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/reports.test.js

@@ -0,0 +1,180 @@
+const request = require('supertest');
+const express = require('express');
+const reportsRoutes = require('../../routes/reports');
+const Report = require('../../models/Report');
+const { createTestUser, createTestStreet, createTestReport } = require('../utils/testHelpers');
+
+// Create Express app for testing
+const app = express();
+app.use(express.json());
+app.use('/api/reports', reportsRoutes);
+
+describe('Reports Routes', () => {
+  describe('GET /api/reports', () => {
+    it('should get all reports', async () => {
+      const { user } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      await createTestReport(user.id, street.id, { type: 'pothole' });
+      await createTestReport(user.id, street.id, { type: 'litter' });
+
+      const response = await request(app)
+        .get('/api/reports')
+        .expect(200);
+
+      expect(Array.isArray(response.body)).toBe(true);
+      expect(response.body.length).toBe(2);
+      expect(response.body[0]).toHaveProperty('type');
+      expect(response.body[0]).toHaveProperty('description');
+    });
+
+    it('should return empty array when no reports exist', async () => {
+      const response = await request(app)
+        .get('/api/reports')
+        .expect(200);
+
+      expect(Array.isArray(response.body)).toBe(true);
+      expect(response.body.length).toBe(0);
+    });
+
+    it('should populate street and user data', async () => {
+      const { user } = await createTestUser({ name: 'Reporter User' });
+      const street = await createTestStreet(user.id, { name: 'Main Street' });
+      await createTestReport(user.id, street.id);
+
+      const response = await request(app)
+        .get('/api/reports')
+        .expect(200);
+
+      expect(response.body[0]).toHaveProperty('street');
+      // Populated fields might be objects or strings depending on the route implementation
+    });
+  });
+
+  describe('POST /api/reports', () => {
+    it('should create a new report with authentication', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      const reportData = {
+        street: street.id,
+        issue: 'Large pothole on Main Street',
+      };
+
+      const response = await request(app)
+        .post('/api/reports')
+        .set('x-auth-token', token)
+        .send(reportData)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('_id');
+      expect(response.body.issue).toBe(reportData.issue);
+      expect(response.body.street.toString()).toBe(street.id);
+
+      // Verify report was created in database
+      const report = await Report.findById(response.body._id);
+      expect(report).toBeTruthy();
+      expect(report.issue).toBe(reportData.issue);
+    });
+
+    it('should reject report creation without authentication', async () => {
+      const { user } = await createTestUser();
+      const street = await createTestStreet(user.id);
+
+      const reportData = {
+        street: street.id,
+        issue: 'Unauthorized report',
+      };
+
+      const response = await request(app)
+        .post('/api/reports')
+        .send(reportData)
+        .expect(401);
+
+      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
+    });
+
+    it('should handle missing required fields', async () => {
+      const { token } = await createTestUser();
+
+      const response = await request(app)
+        .post('/api/reports')
+        .set('x-auth-token', token)
+        .send({ issue: 'Incomplete report' })
+        .expect(500);
+
+      expect(response.body).toBeDefined();
+    });
+  });
+
+  describe('PUT /api/reports/:id', () => {
+    it('should resolve a report with authentication', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+      const report = await createTestReport(user.id, street.id, {
+        status: 'pending'
+      });
+
+      const response = await request(app)
+        .put(`/api/reports/${report.id}`)
+        .set('x-auth-token', token)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('status', 'resolved');
+
+      // Verify report was updated in database
+      const updatedReport = await Report.findById(report.id);
+      expect(updatedReport.status).toBe('resolved');
+    });
+
+    it('should return 404 for non-existent report', async () => {
+      const { token } = await createTestUser();
+      const fakeId = '507f1f77bcf86cd799439011';
+
+      const response = await request(app)
+        .put(`/api/reports/${fakeId}`)
+        .set('x-auth-token', token)
+        .expect(404);
+
+      expect(response.body).toHaveProperty('msg', 'Report not found');
+    });
+
+    it('should reject resolution without authentication', async () => {
+      const { user } = await createTestUser();
+      const street = await createTestStreet(user.id);
+      const report = await createTestReport(user.id, street.id);
+
+      const response = await request(app)
+        .put(`/api/reports/${report.id}`)
+        .expect(401);
+
+      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
+    });
+
+    it('should handle invalid report ID format', async () => {
+      const { token } = await createTestUser();
+
+      const response = await request(app)
+        .put('/api/reports/invalid-id')
+        .set('x-auth-token', token)
+        .expect(500);
+
+      expect(response.body).toBeDefined();
+    });
+
+    it('should allow resolving already resolved reports', async () => {
+      const { user, token } = await createTestUser();
+      const street = await createTestStreet(user.id);
+      const report = await createTestReport(user.id, street.id, {
+        status: 'resolved'
+      });
+
+      const response = await request(app)
+        .put(`/api/reports/${report.id}`)
+        .set('x-auth-token', token)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('status', 'resolved');
+    });
+  });
+});