feat: add integration and setup tests and complete code review fixes

2025-08-14 22:41:48 +01:00
parent da78487047
commit 06f0cc3638
15 changed files with 2766 additions and 263 deletions
@@ -0,0 +1,368 @@
+const request = require("supertest");
+const app = require("../../server");
+const redisClient = require("../../src/utils/redis-client");
+const fallbackStore = require("../../src/utils/fallback-store");
+
+describe("Duplicate Ticket Prevention - Integration Tests", () => {
+  let server;
+  let testEventId = "999"; // Use a unique event ID for testing
+
+  beforeAll(async () => {
+    // Start the server
+    server = app.listen(0); // Use random port
+
+    // Wait for server to be ready
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Ensure Redis is connected
+    if (!redisClient.isConnected) {
+      await redisClient.connect();
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up test data
+    try {
+      if (redisClient.isConnected) {
+        const testEventKey = `event:${testEventId}:meta`;
+        const testTicketsKey = `event:${testEventId}:tickets`;
+        await redisClient.client.del(testEventKey);
+        await redisClient.client.del(testTicketsKey);
+      }
+    } catch (error) {
+      console.warn("Failed to cleanup test data:", error.message);
+    }
+
+    // Close server
+    if (server) {
+      await new Promise((resolve) => server.close(resolve));
+    }
+
+    // Disconnect Redis
+    if (redisClient.isConnected) {
+      await redisClient.disconnect();
+    }
+  });
+
+  beforeEach(async () => {
+    // Reset fallback store
+    fallbackStore.deactivate();
+    fallbackStore.events.clear();
+    fallbackStore.globalStats = {
+      totalEvents: 0,
+      totalTickets: 0,
+      totalSold: 0,
+      lastSeeded: null,
+    };
+
+    // Create test event with 10 tickets in Redis
+    if (redisClient.isConnected) {
+      const testEventKey = `event:${testEventId}:meta`;
+      const testTicketsKey = `event:${testEventId}:tickets`;
+
+      // Create event metadata
+      await redisClient.client.hSet(testEventKey, {
+        eventId: testEventId,
+        name: "Test Event for Duplicate Prevention",
+        description: "Test event to verify no duplicate tickets",
+        totalTickets: "10",
+        soldTickets: "0",
+        createdAt: new Date().toISOString(),
+        lastSoldAt: "never",
+      });
+
+      // Create 10 test tickets
+      const testTickets = Array.from(
+        { length: 10 },
+        (_, i) => `test-ticket-${i + 1}`
+      );
+      await redisClient.client.lPush(testTicketsKey, testTickets);
+
+      // Update global stats
+      await redisClient.client.hSet("global:stats", {
+        totalEvents: "1",
+        totalTickets: "10",
+        totalSold: "0",
+        lastSeeded: new Date().toISOString(),
+      });
+    }
+  });
+
+  describe("Redis Ticket Purchase - Duplicate Prevention", () => {
+    test("should prevent duplicate ticket sales under normal conditions", async () => {
+      if (!redisClient.isConnected) {
+        console.warn("Skipping Redis test - Redis not connected");
+        return;
+      }
+
+      const purchaseIds = [];
+      const soldTickets = new Set();
+      let successCount = 0;
+      let failureCount = 0;
+
+      // Attempt to purchase 15 tickets (more than available)
+      for (let i = 0; i < 15; i++) {
+        const purchaseId = `test-purchase-${Date.now()}-${i}`;
+        purchaseIds.push(purchaseId);
+
+        try {
+          const response = await request(server)
+            .post(`/buy/${testEventId}`)
+            .set("Content-Type", "application/json");
+
+          if (response.status === 200 && response.body.success) {
+            successCount++;
+            const ticket = response.body.ticket;
+
+            // Verify ticket is unique
+            expect(soldTickets.has(ticket)).toBe(false);
+            soldTickets.add(ticket);
+
+            expect(response.body.usingFallback).toBe(false);
+          } else {
+            failureCount++;
+            expect(response.status).toBe(409); // No tickets available
+            expect(response.body.message).toContain("No tickets available");
+          }
+        } catch (error) {
+          failureCount++;
+        }
+      }
+
+      // Should have sold exactly 10 tickets (no duplicates)
+      expect(successCount).toBe(10);
+      expect(failureCount).toBe(5);
+      expect(soldTickets.size).toBe(10);
+
+      // Verify no tickets remain
+      const remainingTickets = await redisClient.client.lLen(
+        `event:${testEventId}:tickets`
+      );
+      expect(remainingTickets).toBe(0);
+    });
+
+    test("should prevent duplicate tickets under concurrent load", async () => {
+      if (!redisClient.isConnected) {
+        console.warn("Skipping Redis test - Redis not connected");
+        return;
+      }
+
+      // Reset test event with 5 tickets
+      const testTicketsKey = `event:${testEventId}:tickets`;
+      await redisClient.client.del(testTicketsKey);
+      const testTickets = Array.from(
+        { length: 5 },
+        (_, i) => `concurrent-ticket-${i + 1}`
+      );
+      await redisClient.client.lPush(testTicketsKey, testTickets);
+
+      const soldTickets = new Set();
+      const purchasePromises = [];
+
+      // Create 10 concurrent purchase requests
+      for (let i = 0; i < 10; i++) {
+        const purchaseId = `concurrent-purchase-${Date.now()}-${i}`;
+
+        const promise = request(server)
+          .post(`/buy/${testEventId}`)
+          .set("Content-Type", "application/json")
+          .then((response) => ({ success: true, response, purchaseId }))
+          .catch((error) => ({ success: false, error, purchaseId }));
+
+        purchasePromises.push(promise);
+      }
+
+      // Wait for all requests to complete
+      const results = await Promise.all(purchasePromises);
+
+      let successCount = 0;
+      let failureCount = 0;
+
+      results.forEach((result) => {
+        if (
+          result.success &&
+          result.response.status === 200 &&
+          result.response.body.success
+        ) {
+          successCount++;
+          const ticket = result.response.body.ticket;
+
+          // Verify ticket is unique
+          expect(soldTickets.has(ticket)).toBe(false);
+          soldTickets.add(ticket);
+        } else {
+          failureCount++;
+        }
+      });
+
+      // Should have sold exactly 5 tickets (no duplicates)
+      expect(successCount).toBe(5);
+      expect(failureCount).toBe(5);
+      expect(soldTickets.size).toBe(5);
+
+      // Verify no tickets remain
+      const remainingTickets = await redisClient.client.lLen(testTicketsKey);
+      expect(remainingTickets).toBe(0);
+    });
+  });
+
+  describe("Fallback Store - Duplicate Prevention", () => {
+    test("should prevent duplicate tickets in fallback mode", async () => {
+      // Seed fallback store with test event
+      const metadata = {
+        eventId: testEventId,
+        name: "Test Event for Duplicate Prevention",
+        description: "Test event to verify no duplicate tickets",
+        totalTickets: 5,
+        soldTickets: 0,
+        createdAt: new Date().toISOString(),
+        lastSoldAt: "never",
+      };
+
+      const testTickets = Array.from(
+        { length: 5 },
+        (_, i) => `fallback-ticket-${i + 1}`
+      );
+      fallbackStore.seedEvent(testEventId, testTickets, metadata);
+      fallbackStore.activate("Test activation");
+
+      const soldTickets = new Set();
+      let successCount = 0;
+      let failureCount = 0;
+
+      // Attempt to purchase 8 tickets (more than available)
+      for (let i = 0; i < 8; i++) {
+        const purchaseId = `fallback-purchase-${Date.now()}-${i}`;
+
+        try {
+          const response = await request(server)
+            .post(`/buy/${testEventId}`)
+            .set("Content-Type", "application/json");
+
+          if (response.status === 200 && response.body.success) {
+            successCount++;
+            const ticket = response.body.ticket;
+
+            // Verify ticket is unique
+            expect(soldTickets.has(ticket)).toBe(false);
+            soldTickets.add(ticket);
+
+            expect(response.body.usingFallback).toBe(true);
+          } else {
+            failureCount++;
+            expect(response.status).toBe(409); // No tickets available
+            expect(response.body.message).toContain("No tickets available");
+          }
+        } catch (error) {
+          failureCount++;
+        }
+      }
+
+      // Should have sold exactly 5 tickets (no duplicates)
+      expect(successCount).toBe(5);
+      expect(failureCount).toBe(3);
+      expect(soldTickets.size).toBe(5);
+
+      // Verify no tickets remain in fallback store
+      const event = fallbackStore.events.get(testEventId);
+      expect(event.tickets).toHaveLength(0);
+    });
+  });
+
+  describe("Mixed Mode - Redis + Fallback", () => {
+    test("should prevent duplicates when switching between Redis and fallback", async () => {
+      if (!redisClient.isConnected) {
+        console.warn("Skipping Redis test - Redis not connected");
+        return;
+      }
+
+      // Start with Redis
+      const soldTickets = new Set();
+
+      // Purchase 3 tickets from Redis
+      for (let i = 0; i < 3; i++) {
+        const purchaseId = `mixed-purchase-redis-${Date.now()}-${i}`;
+
+        const response = await request(server)
+          .post(`/buy/${testEventId}`)
+          .set("Content-Type", "application/json");
+
+        expect(response.status).toBe(200);
+        expect(response.body.success).toBe(true);
+        expect(response.body.usingFallback).toBe(false);
+
+        const ticket = response.body.ticket;
+        expect(soldTickets.has(ticket)).toBe(false);
+        soldTickets.add(ticket);
+      }
+
+      // Simulate Redis failure by disconnecting
+      await redisClient.disconnect();
+
+      // Purchase remaining tickets from fallback
+      for (let i = 0; i < 7; i++) {
+        const purchaseId = `mixed-purchase-fallback-${Date.now()}-${i}`;
+
+        const response = await request(server)
+          .post(`/buy/${testEventId}`)
+          .set("Content-Type", "application/json");
+
+        expect(response.status).toBe(200);
+        expect(response.body.success).toBe(true);
+        expect(response.body.usingFallback).toBe(true);
+
+        const ticket = response.body.ticket;
+        expect(soldTickets.has(ticket)).toBe(false);
+        soldTickets.add(ticket);
+      }
+
+      // Verify total unique tickets sold
+      expect(soldTickets.size).toBe(10);
+
+      // Try to purchase one more (should fail)
+      const response = await request(server)
+        .post(`/buy/${testEventId}`)
+        .set("Content-Type", "application/json");
+
+      expect(response.status).toBe(409);
+      expect(response.body.success).toBe(false);
+      expect(response.body.message).toContain("No tickets available");
+    });
+  });
+
+  describe("Data Integrity Verification", () => {
+    test("should maintain consistent ticket counts across Redis and fallback", async () => {
+      if (!redisClient.isConnected) {
+        console.warn("Skipping Redis test - Redis not connected");
+        return;
+      }
+
+      // Purchase 3 tickets
+      for (let i = 0; i < 3; i++) {
+        const purchaseId = `integrity-purchase-${Date.now()}-${i}`;
+
+        const response = await request(server)
+          .post(`/buy/${testEventId}`)
+          .set("Content-Type", "application/json");
+
+        expect(response.status).toBe(200);
+        expect(response.body.success).toBe(true);
+      }
+
+      // Check Redis stats
+      const redisStats = await redisClient.getEventStats(testEventId);
+      expect(redisStats.remainingTickets).toBe(7);
+      expect(redisStats.soldTickets).toBe(3);
+
+      // Check fallback store stats (should be synced)
+      fallbackStore.activate("Test activation");
+      const fallbackStats = fallbackStore.getEventStats(testEventId);
+      expect(fallbackStats.remainingTickets).toBe(7);
+      expect(fallbackStats.soldTickets).toBe(3);
+
+      // Verify global stats
+      const globalStats = await redisClient.getGlobalStats();
+      expect(globalStats.totalSold).toBe(3);
+    });
+  });
+});