module4_backend_project/tests/unit/fallback-store.test.js

const fallbackStore = require("../../src/utils/fallback-store");

describe("Fallback Store", () => {
  beforeEach(() => {
    // Reset fallback store state before each test
    fallbackStore.deactivate();
    fallbackStore.events.clear();
    fallbackStore.globalStats = {
      totalEvents: 0,
      totalTickets: 0,
      totalSold: 0,
      lastSeeded: null,
    };
  });

  describe("Initialization", () => {
    test("should start in inactive state", () => {
      expect(fallbackStore.isActive).toBe(false);
      expect(fallbackStore.events.size).toBe(0);
    });

    test("should have empty global stats", () => {
      const stats = fallbackStore.getGlobalStats();
      expect(stats.totalEvents).toBe(0);
      expect(stats.totalTickets).toBe(0);
      expect(stats.totalSold).toBe(0);
    });
  });

  describe("Activation/Deactivation", () => {
    test("should activate and deactivate correctly", () => {
      fallbackStore.activate("Test activation");
      expect(fallbackStore.isActive).toBe(true);
      expect(fallbackStore.activationReason).toBe("Test activation");

      fallbackStore.deactivate();
      expect(fallbackStore.isActive).toBe(false);
      expect(fallbackStore.activationReason).toBe(null);
    });

    test("should log activation and deactivation", () => {
      const consoleSpy = jest.spyOn(console, "warn");

      fallbackStore.activate("Test");
      expect(consoleSpy).toHaveBeenCalledWith(
        expect.stringContaining("Fallback store activated")
      );

      fallbackStore.deactivate();
      expect(consoleSpy).toHaveBeenCalledWith(
        expect.stringContaining("Fallback store deactivated")
      );
    });
  });

  describe("Event Seeding", () => {
    test("should seed events correctly", () => {
      const eventId = "1";
      const tickets = ["ticket1", "ticket2", "ticket3"];
      const metadata = {
        eventId: "1",
        name: "Test Event",
        description: "Test Description",
        totalTickets: 3,
        soldTickets: 0,
        createdAt: "2024-01-01T00:00:00.000Z",
        lastSoldAt: "never",
      };

      fallbackStore.seedEvent(eventId, tickets, metadata);

      expect(fallbackStore.events.has(eventId)).toBe(true);
      const event = fallbackStore.events.get(eventId);
      expect(event.tickets).toEqual(tickets);
      expect(event.metadata).toEqual(metadata);
      expect(fallbackStore.globalStats.totalEvents).toBe(1);
      expect(fallbackStore.globalStats.totalTickets).toBe(3);
    });

    test("should update global stats when seeding multiple events", () => {
      const event1 = { eventId: "1", totalTickets: 5 };
      const event2 = { eventId: "2", totalTickets: 3 };

      fallbackStore.seedEvent("1", ["t1", "t2", "t3", "t4", "t5"], event1);
      fallbackStore.seedEvent("2", ["t6", "t7", "t8"], event2);

      expect(fallbackStore.globalStats.totalEvents).toBe(2);
      expect(fallbackStore.globalStats.totalTickets).toBe(8);
    });
  });

  describe("Ticket Purchase", () => {
    beforeEach(() => {
      // Seed a test event
      const metadata = {
        eventId: "1",
        name: "Test Event",
        description: "Test Description",
        totalTickets: 3,
        soldTickets: 0,
        createdAt: "2024-01-01T00:00:00.000Z",
        lastSoldAt: "never",
      };
      fallbackStore.seedEvent("1", ["ticket1", "ticket2", "ticket3"], metadata);
    });

    test("should purchase ticket successfully", () => {
      const purchaseId = "test-purchase-123";
      const result = fallbackStore.purchaseTicket("1", purchaseId);

      expect(result.success).toBe(true);
      expect(result.ticket).toBeDefined();
      expect(result.soldCount).toBe(1);
      expect(result.remainingTickets).toBe(2);

      // Verify ticket was removed
      const event = fallbackStore.events.get("1");
      expect(event.tickets).toHaveLength(2);
      expect(event.tickets).not.toContain(result.ticket);
    });

    test("should prevent duplicate ticket sales", () => {
      const purchaseId1 = "test-purchase-1";
      const purchaseId2 = "test-purchase-2";

      // First purchase should succeed
      const result1 = fallbackStore.purchaseTicket("1", purchaseId1);
      expect(result1.success).toBe(true);

      // Second purchase should succeed (different purchase ID)
      const result2 = fallbackStore.purchaseTicket("1", purchaseId2);
      expect(result2.success).toBe(true);

      // Verify different tickets were sold
      expect(result1.ticket).not.toBe(result2.ticket);
      expect(result1.ticket).toBeDefined();
      expect(result2.ticket).toBeDefined();
    });

    test("should fail when no tickets available", () => {
      // Purchase all available tickets
      fallbackStore.purchaseTicket("1", "purchase1");
      fallbackStore.purchaseTicket("1", "purchase2");
      fallbackStore.purchaseTicket("1", "purchase3");

      // Try to purchase when no tickets left
      const result = fallbackStore.purchaseTicket("1", "purchase4");
      expect(result.success).toBe(false);
      expect(result.error).toBe("NO_TICKETS_AVAILABLE");
    });

    test("should fail for non-existent event", () => {
      const result = fallbackStore.purchaseTicket("999", "test-purchase");
      expect(result.success).toBe(false);
      expect(result.error).toBe("EVENT_NOT_FOUND");
    });
  });

  describe("Event Statistics", () => {
    beforeEach(() => {
      const metadata = {
        eventId: "1",
        name: "Test Event",
        description: "Test Description",
        totalTickets: 5,
        soldTickets: 0,
        createdAt: "2024-01-01T00:00:00.000Z",
        lastSoldAt: "never",
      };
      fallbackStore.seedEvent("1", ["t1", "t2", "t3", "t4", "t5"], metadata);
    });

    test("should return correct event stats", () => {
      const stats = fallbackStore.getEventStats("1");
      expect(stats).toBeDefined();
      expect(stats.eventId).toBe("1");
      expect(stats.name).toBe("Test Event");
      expect(stats.totalTickets).toBe(5);
      expect(stats.remainingTickets).toBe(5);
      expect(stats.soldTickets).toBe(0);
    });

    test("should return null for non-existent event", () => {
      const stats = fallbackStore.getEventStats("999");
      expect(stats).toBeNull();
    });

    test("should update stats after ticket purchase", () => {
      fallbackStore.purchaseTicket("1", "test-purchase");

      const stats = fallbackStore.getEventStats("1");
      expect(stats.remainingTickets).toBe(4);
      expect(stats.soldTickets).toBe(1);
    });
  });

  describe("Global Statistics", () => {
    test("should return correct global stats", () => {
      const stats = fallbackStore.getGlobalStats();
      expect(stats.totalEvents).toBe(0);
      expect(stats.totalTickets).toBe(0);
      expect(stats.totalSold).toBe(0);
      expect(stats.lastSeeded).toBeNull();
    });

    test("should update global stats after seeding", () => {
      const metadata = {
        eventId: "1",
        name: "Test Event",
        totalTickets: 3,
        soldTickets: 0,
        createdAt: "2024-01-01T00:00:00.000Z",
        lastSoldAt: "never",
      };
      fallbackStore.seedEvent("1", ["t1", "t2", "t3"], metadata);

      const stats = fallbackStore.getGlobalStats();
      expect(stats.totalEvents).toBe(1);
      expect(stats.totalTickets).toBe(3);
    });
  });

  describe("Status Information", () => {
    test("should return correct status", () => {
      const status = fallbackStore.getStatus();
      expect(status.active).toBe(false);
      expect(status.eventsCount).toBe(0);
      expect(status.totalTickets).toBe(0);
      expect(status.totalSold).toBe(0);
      expect(status.activationReason).toBeNull();
    });

    test("should return correct status when active", () => {
      fallbackStore.activate("Test reason");
      const status = fallbackStore.getStatus();
      expect(status.active).toBe(true);
      expect(status.activationReason).toBe("Test reason");
    });
  });
});