test(backend): add comprehensive testing infrastructure

Implement complete backend testing infrastructure with Jest and Supertest:

Test Setup:
- Configure Jest for Node.js environment
- Add MongoDB Memory Server for isolated testing
- Create test setup with database connection helpers
- Add test scripts: test, test:coverage, test:watch

Test Files (176 total tests, 109 passing):
- Middleware tests: auth.test.js (100% coverage)
- Model tests: User, Street, Task, Post (82.5% coverage)
- Route tests: auth, streets, tasks, posts, events, rewards, reports

Test Coverage:
- Overall: 54.75% (on track for 70% target)
- Models: 82.5%
- Middleware: 100%
- Routes: 45.84%

Test Utilities:
- Helper functions for creating test users, streets, tasks, posts
- Test database setup and teardown
- MongoDB Memory Server configuration
- Coverage reporting with lcov

Testing Features:
- Isolated test environment (no production data pollution)
- Async/await test patterns
- Proper setup/teardown for each test
- Authentication testing with JWT tokens
- Validation testing for all routes
- Error handling verification

Scripts:
- Database seeding scripts for development
- Test data generation utilities

Dependencies:
- jest@29.7.0
- supertest@7.0.0
- mongodb-memory-server@10.1.2

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

backend/__tests__/routes/tasks.test.js

@@ -0,0 +1,146 @@
+const request = require('supertest');
+const express = require('express');
+const taskRoutes = require('../../routes/tasks');
+const { createTestUser, createTestStreet, createTestTask } = require('../utils/testHelpers');
+
+const app = express();
+app.use(express.json());
+app.use('/api/tasks', taskRoutes);
+
+describe('Task Routes', () => {
+  describe('GET /api/tasks', () => {
+    it('should get all tasks completed by authenticated user', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      await createTestTask(user.id, street.id, {
+        completedBy: user.id,
+        status: 'completed'
+      });
+      await createTestTask(user.id, street.id, {
+        completedBy: user.id,
+        status: 'completed'
+      });
+
+      const response = await request(app)
+        .get('/api/tasks')
+        .set('x-auth-token', token)
+        .expect(200);
+
+      expect(Array.isArray(response.body)).toBe(true);
+      expect(response.body.length).toBe(2);
+    });
+
+    it('should return empty array when user has no completed tasks', async () => {
+      const { token } = await createTestUser();
+
+      const response = await request(app)
+        .get('/api/tasks')
+        .set('x-auth-token', token)
+        .expect(200);
+
+      expect(Array.isArray(response.body)).toBe(true);
+      expect(response.body.length).toBe(0);
+    });
+
+    it('should not get tasks without authentication', async () => {
+      const response = await request(app)
+        .get('/api/tasks')
+        .expect(401);
+
+      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
+    });
+  });
+
+  describe('POST /api/tasks', () => {
+    it('should create a new task with authentication', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      const taskData = {
+        street: street.id,
+        description: 'Clean the sidewalk',
+      };
+
+      const response = await request(app)
+        .post('/api/tasks')
+        .set('x-auth-token', token)
+        .send(taskData)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('description', taskData.description);
+      expect(response.body).toHaveProperty('street', street.id);
+    });
+
+    it('should not create task without authentication', async () => {
+      const { user } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      const taskData = {
+        street: street.id,
+        description: 'Clean the sidewalk',
+      };
+
+      const response = await request(app)
+        .post('/api/tasks')
+        .send(taskData)
+        .expect(401);
+
+      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
+    });
+  });
+
+  describe('PUT /api/tasks/:id', () => {
+    it('should complete a task', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+      const task = await createTestTask(user.id, street.id, {
+        status: 'pending',
+        completedBy: null
+      });
+
+      const response = await request(app)
+        .put(`/api/tasks/${task.id}`)
+        .set('x-auth-token', token)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('status', 'completed');
+      expect(response.body).toHaveProperty('completedBy', user.id);
+    });
+
+    it('should return 404 for non-existent task', async () => {
+      const { token } = await createTestUser();
+      const fakeId = '507f1f77bcf86cd799439011';
+
+      const response = await request(app)
+        .put(`/api/tasks/${fakeId}`)
+        .set('x-auth-token', token)
+        .expect(404);
+
+      expect(response.body).toHaveProperty('msg', 'Task not found');
+    });
+
+    it('should not complete task without authentication', async () => {
+      const { user } = await createTestUser();
+      const street = await createTestStreet(user.id);
+      const task = await createTestTask(user.id, street.id);
+
+      const response = await request(app)
+        .put(`/api/tasks/${task.id}`)
+        .expect(401);
+
+      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
+    });
+
+    it('should handle invalid task ID format', async () => {
+      const { token } = await createTestUser();
+
+      const response = await request(app)
+        .put('/api/tasks/invalid-id')
+        .set('x-auth-token', token)
+        .expect(500);
+
+      expect(response.body).toBeDefined();
+    });
+  });
+});