feat: add comprehensive test coverage for advanced features

- Add Socket.IO real-time feature tests
- Add geospatial query tests with CouchDB integration
- Add gamification system tests (points, badges, leaderboard)
- Add file upload tests with Cloudinary integration
- Add comprehensive error handling tests
- Add performance and stress tests
- Add test documentation and coverage summary
- Install missing testing dependencies (mongodb-memory-server, socket.io-client)

Test Coverage:
- Socket.IO: Authentication, events, rooms, concurrency
- Geospatial: Nearby queries, bounding boxes, performance
- Gamification: Points, badges, transactions, leaderboards
- File Uploads: Profile pictures, posts, reports, validation
- Error Handling: Auth, validation, database, rate limiting
- Performance: Response times, concurrency, memory usage

🤖 Generated with AI Assistant

Co-Authored-By: AI Assistant <noreply@ai-assistant.com>

backend/COMPREHENSIVE_TEST_COVERAGE.md

@@ -0,0 +1,252 @@
+# Comprehensive Test Coverage Summary
+
+I have successfully created comprehensive test suites for all the advanced features requested:
+
+## 1. Socket.IO Real-time Features (`__tests__/socketio.test.js`)
+
+**Coverage:**
+- Socket authentication with valid/invalid tokens
+- Event room joining and leaving
+- Real-time post updates
+- Event participation updates
+- Connection stability under load
+- Concurrent connection handling
+- Multiple room management
+
+**Key Test Scenarios:**
+- ✅ Authentication middleware validation
+- ✅ Event room broadcasting
+- ✅ Post room interactions
+- ✅ Connection stability testing
+- ✅ Performance under concurrent load
+- ✅ Error handling for unauthorized connections
+
+## 2. Geospatial Queries (`__tests__/geospatial.test.js`)
+
+**Coverage:**
+- Street creation with GeoJSON coordinates
+- Nearby street queries with various distances
+- Bounding box queries
+- Location data validation
+- CouchDB geospatial operations
+- Performance testing with large datasets
+- Edge cases and error handling
+
+**Key Test Scenarios:**
+- ✅ Valid/invalid coordinate handling
+- ✅ Distance-based street searches
+- ✅ Bounding box filtering
+- ✅ CouchDB location-based queries
+- ✅ Performance with 1000+ streets
+- ✅ Concurrent geospatial queries
+- ✅ Malformed data handling
+
+## 3. Gamification System (`__tests__/gamification.test.js`)
+
+**Coverage:**
+- Points awarding for all activities
+- Badge earning and progress tracking
+- Leaderboard functionality
+- Point transaction recording
+- Badge criteria validation
+- Performance under concurrent updates
+
+**Key Test Scenarios:**
+- ✅ Street adoption points (50 points)
+- ✅ Task completion points (variable)
+- ✅ Event participation points (15 points)
+- ✅ Post creation points (5 points)
+- ✅ Badge awarding for milestones
+- ✅ Leaderboard ordering and pagination
+- ✅ Transaction history tracking
+- ✅ Concurrent point updates
+
+## 4. File Upload System (`__tests__/fileupload.test.js`)
+
+**Coverage:**
+- Profile picture uploads
+- Post image uploads
+- Report image uploads
+- Cloudinary integration
+- File validation and security
+- Image transformation and optimization
+- Error handling for upload failures
+
+**Key Test Scenarios:**
+- ✅ Profile picture upload with transformation
+- ✅ Post image attachment
+- ✅ Report image upload
+- ✅ File type validation
+- ✅ File size limits
+- ✅ Cloudinary service integration
+- ✅ Concurrent upload handling
+- ✅ Image deletion and cleanup
+
+## 5. Error Handling (`__tests__/errorhandling.test.js`)
+
+**Coverage:**
+- Authentication errors
+- Validation errors
+- Resource not found errors
+- Business logic errors
+- Database connection errors
+- Rate limiting errors
+- Malformed request handling
+- External service failures
+
+**Key Test Scenarios:**
+- ✅ Invalid/expired tokens
+- ✅ Missing required fields
+- ✅ Invalid data formats
+- ✅ Non-existent resources
+- ✅ Duplicate action prevention
+- ✅ Database disconnection handling
+- ✅ Rate limiting enforcement
+- ✅ Malformed JSON/query parameters
+
+## 6. Performance Tests (`__tests__/performance.test.js`)
+
+**Coverage:**
+- API response times
+- Concurrent request handling
+- Memory usage monitoring
+- Database performance
+- Stress testing
+- Resource limits
+- Scalability testing
+
+**Key Test Scenarios:**
+- ✅ Response time benchmarks
+- ✅ Concurrent read/write operations
+- ✅ Memory leak detection
+- ✅ Database query performance
+- ✅ Sustained load testing
+- ✅ Large payload handling
+- ✅ Rate limiting performance
+- ✅ Scalability with data growth
+
+## Test Infrastructure Features
+
+### Mocking Strategy
+- **Cloudinary**: Complete mocking for upload operations
+- **CouchDB**: Service-level mocking for unit tests
+- **Socket.IO**: Client-server simulation
+- **File System**: Buffer-based file simulation
+
+### Test Data Management
+- **MongoDB Memory Server**: Isolated test database
+- **Automatic Cleanup**: Data isolation between tests
+- **Realistic Data**: Geographically distributed test data
+- **User Simulation**: Multiple test users for concurrency
+
+### Performance Benchmarks
+- **Response Time Limits**: 
+  - Health checks: < 50ms
+  - Simple queries: < 200ms
+  - Complex queries: < 400ms
+  - Geospatial queries: < 300ms
+- **Concurrency**: 50+ concurrent requests
+- **Memory**: < 50MB increase during operations
+- **Throughput**: 50+ requests per second
+
+### Security Testing
+- **File Validation**: Type, size, and signature checking
+- **Input Sanitization**: XSS and injection prevention
+- **Authentication**: Token validation and expiration
+- **Authorization**: Resource access control
+- **Rate Limiting**: DDoS protection
+
+## CouchDB Integration Testing
+
+The tests include comprehensive CouchDB integration:
+
+### Design Documents
+- Users, streets, tasks, posts, events, reports, badges
+- Geospatial indexes for location queries
+- Performance-optimized views
+
+### Service Layer Testing
+- CRUD operations with CouchDB
+- Geospatial query implementation
+- Point transaction system
+- Badge progress tracking
+
+### Error Recovery
+- Connection failure handling
+- Conflict resolution
+- Partial failure scenarios
+
+## Raspberry Pi Deployment Considerations
+
+### Performance Optimizations
+- **Memory Efficiency**: Tests monitor memory usage
+- **CPU Usage**: Concurrent request handling
+- **Storage**: Large dataset performance
+- **Network**: External service timeout handling
+
+### Resource Constraints
+- **Limited Memory**: < 1GB on Pi 3B+
+- **ARM Architecture**: Cross-platform compatibility
+- **Storage Optimization**: Efficient data structures
+
+## Test Execution
+
+### Running Individual Test Suites
+```bash
+# Socket.IO tests
+npx jest __tests__/socketio.test.js
+
+# Geospatial tests
+npx jest __tests__/geospatial.test.js
+
+# Gamification tests
+npx jest __tests__/gamification.test.js
+
+# File upload tests
+npx jest __tests__/fileupload.test.js
+
+# Error handling tests
+npx jest __tests__/errorhandling.test.js
+
+# Performance tests
+npx jest __tests__/performance.test.js
+```
+
+### Coverage Reports
+```bash
+# Generate coverage report
+npx jest --coverage
+
+# Coverage for specific features
+npx jest --testPathPattern="socketio" --coverage
+```
+
+## Test Quality Metrics
+
+### Code Coverage Targets
+- **Statements**: 70%
+- **Branches**: 70%
+- **Functions**: 70%
+- **Lines**: 70%
+
+### Test Types
+- **Unit Tests**: Individual function testing
+- **Integration Tests**: Service interaction testing
+- **End-to-End Tests**: Full workflow testing
+- **Performance Tests**: Load and stress testing
+- **Security Tests**: Vulnerability testing
+
+## Future Enhancements
+
+### Additional Test Scenarios
+- **WebSocket Connection Pooling**: Advanced Socket.IO testing
+- **Database Sharding**: Multi-node CouchDB testing
+- **CI/CD Integration**: Automated pipeline testing
+- **Browser Testing**: Frontend integration testing
+
+### Monitoring Integration
+- **Real-time Metrics**: Performance monitoring
+- **Error Tracking**: Automated error reporting
+- **Load Testing**: Continuous performance validation
+
+This comprehensive test suite ensures all advanced features work correctly with the CouchDB backend and maintains performance standards suitable for Raspberry Pi deployment.

backend/__tests__/errorhandling.test.js

@@ -0,0 +1,549 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const app = require("../server");
+const User = require("../models/User");
+
+describe("Error Handling", () => {
+  let mongoServer;
+  let testUser;
+  let authToken;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Create test user
+    testUser = new User({
+      name: "Test User",
+      email: "test@example.com",
+      password: "password123",
+    });
+    await testUser.save();
+
+    // Generate auth token
+    const jwt = require("jsonwebtoken");
+    authToken = jwt.sign(
+      { user: { id: testUser._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  describe("Authentication Errors", () => {
+    test("should reject requests without token", async () => {
+      const response = await request(app)
+        .get("/api/users/profile")
+        .expect(401);
+
+      expect(response.body.msg).toBe("No token, authorization denied");
+    });
+
+    test("should reject requests with invalid token", async () => {
+      const response = await request(app)
+        .get("/api/users/profile")
+        .set("x-auth-token", "invalid_token")
+        .expect(401);
+
+      expect(response.body.msg).toBe("Token is not valid");
+    });
+
+    test("should reject requests with malformed token", async () => {
+      const response = await request(app)
+        .get("/api/users/profile")
+        .set("x-auth-token", "not.a.valid.jwt")
+        .expect(401);
+
+      expect(response.body.msg).toBe("Token is not valid");
+    });
+
+    test("should reject requests with expired token", async () => {
+      const jwt = require("jsonwebtoken");
+      const expiredToken = jwt.sign(
+        { user: { id: testUser._id.toString() } },
+        process.env.JWT_SECRET || "test_secret",
+        { expiresIn: "-1h" } // Expired 1 hour ago
+      );
+
+      const response = await request(app)
+        .get("/api/users/profile")
+        .set("x-auth-token", expiredToken)
+        .expect(401);
+
+      expect(response.body.msg).toBe("Token is not valid");
+    });
+
+    test("should reject requests when user not found", async () => {
+      const jwt = require("jsonwebtoken");
+      const tokenWithNonExistentUser = jwt.sign(
+        { user: { id: new mongoose.Types.ObjectId().toString() } },
+        process.env.JWT_SECRET || "test_secret"
+      );
+
+      const response = await request(app)
+        .get("/api/users/profile")
+        .set("x-auth-token", tokenWithNonExistentUser)
+        .expect(404);
+
+      expect(response.body.msg).toBe("User not found");
+    });
+  });
+
+  describe("Validation Errors", () => {
+    test("should validate required fields in user registration", async () => {
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({})
+        .expect(400);
+
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors.length).toBeGreaterThan(0);
+      
+      const fieldNames = response.body.errors.map(err => err.path);
+      expect(fieldNames).toContain("name");
+      expect(fieldNames).toContain("email");
+      expect(fieldNames).toContain("password");
+    });
+
+    test("should validate email format", async () => {
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({
+          name: "Test User",
+          email: "invalid-email",
+          password: "password123",
+        })
+        .expect(400);
+
+      const emailError = response.body.errors.find(err => err.path === "email");
+      expect(emailError).toBeDefined();
+      expect(emailError.msg).toContain("valid email");
+    });
+
+    test("should validate password strength", async () => {
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({
+          name: "Test User",
+          email: "test@example.com",
+          password: "123", // Too short
+        })
+        .expect(400);
+
+      const passwordError = response.body.errors.find(err => err.path === "password");
+      expect(passwordError).toBeDefined();
+      expect(passwordError.msg).toContain("at least 6 characters");
+    });
+
+    test("should validate street creation data", async () => {
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send({})
+        .expect(400);
+
+      expect(response.body.errors).toBeDefined();
+      
+      const fieldNames = response.body.errors.map(err => err.path);
+      expect(fieldNames).toContain("name");
+      expect(fieldNames).toContain("location");
+    });
+
+    test("should validate GeoJSON location format", async () => {
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send({
+          name: "Test Street",
+          location: {
+            type: "Point",
+            coordinates: "invalid_coordinates",
+          },
+        })
+        .expect(400);
+
+      expect(response.body.msg).toBeDefined();
+    });
+
+    test("should validate coordinate bounds", async () => {
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send({
+          name: "Test Street",
+          location: {
+            type: "Point",
+            coordinates: [200, 100], // Invalid coordinates
+          },
+        })
+        .expect(400);
+
+      expect(response.body.msg).toBeDefined();
+    });
+  });
+
+  describe("Resource Not Found Errors", () => {
+    test("should handle non-existent street", async () => {
+      const nonExistentId = new mongoose.Types.ObjectId().toString();
+
+      const response = await request(app)
+        .get(`/api/streets/${nonExistentId}`)
+        .expect(404);
+
+      expect(response.body.msg).toBe("Street not found");
+    });
+
+    test("should handle non-existent task", async () => {
+      const nonExistentId = new mongoose.Types.ObjectId().toString();
+
+      const response = await request(app)
+        .put(`/api/tasks/${nonExistentId}/complete`)
+        .set("x-auth-token", authToken)
+        .expect(404);
+
+      expect(response.body.msg).toBe("Task not found");
+    });
+
+    test("should handle non-existent event", async () => {
+      const nonExistentId = new mongoose.Types.ObjectId().toString();
+
+      const response = await request(app)
+        .put(`/api/events/rsvp/${nonExistentId}`)
+        .set("x-auth-token", authToken)
+        .expect(404);
+
+      expect(response.body.msg).toBe("Event not found");
+    });
+
+    test("should handle non-existent post", async () => {
+      const nonExistentId = new mongoose.Types.ObjectId().toString();
+
+      const response = await request(app)
+        .get(`/api/posts/${nonExistentId}`)
+        .expect(404);
+
+      expect(response.body.msg).toBe("Post not found");
+    });
+  });
+
+  describe("Business Logic Errors", () => {
+    let testStreet;
+
+    beforeEach(async () => {
+      testStreet = new mongoose.Types.ObjectId();
+    });
+
+    test("should prevent duplicate user registration", async () => {
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({
+          name: "Another User",
+          email: "test@example.com", // Same email as existing user
+          password: "password123",
+        })
+        .expect(400);
+
+      expect(response.body.msg).toContain("already exists");
+    });
+
+    test("should prevent adopting already adopted street", async () => {
+      // First, create and adopt a street
+      const Street = require("../models/Street");
+      const street = new Street({
+        name: "Test Street",
+        location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+        status: "adopted",
+        adoptedBy: {
+          userId: testUser._id,
+          name: testUser.name,
+        },
+      });
+      await street.save();
+
+      // Try to adopt again
+      const response = await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken)
+        .expect(400);
+
+      expect(response.body.msg).toBe("Street already adopted");
+    });
+
+    test("should prevent completing already completed task", async () => {
+      const Task = require("../models/Task");
+      const task = new Task({
+        title: "Test Task",
+        description: "Test Description",
+        street: { streetId: testStreet },
+        status: "completed",
+        completedBy: {
+          userId: testUser._id,
+          name: testUser.name,
+        },
+      });
+      await task.save();
+
+      const response = await request(app)
+        .put(`/api/tasks/${task._id}/complete`)
+        .set("x-auth-token", authToken)
+        .expect(400);
+
+      expect(response.body.msg).toBe("Task already completed");
+    });
+
+    test("should prevent duplicate event RSVP", async () => {
+      const Event = require("../models/Event");
+      const event = new Event({
+        title: "Test Event",
+        description: "Test Description",
+        date: new Date(Date.now() + 86400000),
+        location: "Test Location",
+        participants: [{
+          userId: testUser._id,
+          name: testUser.name,
+        }],
+      });
+      await event.save();
+
+      const response = await request(app)
+        .put(`/api/events/rsvp/${event._id}`)
+        .set("x-auth-token", authToken)
+        .expect(400);
+
+      expect(response.body.msg).toBe("Already RSVPed");
+    });
+  });
+
+  describe("Database Connection Errors", () => {
+    test("should handle database disconnection gracefully", async () => {
+      // Disconnect from database
+      await mongoose.connection.close();
+
+      const response = await request(app)
+        .get("/api/streets")
+        .expect(500);
+
+      expect(response.body.msg).toBeDefined();
+
+      // Reconnect for other tests
+      await mongoose.connect(mongoServer.getUri());
+    });
+
+    test("should handle database operation timeouts", async () => {
+      // Mock a slow database operation
+      const originalFind = mongoose.Model.find;
+      mongoose.Model.find = jest.fn().mockImplementation(() => {
+        return new Promise((resolve, reject) => {
+          setTimeout(() => reject(new Error("Database timeout")), 100);
+        });
+      });
+
+      const response = await request(app)
+        .get("/api/streets")
+        .expect(500);
+
+      expect(response.body.msg).toBeDefined();
+
+      // Restore original method
+      mongoose.Model.find = originalFind;
+    });
+  });
+
+  describe("Rate Limiting Errors", () => {
+    test("should rate limit authentication attempts", async () => {
+      const loginData = {
+        email: "test@example.com",
+        password: "wrongpassword",
+      };
+
+      // Make multiple rapid requests
+      const requests = [];
+      for (let i = 0; i < 6; i++) { // Exceeds limit of 5
+        requests.push(
+          request(app)
+            .post("/api/auth/login")
+            .send(loginData)
+        );
+      }
+
+      const responses = await Promise.all(requests);
+      
+      // At least one should be rate limited
+      const rateLimitedResponse = responses.find(res => res.status === 429);
+      expect(rateLimitedResponse).toBeDefined();
+      expect(rateLimitedResponse.body.error).toContain("Too many authentication attempts");
+    });
+
+    test("should rate limit general API requests", async () => {
+      // Make many rapid requests to exceed general rate limit
+      const requests = [];
+      for (let i = 0; i < 105; i++) { // Exceeds limit of 100
+        requests.push(
+          request(app)
+            .get("/api/streets")
+            .set("x-auth-token", authToken)
+        );
+      }
+
+      const responses = await Promise.all(requests);
+      
+      // At least one should be rate limited
+      const rateLimitedResponse = responses.find(res => res.status === 429);
+      expect(rateLimitedResponse).toBeDefined();
+      expect(rateLimitedResponse.body.error).toContain("Too many requests");
+    });
+  });
+
+  describe("Malformed Request Errors", () => {
+    test("should handle invalid JSON", async () => {
+      const response = await request(app)
+        .post("/api/auth/login")
+        .set("Content-Type", "application/json")
+        .send('{"email": "test@example.com", "password": "password123"') // Missing closing brace
+        .expect(400);
+
+      expect(response.body.msg).toBeDefined();
+    });
+
+    test("should handle invalid query parameters", async () => {
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: "invalid_longitude",
+          lat: "invalid_latitude",
+          maxDistance: "not_a_number",
+        })
+        .expect(400);
+
+      expect(response.body.msg).toBeDefined();
+    });
+
+    test("should handle oversized request body", async () => {
+      const largeData = {
+        content: "x".repeat(1000000), // 1MB of text
+      };
+
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .send(largeData)
+        .expect(413); // Payload Too Large
+
+      expect(response.body.msg).toBeDefined();
+    });
+
+    test("should handle unsupported HTTP methods", async () => {
+      const response = await request(app)
+        .patch("/api/auth/login")
+        .expect(404); // Not Found or Method Not Allowed
+
+      expect(response.body.msg).toBeDefined();
+    });
+  });
+
+  describe("External Service Errors", () => {
+    test("should handle Cloudinary upload failures", async () => {
+      // Mock Cloudinary failure
+      const cloudinary = require("cloudinary").v2;
+      cloudinary.uploader.upload.mockRejectedValue(new Error("Cloudinary service unavailable"));
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg")
+        .expect(500);
+
+      expect(response.body.msg).toContain("Error uploading profile picture");
+    });
+
+    test("should handle email service failures", async () => {
+      // Mock email service failure
+      const nodemailer = require("nodemailer");
+      const mockSendMail = jest.fn().mockRejectedValue(new Error("Email service unavailable"));
+      nodemailer.createTransport.mockReturnValue({
+        sendMail: mockSendMail,
+      });
+
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({
+          name: "Test User",
+          email: "newuser@example.com",
+          password: "password123",
+        })
+        .expect(500);
+
+      expect(response.body.msg).toBeDefined();
+    });
+  });
+
+  describe("Error Response Format", () => {
+    test("should return consistent error response format", async () => {
+      const response = await request(app)
+        .get("/api/nonexistent-endpoint")
+        .expect(404);
+
+      expect(response.body).toHaveProperty("msg");
+      expect(typeof response.body.msg).toBe("string");
+    });
+
+    test("should include error details for validation errors", async () => {
+      const response = await request(app)
+        .post("/api/auth/register")
+        .send({
+          name: "",
+          email: "invalid-email",
+          password: "123",
+        })
+        .expect(400);
+
+      expect(response.body).toHaveProperty("errors");
+      expect(Array.isArray(response.body.errors)).toBe(true);
+      expect(response.body.errors[0]).toHaveProperty("path");
+      expect(response.body.errors[0]).toHaveProperty("msg");
+    });
+
+    test("should sanitize error messages in production", async () => {
+      // Set NODE_ENV to production
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = "production";
+
+      const response = await request(app)
+        .get("/api/streets")
+        .expect(500);
+
+      // Should not expose internal error details
+      expect(response.body.msg).toBe("Server error");
+
+      // Restore original environment
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe("CORS Errors", () => {
+    test("should handle cross-origin requests properly", async () => {
+      const response = await request(app)
+        .options("/api/streets")
+        .set("Origin", "http://localhost:3000")
+        .expect(200);
+
+      expect(response.headers["access-control-allow-origin"]).toBeDefined();
+    });
+
+    test("should reject requests from unauthorized origins", async () => {
+      // This test depends on CORS configuration
+      // In production, you might want to reject certain origins
+      const response = await request(app)
+        .get("/api/streets")
+        .set("Origin", "http://malicious-site.com")
+        .expect(200); // Currently allows all origins, but could be restricted
+
+      // If CORS is properly restricted, this would be 401 or 403
+    });
+  });
+});

backend/__tests__/fileupload.test.js

@@ -0,0 +1,515 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const multer = require("multer");
+const cloudinary = require("cloudinary").v2;
+const app = require("../server");
+const User = require("../models/User");
+const Post = require("../models/Post");
+const Report = require("../models/Report");
+
+// Mock Cloudinary
+jest.mock("cloudinary", () => ({
+  v2: {
+    config: jest.fn(),
+    uploader: {
+      upload: jest.fn(),
+      destroy: jest.fn(),
+    },
+  },
+}));
+
+describe("File Upload System", () => {
+  let mongoServer;
+  let testUser;
+  let authToken;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Configure test Cloudinary settings
+    cloudinary.config({
+      cloud_name: "test_cloud",
+      api_key: "test_key",
+      api_secret: "test_secret",
+    });
+
+    // Create test user
+    testUser = new User({
+      name: "Test User",
+      email: "test@example.com",
+      password: "password123",
+    });
+    await testUser.save();
+
+    // Generate auth token
+    const jwt = require("jsonwebtoken");
+    authToken = jwt.sign(
+      { user: { id: testUser._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  beforeEach(() => {
+    // Reset Cloudinary mocks
+    cloudinary.uploader.upload.mockReset();
+    cloudinary.uploader.destroy.mockReset();
+  });
+
+  describe("Profile Picture Upload", () => {
+    test("should upload profile picture successfully", async () => {
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/profile.jpg",
+        public_id: "profile_test123",
+        width: 500,
+        height: 500,
+        format: "jpg",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg")
+        .expect(200);
+
+      expect(response.body.profilePicture).toBe(mockCloudinaryResponse.secure_url);
+      expect(response.body.cloudinaryPublicId).toBe(mockCloudinaryResponse.public_id);
+
+      // Verify Cloudinary upload was called with correct options
+      expect(cloudinary.uploader.upload).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        expect.objectContaining({
+          folder: "profile-pictures",
+          transformation: [
+            { width: 500, height: 500, crop: "fill" },
+            { quality: "auto" },
+          ],
+        })
+      );
+
+      // Verify user was updated
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.profilePicture).toBe(mockCloudinaryResponse.secure_url);
+    });
+
+    test("should reject invalid file types for profile picture", async () => {
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake file data"), "document.pdf")
+        .expect(400);
+
+      expect(response.body.msg).toContain("Only image files are allowed");
+    });
+
+    test("should reject oversized files for profile picture", async () => {
+      // Create a large buffer (6MB)
+      const largeBuffer = Buffer.alloc(6 * 1024 * 1024, "a");
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", largeBuffer, "large.jpg")
+        .expect(400);
+
+      expect(response.body.msg).toContain("File size too large");
+    });
+
+    test("should handle Cloudinary upload errors", async () => {
+      cloudinary.uploader.upload.mockRejectedValue(new Error("Cloudinary error"));
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg")
+        .expect(500);
+
+      expect(response.body.msg).toContain("Error uploading profile picture");
+    });
+
+    test("should require authentication for profile picture upload", async () => {
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg")
+        .expect(401);
+    });
+  });
+
+  describe("Post Image Upload", () => {
+    test("should upload post image successfully", async () => {
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/post.jpg",
+        public_id: "post_test123",
+        width: 800,
+        height: 600,
+        format: "jpg",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+
+      const postData = {
+        content: "Test post with image",
+      };
+
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .field("content", postData.content)
+        .attach("image", Buffer.from("fake image data"), "post.jpg")
+        .expect(200);
+
+      expect(response.body.imageUrl).toBe(mockCloudinaryResponse.secure_url);
+      expect(response.body.cloudinaryPublicId).toBe(mockCloudinaryResponse.public_id);
+      expect(response.body.content).toBe(postData.content);
+
+      // Verify Cloudinary upload was called with correct options
+      expect(cloudinary.uploader.upload).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        expect.objectContaining({
+          folder: "post-images",
+          transformation: [
+            { width: 1200, height: 800, crop: "limit" },
+            { quality: "auto" },
+          ],
+        })
+      );
+
+      // Verify post was created with image
+      const post = await Post.findById(response.body._id);
+      expect(post.imageUrl).toBe(mockCloudinaryResponse.secure_url);
+      expect(post.cloudinaryPublicId).toBe(mockCloudinaryResponse.public_id);
+    });
+
+    test("should create post without image", async () => {
+      const postData = {
+        content: "Test post without image",
+      };
+
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .send(postData)
+        .expect(200);
+
+      expect(response.body.content).toBe(postData.content);
+      expect(response.body.imageUrl).toBeUndefined();
+      expect(response.body.cloudinaryPublicId).toBeUndefined();
+    });
+
+    test("should reject invalid file types for post image", async () => {
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .field("content", "Test post")
+        .attach("image", Buffer.from("fake file data"), "document.pdf")
+        .expect(400);
+
+      expect(response.body.msg).toContain("Only image files are allowed");
+    });
+
+    test("should handle post image upload errors gracefully", async () => {
+      cloudinary.uploader.upload.mockRejectedValue(new Error("Upload failed"));
+
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .field("content", "Test post")
+        .attach("image", Buffer.from("fake image data"), "post.jpg")
+        .expect(500);
+
+      expect(response.body.msg).toContain("Error creating post");
+    });
+  });
+
+  describe("Report Image Upload", () => {
+    let testStreet;
+
+    beforeEach(async () => {
+      testStreet = new mongoose.Types.ObjectId();
+    });
+
+    test("should upload report image successfully", async () => {
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/report.jpg",
+        public_id: "report_test123",
+        width: 800,
+        height: 600,
+        format: "jpg",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+
+      const reportData = {
+        street: { streetId: testStreet.toString() },
+        issue: "Pothole on the street",
+      };
+
+      const response = await request(app)
+        .post("/api/reports")
+        .set("x-auth-token", authToken)
+        .field("street[streetId]", reportData.street.streetId)
+        .field("issue", reportData.issue)
+        .attach("image", Buffer.from("fake image data"), "report.jpg")
+        .expect(200);
+
+      expect(response.body.imageUrl).toBe(mockCloudinaryResponse.secure_url);
+      expect(response.body.cloudinaryPublicId).toBe(mockCloudinaryResponse.public_id);
+      expect(response.body.issue).toBe(reportData.issue);
+
+      // Verify Cloudinary upload was called with correct options
+      expect(cloudinary.uploader.upload).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        expect.objectContaining({
+          folder: "report-images",
+          transformation: [
+            { width: 1200, height: 800, crop: "limit" },
+            { quality: "auto" },
+          ],
+        })
+      );
+
+      // Verify report was created with image
+      const report = await Report.findById(response.body._id);
+      expect(report.imageUrl).toBe(mockCloudinaryResponse.secure_url);
+      expect(report.cloudinaryPublicId).toBe(mockCloudinaryResponse.public_id);
+    });
+
+    test("should create report without image", async () => {
+      const reportData = {
+        street: { streetId: testStreet.toString() },
+        issue: "Street light not working",
+      };
+
+      const response = await request(app)
+        .post("/api/reports")
+        .set("x-auth-token", authToken)
+        .send(reportData)
+        .expect(200);
+
+      expect(response.body.issue).toBe(reportData.issue);
+      expect(response.body.imageUrl).toBeUndefined();
+      expect(response.body.cloudinaryPublicId).toBeUndefined();
+    });
+
+    test("should reject oversized report images", async () => {
+      const largeBuffer = Buffer.alloc(8 * 1024 * 1024, "a"); // 8MB
+
+      const response = await request(app)
+        .post("/api/reports")
+        .set("x-auth-token", authToken)
+        .field("street[streetId]", testStreet.toString())
+        .field("issue", "Test issue")
+        .attach("image", largeBuffer, "large.jpg")
+        .expect(400);
+
+      expect(response.body.msg).toContain("File size too large");
+    });
+  });
+
+  describe("Image Deletion and Cleanup", () => {
+    test("should delete old profile picture when uploading new one", async () => {
+      // Set initial profile picture
+      await User.findByIdAndUpdate(testUser._id, {
+        profilePicture: "https://cloudinary.com/test/old_profile.jpg",
+        cloudinaryPublicId: "old_profile123",
+      });
+
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/new_profile.jpg",
+        public_id: "new_profile456",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+      cloudinary.uploader.destroy.mockResolvedValue({ result: "ok" });
+
+      await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "new_profile.jpg")
+        .expect(200);
+
+      // Verify old image was deleted
+      expect(cloudinary.uploader.destroy).toHaveBeenCalledWith("old_profile123");
+    });
+
+    test("should handle image deletion errors gracefully", async () => {
+      // Set initial profile picture
+      await User.findByIdAndUpdate(testUser._id, {
+        profilePicture: "https://cloudinary.com/test/old_profile.jpg",
+        cloudinaryPublicId: "old_profile123",
+      });
+
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/new_profile.jpg",
+        public_id: "new_profile456",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+      cloudinary.uploader.destroy.mockRejectedValue(new Error("Delete failed"));
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "new_profile.jpg")
+        .expect(200);
+
+      // Should still succeed even if deletion fails
+      expect(response.body.profilePicture).toBe(mockCloudinaryResponse.secure_url);
+    });
+  });
+
+  describe("File Validation and Security", () => {
+    test("should validate image file signatures", async () => {
+      // Create a buffer with PDF signature but .jpg extension
+      const pdfBuffer = Buffer.from("%PDF-1.4", "binary");
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", pdfBuffer, "fake.jpg")
+        .expect(400);
+
+      expect(response.body.msg).toContain("Invalid image file");
+    });
+
+    test("should sanitize filenames", async () => {
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/profile.jpg",
+        public_id: "profile_sanitized123",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+
+      await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "../../../etc/passwd.jpg")
+        .expect(200);
+
+      // Verify Cloudinary was called and didn't use malicious filename
+      expect(cloudinary.uploader.upload).toHaveBeenCalled();
+      expect(cloudinary.uploader.upload).not.toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          public_id: expect.stringContaining("../"),
+        })
+      );
+    });
+
+    test("should apply appropriate transformations for different use cases", async () => {
+      const mockProfileResponse = {
+        secure_url: "https://cloudinary.com/test/profile.jpg",
+        public_id: "profile123",
+      };
+
+      const mockPostResponse = {
+        secure_url: "https://cloudinary.com/test/post.jpg",
+        public_id: "post123",
+      };
+
+      cloudinary.uploader.upload
+        .mockResolvedValueOnce(mockProfileResponse)
+        .mockResolvedValueOnce(mockPostResponse);
+
+      // Test profile picture upload
+      await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg");
+
+      // Verify profile picture transformations
+      expect(cloudinary.uploader.upload).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        expect.objectContaining({
+          transformation: [
+            { width: 500, height: 500, crop: "fill" },
+            { quality: "auto" },
+          ],
+        })
+      );
+
+      // Test post image upload
+      await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .field("content", "Test post")
+        .attach("image", Buffer.from("fake image data"), "post.jpg");
+
+      // Verify post image transformations
+      expect(cloudinary.uploader.upload).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        expect.objectContaining({
+          transformation: [
+            { width: 1200, height: 800, crop: "limit" },
+            { quality: "auto" },
+          ],
+        })
+      );
+    });
+  });
+
+  describe("Performance and Concurrent Uploads", () => {
+    test("should handle concurrent image uploads", async () => {
+      const mockCloudinaryResponse = {
+        secure_url: "https://cloudinary.com/test/concurrent.jpg",
+        public_id: "concurrent123",
+      };
+
+      cloudinary.uploader.upload.mockResolvedValue(mockCloudinaryResponse);
+
+      const startTime = Date.now();
+
+      // Create 10 concurrent upload requests
+      const uploads = [];
+      for (let i = 0; i < 10; i++) {
+        uploads.push(
+          request(app)
+            .put("/api/users/profile-picture")
+            .set("x-auth-token", authToken)
+            .attach("profilePicture", Buffer.from(`fake image data ${i}`), `profile${i}.jpg`)
+        );
+      }
+
+      const responses = await Promise.all(uploads);
+      const endTime = Date.now();
+
+      // All uploads should succeed
+      responses.forEach((response) => {
+        expect(response.status).toBe(200);
+        expect(response.body.profilePicture).toBe(mockCloudinaryResponse.secure_url);
+      });
+
+      // Should complete within reasonable time (less than 10 seconds)
+      expect(endTime - startTime).toBeLessThan(10000);
+
+      // Verify Cloudinary was called 10 times
+      expect(cloudinary.uploader.upload).toHaveBeenCalledTimes(10);
+    });
+
+    test("should handle upload timeout gracefully", async () => {
+      // Mock a slow upload that times out
+      cloudinary.uploader.upload.mockImplementation(() => 
+        new Promise((resolve, reject) => {
+          setTimeout(() => reject(new Error("Upload timeout")), 100);
+        })
+      );
+
+      const response = await request(app)
+        .put("/api/users/profile-picture")
+        .set("x-auth-token", authToken)
+        .attach("profilePicture", Buffer.from("fake image data"), "profile.jpg")
+        .expect(500);
+
+      expect(response.body.msg).toContain("Error uploading profile picture");
+    });
+  });
+});

backend/__tests__/gamification.test.js

@@ -0,0 +1,620 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const app = require("../server");
+const User = require("../models/User");
+const Task = require("../models/Task");
+const Street = require("../models/Street");
+const Event = require("../models/Event");
+const Post = require("../models/Post");
+const couchdbService = require("../services/couchdbService");
+
+describe("Gamification System", () => {
+  let mongoServer;
+  let testUser;
+  let testUser2;
+  let authToken;
+  let authToken2;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Initialize CouchDB for testing
+    await couchdbService.initialize();
+
+    // Create test users
+    testUser = new User({
+      name: "Test User",
+      email: "test@example.com",
+      password: "password123",
+      points: 0,
+      stats: {
+        streetsAdopted: 0,
+        tasksCompleted: 0,
+        postsCreated: 0,
+        eventsParticipated: 0,
+        badgesEarned: 0,
+      },
+    });
+    await testUser.save();
+
+    testUser2 = new User({
+      name: "Test User 2",
+      email: "test2@example.com",
+      password: "password123",
+      points: 100,
+      stats: {
+        streetsAdopted: 1,
+        tasksCompleted: 5,
+        postsCreated: 3,
+        eventsParticipated: 2,
+        badgesEarned: 2,
+      },
+    });
+    await testUser2.save();
+
+    // Generate auth tokens
+    const jwt = require("jsonwebtoken");
+    authToken = jwt.sign(
+      { user: { id: testUser._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+    authToken2 = jwt.sign(
+      { user: { id: testUser2._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+
+    // Create test badges in CouchDB
+    const badges = [
+      {
+        _id: "badge_starter",
+        type: "badge",
+        name: "Street Starter",
+        description: "Adopt your first street",
+        icon: "🏠",
+        rarity: "common",
+        criteria: { type: "street_adoptions", threshold: 1 },
+        isActive: true,
+        order: 1,
+      },
+      {
+        _id: "badge_task_master",
+        type: "badge",
+        name: "Task Master",
+        description: "Complete 10 tasks",
+        icon: "✅",
+        rarity: "rare",
+        criteria: { type: "task_completions", threshold: 10 },
+        isActive: true,
+        order: 2,
+      },
+      {
+        _id: "badge_social_butterfly",
+        type: "badge",
+        name: "Social Butterfly",
+        description: "Create 20 posts",
+        icon: "🦋",
+        rarity: "epic",
+        criteria: { type: "post_creations", threshold: 20 },
+        isActive: true,
+        order: 3,
+      },
+      {
+        _id: "badge_event_enthusiast",
+        type: "badge",
+        name: "Event Enthusiast",
+        description: "Participate in 5 events",
+        icon: "🎉",
+        rarity: "rare",
+        criteria: { type: "event_participations", threshold: 5 },
+        isActive: true,
+        order: 4,
+      },
+      {
+        _id: "badge_point_collector",
+        type: "badge",
+        name: "Point Collector",
+        description: "Earn 500 points",
+        icon: "💰",
+        rarity: "legendary",
+        criteria: { type: "points_earned", threshold: 500 },
+        isActive: true,
+        order: 5,
+      },
+    ];
+
+    for (const badge of badges) {
+      await couchdbService.createDocument(badge);
+    }
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+    await couchdbService.shutdown();
+  });
+
+  beforeEach(async () => {
+    // Reset user points and stats
+    await User.findByIdAndUpdate(testUser._id, {
+      points: 0,
+      stats: {
+        streetsAdopted: 0,
+        tasksCompleted: 0,
+        postsCreated: 0,
+        eventsParticipated: 0,
+        badgesEarned: 0,
+      },
+      earnedBadges: [],
+    });
+  });
+
+  describe("Points System", () => {
+    test("should award points for street adoption", async () => {
+      const street = new Street({
+        name: "Test Street",
+        location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+        status: "available",
+      });
+      await street.save();
+
+      const response = await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken)
+        .expect(200);
+
+      expect(response.body.pointsAwarded).toBe(50);
+      expect(response.body.newBalance).toBe(50);
+
+      // Verify user points updated
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.points).toBe(50);
+      expect(updatedUser.stats.streetsAdopted).toBe(1);
+    });
+
+    test("should award points for task completion", async () => {
+      const task = new Task({
+        title: "Test Task",
+        description: "Test Description",
+        street: { streetId: new mongoose.Types.ObjectId() },
+        pointsAwarded: 10,
+        status: "pending",
+      });
+      await task.save();
+
+      const response = await request(app)
+        .put(`/api/tasks/${task._id}/complete`)
+        .set("x-auth-token", authToken)
+        .expect(200);
+
+      expect(response.body.pointsAwarded).toBe(10);
+      expect(response.body.newBalance).toBe(10);
+
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.points).toBe(10);
+      expect(updatedUser.stats.tasksCompleted).toBe(1);
+    });
+
+    test("should award points for event participation", async () => {
+      const event = new Event({
+        title: "Test Event",
+        description: "Test Description",
+        date: new Date(Date.now() + 86400000),
+        location: "Test Location",
+        participants: [],
+      });
+      await event.save();
+
+      const response = await request(app)
+        .put(`/api/events/rsvp/${event._id}`)
+        .set("x-auth-token", authToken)
+        .expect(200);
+
+      expect(response.body.pointsAwarded).toBe(15);
+      expect(response.body.newBalance).toBe(15);
+
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.points).toBe(15);
+      expect(updatedUser.stats.eventsParticipated).toBe(1);
+    });
+
+    test("should award points for post creation", async () => {
+      const postData = {
+        content: "This is a test post",
+      };
+
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authToken)
+        .send(postData)
+        .expect(200);
+
+      // Points are awarded through CouchDB service
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.points).toBe(5);
+      expect(updatedUser.stats.postsCreated).toBe(1);
+    });
+
+    test("should track point transactions", async () => {
+      // Create some activity to generate transactions
+      const street = new Street({
+        name: "Test Street",
+        location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+        status: "available",
+      });
+      await street.save();
+
+      await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken);
+
+      // Check CouchDB for transactions
+      const transactions = await couchdbService.findByType('point_transaction', {
+        'user.userId': testUser._id.toString()
+      });
+
+      expect(transactions.length).toBe(1);
+      expect(transactions[0].amount).toBe(50);
+      expect(transactions[0].description).toBe('Street adoption');
+      expect(transactions[0].balanceAfter).toBe(50);
+    });
+
+    test("should prevent negative points", async () => {
+      // Try to deduct more points than user has
+      await expect(
+        couchdbService.updateUserPoints(testUser._id.toString(), -100, "Penalty")
+      ).rejects.toThrow();
+
+      const user = await User.findById(testUser._id);
+      expect(user.points).toBe(0);
+    });
+  });
+
+  describe("Badge System", () => {
+    test("should award street adoption badge", async () => {
+      // Adopt a street
+      const street = new Street({
+        name: "Test Street",
+        location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+        status: "available",
+      });
+      await street.save();
+
+      await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken);
+
+      // Check if badge was awarded
+      const updatedUser = await User.findById(testUser._id);
+      expect(updatedUser.earnedBadges.length).toBe(1);
+      expect(updatedUser.earnedBadges[0].name).toBe("Street Starter");
+      expect(updatedUser.stats.badgesEarned).toBe(1);
+    });
+
+    test("should award task completion badge", async () => {
+      // Complete 10 tasks
+      for (let i = 0; i < 10; i++) {
+        const task = new Task({
+          title: `Task ${i}`,
+          description: "Test Description",
+          street: { streetId: new mongoose.Types.ObjectId() },
+          pointsAwarded: 10,
+          status: "pending",
+        });
+        await task.save();
+
+        await request(app)
+          .put(`/api/tasks/${task._id}/complete`)
+          .set("x-auth-token", authToken);
+      }
+
+      // Check if badge was awarded
+      const updatedUser = await User.findById(testUser._id);
+      const taskMasterBadge = updatedUser.earnedBadges.find(
+        (badge) => badge.name === "Task Master"
+      );
+      expect(taskMasterBadge).toBeDefined();
+      expect(taskMasterBadge.rarity).toBe("rare");
+    });
+
+    test("should track badge progress", async () => {
+      // Create 5 posts (out of 20 needed for Social Butterfly badge)
+      for (let i = 0; i < 5; i++) {
+        await request(app)
+          .post("/api/posts")
+          .set("x-auth-token", authToken)
+          .send({ content: `Test post ${i}` });
+      }
+
+      // Check badge progress in CouchDB
+      const userBadges = await couchdbService.findByType('user_badge', {
+        userId: testUser._id.toString()
+      });
+
+      const socialButterflyProgress = userBadges.find(
+        (badge) => badge.badgeId === "badge_social_butterfly"
+      );
+
+      expect(socialButterflyProgress).toBeDefined();
+      expect(socialButterflyProgress.progress).toBe(25); // 5/20 = 25%
+    });
+
+    test("should not award duplicate badges", async () => {
+      // Adopt a street twice (second attempt should fail but still check badges)
+      const street = new Street({
+        name: "Test Street",
+        location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+        status: "available",
+      });
+      await street.save();
+
+      await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken);
+
+      // Try to adopt again (should fail)
+      await request(app)
+        .put(`/api/streets/adopt/${street._id}`)
+        .set("x-auth-token", authToken)
+        .expect(400);
+
+      // Should still only have one badge
+      const updatedUser = await User.findById(testUser._id);
+      const streetStarterBadges = updatedUser.earnedBadges.filter(
+        (badge) => badge.name === "Street Starter"
+      );
+      expect(streetStarterBadges.length).toBe(1);
+    });
+
+    test("should award point-based badge", async () => {
+      // Accumulate 500 points through various activities
+      const activities = [
+        { type: 'street', points: 50, count: 4 }, // 4 street adoptions = 200 points
+        { type: 'task', points: 10, count: 20 }, // 20 tasks = 200 points
+        { type: 'event', points: 15, count: 6 }, // 6 events = 90 points
+        { type: 'post', points: 5, count: 2 }, // 2 posts = 10 points
+      ];
+
+      for (const activity of activities) {
+        for (let i = 0; i < activity.count; i++) {
+          if (activity.type === 'street') {
+            const street = new Street({
+              name: `Street ${i}`,
+              location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+              status: "available",
+            });
+            await street.save();
+            await request(app)
+              .put(`/api/streets/adopt/${street._id}`)
+              .set("x-auth-token", authToken);
+          } else if (activity.type === 'task') {
+            const task = new Task({
+              title: `Task ${i}`,
+              description: "Test Description",
+              street: { streetId: new mongoose.Types.ObjectId() },
+              pointsAwarded: activity.points,
+              status: "pending",
+            });
+            await task.save();
+            await request(app)
+              .put(`/api/tasks/${task._id}/complete`)
+              .set("x-auth-token", authToken);
+          } else if (activity.type === 'event') {
+            const event = new Event({
+              title: `Event ${i}`,
+              description: "Test Description",
+              date: new Date(Date.now() + 86400000),
+              location: "Test Location",
+              participants: [],
+            });
+            await event.save();
+            await request(app)
+              .put(`/api/events/rsvp/${event._id}`)
+              .set("x-auth-token", authToken);
+          } else if (activity.type === 'post') {
+            await request(app)
+              .post("/api/posts")
+              .set("x-auth-token", authToken)
+              .send({ content: `Test post ${i}` });
+          }
+        }
+      }
+
+      // Check if Point Collector badge was awarded
+      const updatedUser = await User.findById(testUser._id);
+      const pointCollectorBadge = updatedUser.earnedBadges.find(
+        (badge) => badge.name === "Point Collector"
+      );
+      expect(pointCollectorBadge).toBeDefined();
+      expect(pointCollectorBadge.rarity).toBe("legendary");
+    });
+  });
+
+  describe("Leaderboard System", () => {
+    beforeEach(async () => {
+      // Set up users with different point levels
+      await User.findByIdAndUpdate(testUser._id, { points: 250 });
+      await User.findByIdAndUpdate(testUser2._id, { points: 450 });
+
+      // Create a third user
+      const testUser3 = new User({
+        name: "Leader User",
+        email: "leader@example.com",
+        password: "password123",
+        points: 750,
+        stats: {
+          streetsAdopted: 5,
+          tasksCompleted: 25,
+          postsCreated: 10,
+          eventsParticipated: 8,
+          badgesEarned: 4,
+        },
+      });
+      await testUser3.save();
+    });
+
+    test("should return leaderboard in correct order", async () => {
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      expect(response.body.length).toBe(3);
+      expect(response.body[0].points).toBe(750);
+      expect(response.body[0].name).toBe("Leader User");
+      expect(response.body[1].points).toBe(450);
+      expect(response.body[2].points).toBe(250);
+    });
+
+    test("should limit leaderboard results", async () => {
+      const response = await request(app)
+        .get("/api/rewards/leaderboard?limit=2")
+        .expect(200);
+
+      expect(response.body.length).toBe(2);
+      expect(response.body[0].points).toBe(750);
+      expect(response.body[1].points).toBe(450);
+    });
+
+    test("should include user stats in leaderboard", async () => {
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      const leader = response.body[0];
+      expect(leader.stats).toBeDefined();
+      expect(leader.stats.streetsAdopted).toBe(5);
+      expect(leader.stats.tasksCompleted).toBe(25);
+      expect(leader.stats.badgesEarned).toBe(4);
+    });
+
+    test("should handle empty leaderboard", async () => {
+      // Delete all users
+      await User.deleteMany({});
+
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      expect(response.body).toHaveLength(0);
+    });
+  });
+
+  describe("Point Transactions", () => {
+    test("should create transaction record for point changes", async () => {
+      await couchdbService.updateUserPoints(
+        testUser._id.toString(),
+        25,
+        "Test transaction",
+        {
+          entityType: "Test",
+          entityId: "test123",
+          entityName: "Test Entity"
+        }
+      );
+
+      const transactions = await couchdbService.findByType('point_transaction', {
+        'user.userId': testUser._id.toString()
+      });
+
+      expect(transactions.length).toBe(1);
+      expect(transactions[0].amount).toBe(25);
+      expect(transactions[0].description).toBe("Test transaction");
+      expect(transactions[0].relatedEntity.entityType).toBe("Test");
+      expect(transactions[0].relatedEntity.entityId).toBe("test123");
+      expect(transactions[0].balanceAfter).toBe(25);
+    });
+
+    test("should track transaction history", async () => {
+      // Create multiple transactions
+      await couchdbService.updateUserPoints(testUser._id.toString(), 50, "Street adoption");
+      await couchdbService.updateUserPoints(testUser._id.toString(), 10, "Task completion");
+      await couchdbService.updateUserPoints(testUser._id.toString(), 15, "Event participation");
+
+      const transactions = await couchdbService.findByType('point_transaction', {
+        'user.userId': testUser._id.toString()
+      }, {
+        sort: [{ createdAt: 'desc' }]
+      });
+
+      expect(transactions.length).toBe(3);
+      expect(transactions[0].amount).toBe(15); // Most recent
+      expect(transactions[1].amount).toBe(10);
+      expect(transactions[2].amount).toBe(50); // Oldest
+    });
+
+    test("should categorize transactions correctly", async () => {
+      await couchdbService.updateUserPoints(testUser._id.toString(), 50, "Street adoption");
+      await couchdbService.updateUserPoints(testUser._id.toString(), 10, "Completed task: Test task");
+      await couchdbService.updateUserPoints(testUser._id.toString(), 5, "Created post: Test post");
+      await couchdbService.updateUserPoints(testUser._id.toString(), 15, "Joined event: Test event");
+
+      const transactions = await couchdbService.findByType('point_transaction', {
+        'user.userId': testUser._id.toString()
+      });
+
+      const types = transactions.map(t => t.type);
+      expect(types).toContain('street_adoption');
+      expect(types).toContain('task_completion');
+      expect(types).toContain('post_creation');
+      expect(types).toContain('event_participation');
+    });
+  });
+
+  describe("Performance Tests", () => {
+    test("should handle concurrent point updates", async () => {
+      const startTime = Date.now();
+
+      const promises = [];
+      for (let i = 0; i < 50; i++) {
+        promises.push(
+          couchdbService.updateUserPoints(
+            testUser._id.toString(),
+            5,
+            `Concurrent transaction ${i}`
+          )
+        );
+      }
+
+      await Promise.all(promises);
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should complete within 5 seconds
+      expect(duration).toBeLessThan(5000);
+
+      // Check final balance
+      const user = await User.findById(testUser._id);
+      expect(user.points).toBe(250); // 50 * 5
+    });
+
+    test("should handle large leaderboard efficiently", async () => {
+      // Create many users
+      const users = [];
+      for (let i = 0; i < 100; i++) {
+        users.push({
+          name: `User ${i}`,
+          email: `user${i}@example.com`,
+          password: "password123",
+          points: Math.floor(Math.random() * 1000),
+        });
+      }
+      await User.insertMany(users);
+
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should complete within 2 seconds even with 100+ users
+      expect(duration).toBeLessThan(2000);
+      expect(response.body.length).toBeGreaterThan(100);
+    });
+  });
+});

backend/__tests__/geospatial.test.js

@@ -0,0 +1,510 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const app = require("../server");
+const Street = require("../models/Street");
+const User = require("../models/User");
+const couchdbService = require("../services/couchdbService");
+
+describe("Geospatial Queries", () => {
+  let mongoServer;
+  let testUser;
+  let authToken;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Initialize CouchDB for testing
+    await couchdbService.initialize();
+
+    // Create test user
+    testUser = new User({
+      name: "Test User",
+      email: "test@example.com",
+      password: "password123",
+    });
+    await testUser.save();
+
+    // Generate auth token
+    const jwt = require("jsonwebtoken");
+    authToken = jwt.sign(
+      { user: { id: testUser._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+    await couchdbService.shutdown();
+  });
+
+  beforeEach(async () => {
+    // Clean up streets before each test
+    await Street.deleteMany({});
+  });
+
+  describe("Street Creation with Coordinates", () => {
+    test("should create street with valid GeoJSON coordinates", async () => {
+      const streetData = {
+        name: "Test Street",
+        location: {
+          type: "Point",
+          coordinates: [-74.0060, 40.7128], // NYC coordinates
+        },
+      };
+
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send(streetData)
+        .expect(200);
+
+      expect(response.body.location).toBeDefined();
+      expect(response.body.location.type).toBe("Point");
+      expect(response.body.location.coordinates).toEqual([-74.0060, 40.7128]);
+    });
+
+    test("should reject street with invalid coordinates", async () => {
+      const streetData = {
+        name: "Invalid Street",
+        location: {
+          type: "Point",
+          coordinates: [181, 91], // Invalid coordinates
+        },
+      };
+
+      await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send(streetData)
+        .expect(400);
+    });
+
+    test("should create streets with various coordinate formats", async () => {
+      const streets = [
+        {
+          name: "Street 1",
+          location: { type: "Point", coordinates: [0, 0] },
+        },
+        {
+          name: "Street 2",
+          location: { type: "Point", coordinates: [-122.4194, 37.7749] }, // SF
+        },
+        {
+          name: "Street 3",
+          location: { type: "Point", coordinates: [2.3522, 48.8566] }, // Paris
+        },
+      ];
+
+      for (const street of streets) {
+        await request(app)
+          .post("/api/streets")
+          .set("x-auth-token", authToken)
+          .send(street)
+          .expect(200);
+      }
+
+      const allStreets = await Street.find();
+      expect(allStreets).toHaveLength(3);
+    });
+  });
+
+  describe("Nearby Street Queries", () => {
+    beforeEach(async () => {
+      // Create test streets at various locations
+      const streets = [
+        {
+          name: "Central Park Street",
+          location: { type: "Point", coordinates: [-73.9654, 40.7829] },
+          status: "available",
+        },
+        {
+          name: "Times Square Street",
+          location: { type: "Point", coordinates: [-73.9857, 40.7580] },
+          status: "available",
+        },
+        {
+          name: "Brooklyn Bridge Street",
+          location: { type: "Point", coordinates: [-73.9969, 40.7061] },
+          status: "adopted",
+        },
+        {
+          name: "Far Away Street",
+          location: { type: "Point", coordinates: [-118.2437, 34.0522] }, // LA
+          status: "available",
+        },
+      ];
+
+      await Street.insertMany(streets);
+    });
+
+    test("should find nearby streets within small radius", async () => {
+      // Query near Central Park (NYC)
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: -73.9654,
+          lat: 40.7829,
+          maxDistance: 1000, // 1km
+        })
+        .expect(200);
+
+      expect(response.body).toHaveLength(1);
+      expect(response.body[0].name).toBe("Central Park Street");
+    });
+
+    test("should find nearby streets within larger radius", async () => {
+      // Query near Central Park with 5km radius
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: -73.9654,
+          lat: 40.7829,
+          maxDistance: 5000, // 5km
+        })
+        .expect(200);
+
+      expect(response.body.length).toBeGreaterThanOrEqual(2);
+      const streetNames = response.body.map(s => s.name);
+      expect(streetNames).toContain("Central Park Street");
+      expect(streetNames).toContain("Times Square Street");
+    });
+
+    test("should filter by status in nearby queries", async () => {
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: -73.9654,
+          lat: 40.7829,
+          maxDistance: 10000, // 10km
+          status: "available",
+        })
+        .expect(200);
+
+      const streetNames = response.body.map(s => s.name);
+      expect(streetNames).toContain("Central Park Street");
+      expect(streetNames).toContain("Times Square Street");
+      expect(streetNames).not.toContain("Brooklyn Bridge Street"); // adopted
+    });
+
+    test("should return empty result for distant location", async () => {
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: 0, // Prime meridian
+          lat: 0, // Equator
+          maxDistance: 1000, // 1km
+        })
+        .expect(200);
+
+      expect(response.body).toHaveLength(0);
+    });
+  });
+
+  describe("Bounding Box Queries", () => {
+    beforeEach(async () => {
+      // Create streets in a grid pattern
+      const streets = [
+        { name: "SW Corner", location: { type: "Point", coordinates: [-74.0, 40.7] } },
+        { name: "SE Corner", location: { type: "Point", coordinates: [-73.9, 40.7] } },
+        { name: "NW Corner", location: { type: "Point", coordinates: [-74.0, 40.8] } },
+        { name: "NE Corner", location: { type: "Point", coordinates: [-73.9, 40.8] } },
+        { name: "Center", location: { type: "Point", coordinates: [-73.95, 40.75] } },
+        { name: "Outside Box", location: { type: "Point", coordinates: [-74.1, 40.6] } },
+      ];
+
+      await Street.insertMany(streets);
+    });
+
+    test("should find streets within bounding box", async () => {
+      const response = await request(app)
+        .get("/api/streets/bounds")
+        .query({
+          sw_lng: -74.0,
+          sw_lat: 40.7,
+          ne_lng: -73.9,
+          ne_lat: 40.8,
+        })
+        .expect(200);
+
+      expect(response.body.length).toBe(5); // All except "Outside Box"
+      const names = response.body.map(s => s.name);
+      expect(names).toContain("SW Corner");
+      expect(names).toContain("SE Corner");
+      expect(names).toContain("NW Corner");
+      expect(names).toContain("NE Corner");
+      expect(names).toContain("Center");
+      expect(names).not.toContain("Outside Box");
+    });
+
+    test("should handle partial bounding box", async () => {
+      const response = await request(app)
+        .get("/api/streets/bounds")
+        .query({
+          sw_lng: -74.0,
+          sw_lat: 40.7,
+          ne_lng: -73.95,
+          ne_lat: 40.75,
+        })
+        .expect(200);
+
+      expect(response.body.length).toBe(3); // SW, NW, Center
+      const names = response.body.map(s => s.name);
+      expect(names).toContain("SW Corner");
+      expect(names).toContain("NW Corner");
+      expect(names).toContain("Center");
+    });
+
+    test("should return empty for invalid bounding box", async () => {
+      const response = await request(app)
+        .get("/api/streets/bounds")
+        .query({
+          sw_lng: -73.95,
+          sw_lat: 40.75,
+          ne_lng: -74.0, // Reversed coordinates
+          ne_lat: 40.7,
+        })
+        .expect(200);
+
+      expect(response.body).toHaveLength(0);
+    });
+  });
+
+  describe("CouchDB Geospatial Operations", () => {
+    beforeEach(async () => {
+      // Create test streets in CouchDB
+      const streets = [
+        {
+          _id: "street_test1",
+          type: "street",
+          name: "Downtown Street",
+          location: { type: "Point", coordinates: [-74.0060, 40.7128] },
+          status: "available",
+          stats: { completedTasksCount: 0, reportsCount: 0 },
+        },
+        {
+          _id: "street_test2",
+          type: "street",
+          name: "Uptown Street",
+          location: { type: "Point", coordinates: [-73.9654, 40.7829] },
+          status: "adopted",
+          stats: { completedTasksCount: 5, reportsCount: 2 },
+        },
+        {
+          _id: "street_test3",
+          type: "street",
+          name: "Suburban Street",
+          location: { type: "Point", coordinates: [-73.8000, 40.7000] },
+          status: "available",
+          stats: { completedTasksCount: 1, reportsCount: 0 },
+        },
+      ];
+
+      for (const street of streets) {
+        await couchdbService.createDocument(street);
+      }
+    });
+
+    test("should find streets by location bounds in CouchDB", async () => {
+      const bounds = [
+        [-74.1, 40.7], // Southwest corner
+        [-73.9, 40.8], // Northeast corner
+      ];
+
+      const streets = await couchdbService.findStreetsByLocation(bounds);
+      expect(streets.length).toBe(2);
+      
+      const names = streets.map(s => s.name);
+      expect(names).toContain("Downtown Street");
+      expect(names).toContain("Uptown Street");
+      expect(names).not.toContain("Suburban Street");
+    });
+
+    test("should handle empty bounds gracefully", async () => {
+      const bounds = [
+        [0, 0], // Far away location
+        [0.1, 0.1],
+      ];
+
+      const streets = await couchdbService.findStreetsByLocation(bounds);
+      expect(streets).toHaveLength(0);
+    });
+
+    test("should filter by status in location queries", async () => {
+      const bounds = [
+        [-74.1, 40.7],
+        [-73.9, 40.8],
+      ];
+
+      // First get all streets in bounds
+      const allStreets = await couchdbService.findStreetsByLocation(bounds);
+      
+      // Then filter manually for available streets (since CouchDB doesn't support complex geo queries)
+      const availableStreets = allStreets.filter(street => street.status === 'available');
+      
+      expect(availableStreets.length).toBe(1);
+      expect(availableStreets[0].name).toBe("Downtown Street");
+    });
+  });
+
+  describe("Performance Tests", () => {
+    beforeEach(async () => {
+      // Create a large number of streets for performance testing
+      const streets = [];
+      for (let i = 0; i < 1000; i++) {
+        streets.push({
+          name: `Street ${i}`,
+          location: {
+            type: "Point",
+            coordinates: [
+              -74 + (Math.random() * 0.2), // Random longitude in NYC area
+              40.7 + (Math.random() * 0.2), // Random latitude in NYC area
+            ],
+          },
+          status: Math.random() > 0.5 ? "available" : "adopted",
+        });
+      }
+      await Street.insertMany(streets);
+    });
+
+    test("should handle nearby queries efficiently", async () => {
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: -73.9654,
+          lat: 40.7829,
+          maxDistance: 5000, // 5km
+        })
+        .expect(200);
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should complete within 1 second even with 1000 streets
+      expect(duration).toBeLessThan(1000);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+
+    test("should handle bounding box queries efficiently", async () => {
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/streets/bounds")
+        .query({
+          sw_lng: -74.0,
+          sw_lat: 40.7,
+          ne_lng: -73.9,
+          ne_lat: 40.8,
+        })
+        .expect(200);
+
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should complete within 1 second
+      expect(duration).toBeLessThan(1000);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+
+    test("should handle concurrent geospatial queries", async () => {
+      const startTime = Date.now();
+      
+      const queries = [];
+      for (let i = 0; i < 10; i++) {
+        queries.push(
+          request(app)
+            .get("/api/streets/nearby")
+            .query({
+              lng: -73.9654 + (Math.random() * 0.01),
+              lat: 40.7829 + (Math.random() * 0.01),
+              maxDistance: 2000,
+            })
+        );
+      }
+
+      await Promise.all(queries);
+      
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+
+      // Should handle 10 concurrent queries within 2 seconds
+      expect(duration).toBeLessThan(2000);
+    });
+  });
+
+  describe("Edge Cases and Error Handling", () => {
+    test("should handle missing coordinates gracefully", async () => {
+      const streetData = {
+        name: "Street without coordinates",
+      };
+
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send(streetData)
+        .expect(400);
+
+      expect(response.body.msg).toContain("location");
+    });
+
+    test("should handle malformed GeoJSON", async () => {
+      const streetData = {
+        name: "Malformed Street",
+        location: {
+          type: "InvalidType",
+          coordinates: "not an array",
+        },
+      };
+
+      await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send(streetData)
+        .expect(400);
+    });
+
+    test("should handle extreme coordinate values", async () => {
+      const streetData = {
+        name: "Extreme Coordinates",
+        location: {
+          type: "Point",
+          coordinates: [180, 90], // Maximum valid coordinates
+        },
+      };
+
+      const response = await request(app)
+        .post("/api/streets")
+        .set("x-auth-token", authToken)
+        .send(streetData)
+        .expect(200);
+
+      expect(response.body.location.coordinates).toEqual([180, 90]);
+    });
+
+    test("should validate query parameters", async () => {
+      await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: "invalid",
+          lat: 40.7128,
+          maxDistance: 1000,
+        })
+        .expect(400);
+
+      await request(app)
+        .get("/api/streets/bounds")
+        .query({
+          sw_lng: -74.0,
+          sw_lat: "invalid",
+          ne_lng: -73.9,
+          ne_lat: 40.8,
+        })
+        .expect(400);
+    });
+  });
+});

backend/__tests__/performance.test.js

@@ -0,0 +1,562 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const app = require("../server");
+const User = require("../models/User");
+const Street = require("../models/Street");
+const Task = require("../models/Task");
+const Event = require("../models/Event");
+const Post = require("../models/Post");
+
+describe("Performance Tests", () => {
+  let mongoServer;
+  let testUsers = [];
+  let authTokens = [];
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Create multiple test users for concurrent testing
+    for (let i = 0; i < 20; i++) {
+      const user = new User({
+        name: `Test User ${i}`,
+        email: `test${i}@example.com`,
+        password: "password123",
+        points: Math.floor(Math.random() * 1000),
+      });
+      await user.save();
+      testUsers.push(user);
+
+      const jwt = require("jsonwebtoken");
+      const token = jwt.sign(
+        { user: { id: user._id.toString() } },
+        process.env.JWT_SECRET || "test_secret"
+      );
+      authTokens.push(token);
+    }
+
+    // Create test data
+    await createTestData();
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  async function createTestData() {
+    // Create streets
+    const streets = [];
+    for (let i = 0; i < 100; i++) {
+      streets.push({
+        name: `Street ${i}`,
+        location: {
+          type: "Point",
+          coordinates: [
+            -74 + (Math.random() * 0.1),
+            40.7 + (Math.random() * 0.1),
+          ],
+        },
+        status: Math.random() > 0.5 ? "available" : "adopted",
+      });
+    }
+    await Street.insertMany(streets);
+
+    // Create tasks
+    const tasks = [];
+    for (let i = 0; i < 200; i++) {
+      tasks.push({
+        title: `Task ${i}`,
+        description: `Description for task ${i}`,
+        street: { streetId: streets[Math.floor(Math.random() * streets.length)]._id },
+        pointsAwarded: Math.floor(Math.random() * 20) + 5,
+        status: Math.random() > 0.3 ? "pending" : "completed",
+      });
+    }
+    await Task.insertMany(tasks);
+
+    // Create events
+    const events = [];
+    for (let i = 0; i < 50; i++) {
+      events.push({
+        title: `Event ${i}`,
+        description: `Description for event ${i}`,
+        date: new Date(Date.now() + Math.random() * 30 * 24 * 60 * 60 * 1000),
+        location: `Location ${i}`,
+        status: "upcoming",
+        participants: [],
+      });
+    }
+    await Event.insertMany(events);
+
+    // Create posts
+    const posts = [];
+    for (let i = 0; i < 150; i++) {
+      posts.push({
+        user: {
+          userId: testUsers[Math.floor(Math.random() * testUsers.length)]._id,
+          name: `User ${i}`,
+        },
+        content: `Post content ${i}`,
+        likes: [],
+        commentsCount: 0,
+      });
+    }
+    await Post.insertMany(posts);
+  }
+
+  describe("API Response Times", () => {
+    test("should respond to basic requests quickly", async () => {
+      const startTime = Date.now();
+
+      await request(app)
+        .get("/api/health")
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Health check should be very fast (< 50ms)
+      expect(responseTime).toBeLessThan(50);
+    });
+
+    test("should handle street listing efficiently", async () => {
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/streets")
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should respond within 200ms even with 100 streets
+      expect(responseTime).toBeLessThan(200);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+
+    test("should handle paginated requests efficiently", async () => {
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/streets?page=1&limit=10")
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Pagination should be fast (< 100ms)
+      expect(responseTime).toBeLessThan(100);
+      expect(response.body.docs).toHaveLength(10);
+    });
+
+    test("should handle geospatial queries efficiently", async () => {
+      const startTime = Date.now();
+
+      const response = await request(app)
+        .get("/api/streets/nearby")
+        .query({
+          lng: -73.9654,
+          lat: 40.7829,
+          maxDistance: 5000,
+        })
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Geospatial queries should be efficient (< 300ms)
+      expect(responseTime).toBeLessThan(300);
+    });
+
+    test("should handle complex queries efficiently", async () => {
+      const startTime = Date.now();
+
+      // Test a complex query with multiple filters
+      const response = await request(app)
+        .get("/api/tasks")
+        .query({
+          status: "pending",
+          limit: 20,
+          sort: "createdAt",
+        })
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Complex queries should still be reasonable (< 400ms)
+      expect(responseTime).toBeLessThan(400);
+    });
+  });
+
+  describe("Concurrent Request Handling", () => {
+    test("should handle concurrent read requests", async () => {
+      const startTime = Date.now();
+      const concurrentRequests = 50;
+
+      const promises = [];
+      for (let i = 0; i < concurrentRequests; i++) {
+        promises.push(request(app).get("/api/streets"));
+      }
+
+      const responses = await Promise.all(promises);
+      const endTime = Date.now();
+      const totalTime = endTime - startTime;
+
+      // All requests should succeed
+      responses.forEach((response) => {
+        expect(response.status).toBe(200);
+      });
+
+      // Should handle 50 concurrent requests within 2 seconds
+      expect(totalTime).toBeLessThan(2000);
+
+      // Average response time should be reasonable
+      const avgResponseTime = totalTime / concurrentRequests;
+      expect(avgResponseTime).toBeLessThan(100);
+    });
+
+    test("should handle concurrent write requests", async () => {
+      const startTime = Date.now();
+      const concurrentRequests = 20;
+
+      const promises = [];
+      for (let i = 0; i < concurrentRequests; i++) {
+        promises.push(
+          request(app)
+            .post("/api/posts")
+            .set("x-auth-token", authTokens[i % authTokens.length])
+            .send({
+              content: `Concurrent post ${i}`,
+            })
+        );
+      }
+
+      const responses = await Promise.all(promises);
+      const endTime = Date.now();
+      const totalTime = endTime - startTime;
+
+      // Most requests should succeed (some might fail due to rate limiting)
+      const successCount = responses.filter(r => r.status === 200).length;
+      expect(successCount).toBeGreaterThan(15);
+
+      // Should handle concurrent writes within 5 seconds
+      expect(totalTime).toBeLessThan(5000);
+    });
+
+    test("should handle mixed read/write workload", async () => {
+      const startTime = Date.now();
+      const operations = [];
+
+      // Mix of different operations
+      for (let i = 0; i < 30; i++) {
+        // Read operations
+        operations.push(request(app).get("/api/streets"));
+        operations.push(request(app).get("/api/events"));
+        
+        // Write operations
+        operations.push(
+          request(app)
+            .post("/api/posts")
+            .set("x-auth-token", authTokens[i % authTokens.length])
+            .send({ content: `Mixed post ${i}` })
+        );
+      }
+
+      const responses = await Promise.all(operations);
+      const endTime = Date.now();
+      const totalTime = endTime - startTime;
+
+      // Most operations should succeed
+      const successCount = responses.filter(r => r.status === 200).length;
+      expect(successCount).toBeGreaterThan(50);
+
+      // Should handle mixed workload within 3 seconds
+      expect(totalTime).toBeLessThan(3000);
+    });
+  });
+
+  describe("Memory Usage", () => {
+    test("should not leak memory during repeated operations", async () => {
+      const initialMemory = process.memoryUsage().heapUsed;
+
+      // Perform many operations
+      for (let i = 0; i < 100; i++) {
+        await request(app).get("/api/streets");
+        await request(app).get("/api/events");
+        await request(app).get("/api/tasks");
+        
+        // Force garbage collection if available
+        if (global.gc) {
+          global.gc();
+        }
+      }
+
+      const finalMemory = process.memoryUsage().heapUsed;
+      const memoryIncrease = finalMemory - initialMemory;
+
+      // Memory increase should be reasonable (< 50MB)
+      expect(memoryIncrease).toBeLessThan(50 * 1024 * 1024);
+    });
+
+    test("should handle large result sets efficiently", async () => {
+      const startTime = Date.now();
+
+      // Request a large result set
+      const response = await request(app)
+        .get("/api/streets?limit=100")
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should handle large results efficiently
+      expect(responseTime).toBeLessThan(500);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Database Performance", () => {
+    test("should use database indexes effectively", async () => {
+      const startTime = Date.now();
+
+      // Query that should use indexes
+      await request(app)
+        .get("/api/streets")
+        .query({ status: "available" });
+
+      const endTime = Date.now();
+      const queryTime = endTime - startTime;
+
+      // Indexed queries should be fast
+      expect(queryTime).toBeLessThan(100);
+    });
+
+    test("should handle database connection pooling", async () => {
+      const startTime = Date.now();
+      const concurrentDbOperations = 30;
+
+      const promises = [];
+      for (let i = 0; i < concurrentDbOperations; i++) {
+        promises.push(
+          request(app)
+            .get(`/api/streets/${new mongoose.Types.ObjectId()}`)
+            .expect(404)
+        );
+      }
+
+      await Promise.all(promises);
+      const endTime = Date.now();
+      const totalTime = endTime - startTime;
+
+      // Connection pooling should handle concurrent operations efficiently
+      expect(totalTime).toBeLessThan(1000);
+    });
+
+    test("should handle aggregation queries efficiently", async () => {
+      const startTime = Date.now();
+
+      // Test leaderboard (aggregation) performance
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      const endTime = Date.now();
+      const queryTime = endTime - startTime;
+
+      // Aggregation should be reasonably fast
+      expect(queryTime).toBeLessThan(300);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Rate Limiting Performance", () => {
+    test("should handle rate limiting efficiently", async () => {
+      const startTime = Date.now();
+
+      // Make requests that approach rate limit
+      const promises = [];
+      for (let i = 0; i < 95; i++) { // Just under the limit
+        promises.push(
+          request(app)
+            .get("/api/streets")
+            .set("x-auth-token", authTokens[i % authTokens.length])
+        );
+      }
+
+      const responses = await Promise.all(promises);
+      const endTime = Date.now();
+      const totalTime = endTime - startTime;
+
+      // Should handle requests near rate limit efficiently
+      expect(totalTime).toBeLessThan(2000);
+
+      const successCount = responses.filter(r => r.status === 200).length;
+      expect(successCount).toBeGreaterThan(90);
+    });
+  });
+
+  describe("Stress Tests", () => {
+    test("should handle sustained load", async () => {
+      const duration = 5000; // 5 seconds
+      const startTime = Date.now();
+      let requestCount = 0;
+
+      while (Date.now() - startTime < duration) {
+        const promises = [];
+        for (let i = 0; i < 10; i++) {
+          promises.push(request(app).get("/api/health"));
+        }
+        await Promise.all(promises);
+        requestCount += 10;
+      }
+
+      const actualDuration = Date.now() - startTime;
+      const requestsPerSecond = (requestCount / actualDuration) * 1000;
+
+      // Should handle at least 50 requests per second
+      expect(requestsPerSecond).toBeGreaterThan(50);
+    });
+
+    test("should maintain performance under load", async () => {
+      const baselineTime = await measureResponseTime("/api/streets");
+
+      // Apply load
+      const loadPromises = [];
+      for (let i = 0; i < 50; i++) {
+        loadPromises.push(request(app).get("/api/events"));
+      }
+      await Promise.all(loadPromises);
+
+      // Measure performance after load
+      const afterLoadTime = await measureResponseTime("/api/streets");
+
+      // Performance should not degrade significantly
+      const performanceDegradation = (afterLoadTime - baselineTime) / baselineTime;
+      expect(performanceDegradation).toBeLessThan(0.5); // Less than 50% degradation
+    });
+
+    async function measureResponseTime(endpoint) {
+      const startTime = Date.now();
+      await request(app).get(endpoint);
+      return Date.now() - startTime;
+    }
+  });
+
+  describe("Resource Limits", () => {
+    test("should handle large payloads efficiently", async () => {
+      const largeContent = "x".repeat(10000); // 10KB content
+
+      const startTime = Date.now();
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authTokens[0])
+        .send({ content: largeContent })
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should handle large payloads reasonably
+      expect(responseTime).toBeLessThan(1000);
+      expect(response.body.content).toBe(largeContent);
+    });
+
+    test("should reject oversized payloads quickly", async () => {
+      const oversizedContent = "x".repeat(1000000); // 1MB content
+
+      const startTime = Date.now();
+      const response = await request(app)
+        .post("/api/posts")
+        .set("x-auth-token", authTokens[0])
+        .send({ content: oversizedContent })
+        .expect(413);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should reject oversized payloads quickly
+      expect(responseTime).toBeLessThan(100);
+    });
+  });
+
+  describe("Caching Performance", () => {
+    test("should cache static responses efficiently", async () => {
+      // First request
+      const startTime1 = Date.now();
+      await request(app).get("/api/health");
+      const firstRequestTime = Date.now() - startTime1;
+
+      // Second request (potentially cached)
+      const startTime2 = Date.now();
+      await request(app).get("/api/health");
+      const secondRequestTime = Date.now() - startTime2;
+
+      // Second request should be faster (if cached)
+      // Note: This test depends on implementation of caching
+      expect(secondRequestTime).toBeLessThanOrEqual(firstRequestTime);
+    });
+  });
+
+  describe("Scalability Tests", () => {
+    test("should handle increasing data volumes", async () => {
+      // Create additional data
+      const additionalStreets = [];
+      for (let i = 0; i < 100; i++) {
+        additionalStreets.push({
+          name: `Additional Street ${i}`,
+          location: {
+            type: "Point",
+            coordinates: [-74 + Math.random() * 0.1, 40.7 + Math.random() * 0.1],
+          },
+          status: "available",
+        });
+      }
+      await Street.insertMany(additionalStreets);
+
+      // Measure performance with increased data
+      const startTime = Date.now();
+      const response = await request(app)
+        .get("/api/streets")
+        .query({ limit: 50 })
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should maintain performance with more data
+      expect(responseTime).toBeLessThan(300);
+      expect(response.body.length).toBe(50);
+    });
+
+    test("should handle user growth efficiently", async () => {
+      // Create additional users
+      const additionalUsers = [];
+      for (let i = 0; i < 50; i++) {
+        additionalUsers.push({
+          name: `Additional User ${i}`,
+          email: `additional${i}@example.com`,
+          password: "password123",
+          points: Math.floor(Math.random() * 1000),
+        });
+      }
+      await User.insertMany(additionalUsers);
+
+      // Test leaderboard performance with more users
+      const startTime = Date.now();
+      const response = await request(app)
+        .get("/api/rewards/leaderboard")
+        .expect(200);
+
+      const endTime = Date.now();
+      const responseTime = endTime - startTime;
+
+      // Should handle more users efficiently
+      expect(responseTime).toBeLessThan(400);
+      expect(response.body.length).toBeGreaterThan(0);
+    });
+  });
+});

backend/__tests__/socketio.test.js

@@ -0,0 +1,299 @@
+const request = require("supertest");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const socketIoClient = require("socket.io-client");
+const jwt = require("jsonwebtoken");
+const app = require("../server");
+const User = require("../models/User");
+const Event = require("../models/Event");
+const Post = require("../models/Post");
+
+describe("Socket.IO Real-time Features", () => {
+  let mongoServer;
+  let server;
+  let io;
+  let clientSocket;
+  let testUser;
+  let authToken;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+
+    // Start server
+    server = app.listen(0); // Use random port
+    io = app.get("io");
+
+    // Create test user
+    testUser = new User({
+      name: "Test User",
+      email: "test@example.com",
+      password: "password123",
+    });
+    await testUser.save();
+
+    // Generate auth token
+    authToken = jwt.sign(
+      { user: { id: testUser._id.toString() } },
+      process.env.JWT_SECRET || "test_secret"
+    );
+  });
+
+  afterAll(async () => {
+    if (clientSocket) {
+      clientSocket.disconnect();
+    }
+    server.close();
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  beforeEach((done) => {
+    // Connect client socket with authentication
+    clientSocket = socketIoClient(`http://localhost:${server.address().port}`, {
+      auth: { token: authToken },
+    });
+
+    clientSocket.on("connect", () => {
+      done();
+    });
+
+    clientSocket.on("connect_error", (err) => {
+      done(err);
+    });
+  });
+
+  afterEach(() => {
+    if (clientSocket && clientSocket.connected) {
+      clientSocket.disconnect();
+    }
+  });
+
+  describe("Socket Authentication", () => {
+    test("should connect with valid token", (done) => {
+      expect(clientSocket.connected).toBe(true);
+      done();
+    });
+
+    test("should reject connection with invalid token", (done) => {
+      const invalidSocket = socketIoClient(
+        `http://localhost:${server.address().port}`,
+        {
+          auth: { token: "invalid_token" },
+        }
+      );
+
+      invalidSocket.on("connect_error", (err) => {
+        expect(err.message).toBe("Authentication error: Invalid token");
+        invalidSocket.disconnect();
+        done();
+      });
+    });
+
+    test("should reject connection without token", (done) => {
+      const noTokenSocket = socketIoClient(
+        `http://localhost:${server.address().port}`
+      );
+
+      noTokenSocket.on("connect_error", (err) => {
+        expect(err.message).toBe("Authentication error: No token provided");
+        noTokenSocket.disconnect();
+        done();
+      });
+    });
+  });
+
+  describe("Event Participation", () => {
+    let testEvent;
+
+    beforeEach(async () => {
+      testEvent = new Event({
+        title: "Test Event",
+        description: "Test Description",
+        date: new Date(Date.now() + 86400000), // Tomorrow
+        location: "Test Location",
+        participants: [],
+      });
+      await testEvent.save();
+    });
+
+    test("should join event room", (done) => {
+      clientSocket.emit("joinEvent", testEvent._id.toString());
+
+      // Verify socket joined room by checking server logs
+      setTimeout(() => {
+        // The socket should have joined the event room
+        expect(clientSocket.rooms.has(`event_${testEvent._id}`)).toBe(true);
+        done();
+      }, 100);
+    });
+
+    test("should receive event updates in room", (done) => {
+      clientSocket.emit("joinEvent", testEvent._id.toString());
+
+      // Listen for updates
+      clientSocket.on("update", (data) => {
+        expect(data).toBe("Event status updated to ongoing");
+        done();
+      });
+
+      // Simulate event update
+      setTimeout(() => {
+        clientSocket.emit("eventUpdate", {
+          eventId: testEvent._id.toString(),
+          message: "Event status updated to ongoing",
+        });
+      }, 100);
+    });
+
+    test("should not receive updates for events not joined", (done) => {
+      const anotherEventId = new mongoose.Types.ObjectId().toString();
+
+      // Listen for updates (should not receive any)
+      let updateReceived = false;
+      clientSocket.on("update", () => {
+        updateReceived = true;
+      });
+
+      // Send update for event not joined
+      setTimeout(() => {
+        clientSocket.emit("eventUpdate", {
+          eventId: anotherEventId,
+          message: "This should not be received",
+        });
+
+        // Check after delay that no update was received
+        setTimeout(() => {
+          expect(updateReceived).toBe(false);
+          done();
+        }, 100);
+      }, 100);
+    });
+  });
+
+  describe("Post Interactions", () => {
+    let testPost;
+
+    beforeEach(async () => {
+      testPost = new Post({
+        user: {
+          userId: testUser._id,
+          name: testUser.name,
+        },
+        content: "Test post content",
+        likes: [],
+        commentsCount: 0,
+      });
+      await testPost.save();
+    });
+
+    test("should join post room", (done) => {
+      clientSocket.emit("joinPost", testPost._id.toString());
+
+      setTimeout(() => {
+        expect(clientSocket.rooms.has(`post_${testPost._id}`)).toBe(true);
+        done();
+      }, 100);
+    });
+
+    test("should handle multiple room joins", (done) => {
+      const testEvent = new Event({
+        title: "Another Event",
+        description: "Another Description",
+        date: new Date(Date.now() + 86400000),
+        location: "Another Location",
+        participants: [],
+      });
+      testEvent.save().then(() => {
+        clientSocket.emit("joinEvent", testEvent._id.toString());
+        clientSocket.emit("joinPost", testPost._id.toString());
+
+        setTimeout(() => {
+          expect(clientSocket.rooms.has(`event_${testEvent._id}`)).toBe(true);
+          expect(clientSocket.rooms.has(`post_${testPost._id}`)).toBe(true);
+          done();
+        }, 100);
+      });
+    });
+  });
+
+  describe("Connection Stability", () => {
+    test("should handle disconnection gracefully", (done) => {
+      const disconnectSpy = jest.spyOn(console, "log");
+      
+      clientSocket.disconnect();
+      
+      setTimeout(() => {
+        expect(disconnectSpy).toHaveBeenCalledWith(
+          expect.stringContaining("Client disconnected:")
+        );
+        disconnectSpy.mockRestore();
+        done();
+      }, 100);
+    });
+
+    test("should maintain connection under load", async () => {
+      const startTime = Date.now();
+      const messageCount = 100;
+      
+      for (let i = 0; i < messageCount; i++) {
+        await new Promise((resolve) => {
+          clientSocket.emit("eventUpdate", {
+            eventId: new mongoose.Types.ObjectId().toString(),
+            message: `Test message ${i}`,
+          });
+          setTimeout(resolve, 10);
+        });
+      }
+      
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+      
+      // Should complete within reasonable time (less than 5 seconds)
+      expect(duration).toBeLessThan(5000);
+      expect(clientSocket.connected).toBe(true);
+    });
+  });
+
+  describe("Concurrent Connections", () => {
+    test("should handle multiple simultaneous connections", async () => {
+      const clients = [];
+      const connectionPromises = [];
+
+      // Create 10 concurrent connections
+      for (let i = 0; i < 10; i++) {
+        const promise = new Promise((resolve) => {
+          const client = socketIoClient(
+            `http://localhost:${server.address().port}`,
+            {
+              auth: { token: authToken },
+            }
+          );
+
+          client.on("connect", () => {
+            clients.push(client);
+            resolve();
+          });
+
+          client.on("connect_error", (err) => {
+            resolve(err);
+          });
+        });
+
+        connectionPromises.push(promise);
+      }
+
+      await Promise.all(connectionPromises);
+
+      // All connections should succeed
+      expect(clients.length).toBe(10);
+      clients.forEach((client) => {
+        expect(client.connected).toBe(true);
+      });
+
+      // Clean up
+      clients.forEach((client) => client.disconnect());
+    });
+  });
+});