feat: add integration and setup tests and complete code review fixes
This commit is contained in:
Ayobami
@@ -0,0 +1,416 @@
|
||||
const request = require("supertest");
|
||||
const app = require("../../server");
|
||||
const redisClient = require("../../src/utils/redis-client");
|
||||
const fallbackStore = require("../../src/utils/fallback-store");
|
||||
|
||||
describe("Performance and Load Testing", () => {
|
||||
let server;
|
||||
let testEventId = "777"; // Use a unique event ID for testing
|
||||
const CONCURRENT_REQUESTS = 100; // Test with 100 concurrent requests
|
||||
const TICKET_COUNT = 50; // Start with 50 tickets
|
||||
|
||||
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 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: "Performance Test Event",
|
||||
description: "Test event for load testing",
|
||||
totalTickets: TICKET_COUNT.toString(),
|
||||
soldTickets: "0",
|
||||
createdAt: new Date().toISOString(),
|
||||
lastSoldAt: "never",
|
||||
});
|
||||
|
||||
// Create test tickets
|
||||
const testTickets = Array.from(
|
||||
{ length: TICKET_COUNT },
|
||||
(_, i) => `perf-ticket-${i + 1}`
|
||||
);
|
||||
await redisClient.client.lPush(testTicketsKey, testTickets);
|
||||
}
|
||||
});
|
||||
|
||||
describe("High Concurrency Ticket Purchase", () => {
|
||||
test("should handle 100 concurrent requests without duplicate tickets", async () => {
|
||||
if (!redisClient.isConnected) {
|
||||
console.warn("Skipping Redis test - Redis not connected");
|
||||
return;
|
||||
}
|
||||
|
||||
const soldTickets = new Set();
|
||||
const purchasePromises = [];
|
||||
const startTime = Date.now();
|
||||
|
||||
// Create concurrent purchase requests
|
||||
for (let i = 0; i < CONCURRENT_REQUESTS; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json")
|
||||
.then((response) => ({ success: true, response, index: i }))
|
||||
.catch((error) => ({ success: false, error, index: i }));
|
||||
|
||||
purchasePromises.push(promise);
|
||||
}
|
||||
|
||||
// Wait for all requests to complete
|
||||
const results = await Promise.all(purchasePromises);
|
||||
const endTime = Date.now();
|
||||
const totalTime = endTime - startTime;
|
||||
|
||||
let successCount = 0;
|
||||
let failureCount = 0;
|
||||
let duplicateCount = 0;
|
||||
|
||||
results.forEach((result) => {
|
||||
if (
|
||||
result.success &&
|
||||
result.response.status === 200 &&
|
||||
result.response.body.success
|
||||
) {
|
||||
successCount++;
|
||||
const ticket = result.response.body.ticket;
|
||||
|
||||
// Check for duplicates
|
||||
if (soldTickets.has(ticket)) {
|
||||
duplicateCount++;
|
||||
} else {
|
||||
soldTickets.add(ticket);
|
||||
}
|
||||
} else {
|
||||
failureCount++;
|
||||
}
|
||||
});
|
||||
|
||||
// Performance metrics
|
||||
const avgResponseTime = totalTime / CONCURRENT_REQUESTS;
|
||||
const requestsPerSecond = (CONCURRENT_REQUESTS / totalTime) * 1000;
|
||||
|
||||
console.log(`\n📊 Performance Test Results:`);
|
||||
console.log(` Total Time: ${totalTime}ms`);
|
||||
console.log(` Average Response Time: ${avgResponseTime.toFixed(2)}ms`);
|
||||
console.log(` Requests per Second: ${requestsPerSecond.toFixed(2)}`);
|
||||
console.log(` Success Count: ${successCount}`);
|
||||
console.log(` Failure Count: ${failureCount}`);
|
||||
console.log(` Duplicate Tickets: ${duplicateCount}`);
|
||||
|
||||
// Critical assertions
|
||||
expect(duplicateCount).toBe(0); // No duplicate tickets allowed
|
||||
expect(successCount).toBe(TICKET_COUNT); // Should sell exactly available tickets
|
||||
expect(failureCount).toBe(CONCURRENT_REQUESTS - TICKET_COUNT); // Remaining should fail
|
||||
expect(soldTickets.size).toBe(TICKET_COUNT); // All sold tickets should be unique
|
||||
|
||||
// Performance requirements
|
||||
expect(avgResponseTime).toBeLessThan(1000); // Should respond within 1 second on average
|
||||
expect(requestsPerSecond).toBeGreaterThan(10); // Should handle at least 10 RPS
|
||||
});
|
||||
|
||||
test("should maintain data consistency under high load", async () => {
|
||||
if (!redisClient.isConnected) {
|
||||
console.warn("Skipping Redis test - Redis not connected");
|
||||
return;
|
||||
}
|
||||
|
||||
// Purchase 20 tickets under load
|
||||
const purchasePromises = [];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json");
|
||||
|
||||
purchasePromises.push(promise);
|
||||
}
|
||||
|
||||
await Promise.all(purchasePromises);
|
||||
|
||||
// Verify Redis consistency
|
||||
const remainingTickets = await redisClient.client.lLen(
|
||||
`event:${testEventId}:tickets`
|
||||
);
|
||||
const eventStats = await redisClient.getEventStats(testEventId);
|
||||
|
||||
expect(remainingTickets).toBe(TICKET_COUNT - 20);
|
||||
expect(eventStats.soldTickets).toBe(20);
|
||||
expect(eventStats.remainingTickets).toBe(TICKET_COUNT - 20);
|
||||
|
||||
// Verify no tickets remain after exhausting supply
|
||||
const finalPurchasePromises = [];
|
||||
for (let i = 0; i < TICKET_COUNT; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json");
|
||||
|
||||
finalPurchasePromises.push(promise);
|
||||
}
|
||||
|
||||
const finalResults = await Promise.all(finalPurchasePromises);
|
||||
const finalSuccessCount = finalResults.filter(
|
||||
(r) =>
|
||||
r.response && r.response.status === 200 && r.response.body.success
|
||||
).length;
|
||||
|
||||
expect(finalSuccessCount).toBe(TICKET_COUNT - 20); // Should only sell remaining tickets
|
||||
});
|
||||
});
|
||||
|
||||
describe("Fallback Store Performance", () => {
|
||||
test("should handle high concurrency in fallback mode", async () => {
|
||||
// Disconnect Redis to simulate failure
|
||||
if (redisClient.isConnected) {
|
||||
await redisClient.disconnect();
|
||||
}
|
||||
|
||||
// Seed fallback store with test event
|
||||
const metadata = {
|
||||
eventId: testEventId,
|
||||
name: "Fallback Performance Test Event",
|
||||
description: "Test event for fallback performance",
|
||||
totalTickets: 30,
|
||||
soldTickets: 0,
|
||||
createdAt: new Date().toISOString(),
|
||||
lastSoldAt: "never",
|
||||
};
|
||||
|
||||
const testTickets = Array.from(
|
||||
{ length: 30 },
|
||||
(_, i) => `fallback-perf-ticket-${i + 1}`
|
||||
);
|
||||
fallbackStore.seedEvent(testEventId, testTickets, metadata);
|
||||
fallbackStore.activate("Performance test fallback mode");
|
||||
|
||||
const soldTickets = new Set();
|
||||
const purchasePromises = [];
|
||||
const startTime = Date.now();
|
||||
|
||||
// Create 50 concurrent purchase requests (more than available)
|
||||
for (let i = 0; i < 50; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json")
|
||||
.then((response) => ({ success: true, response, index: i }))
|
||||
.catch((error) => ({ success: false, error, index: i }));
|
||||
|
||||
purchasePromises.push(promise);
|
||||
}
|
||||
|
||||
const results = await Promise.all(purchasePromises);
|
||||
const endTime = Date.now();
|
||||
const totalTime = endTime - startTime;
|
||||
|
||||
let successCount = 0;
|
||||
let failureCount = 0;
|
||||
let duplicateCount = 0;
|
||||
|
||||
results.forEach((result) => {
|
||||
if (
|
||||
result.success &&
|
||||
result.response.status === 200 &&
|
||||
result.response.body.success
|
||||
) {
|
||||
successCount++;
|
||||
const ticket = result.response.body.ticket;
|
||||
|
||||
if (soldTickets.has(ticket)) {
|
||||
duplicateCount++;
|
||||
} else {
|
||||
soldTickets.add(ticket);
|
||||
}
|
||||
} else {
|
||||
failureCount++;
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`\n📊 Fallback Performance Test Results:`);
|
||||
console.log(` Total Time: ${totalTime}ms`);
|
||||
console.log(` Success Count: ${successCount}`);
|
||||
console.log(` Failure Count: ${failureCount}`);
|
||||
console.log(` Duplicate Tickets: ${duplicateCount}`);
|
||||
|
||||
// Critical assertions for fallback mode
|
||||
expect(duplicateCount).toBe(0); // No duplicate tickets
|
||||
expect(successCount).toBe(30); // Should sell exactly available tickets
|
||||
expect(failureCount).toBe(20); // Remaining should fail
|
||||
expect(soldTickets.size).toBe(30); // All sold tickets should be unique
|
||||
|
||||
// Verify fallback store consistency
|
||||
const event = fallbackStore.events.get(testEventId);
|
||||
expect(event.tickets).toHaveLength(0); // No tickets should remain
|
||||
expect(event.soldTickets).toBe(30); // All tickets should be marked as sold
|
||||
});
|
||||
});
|
||||
|
||||
describe("Memory and Resource Usage", () => {
|
||||
test("should maintain stable memory usage under load", async () => {
|
||||
if (!redisClient.isConnected) {
|
||||
console.warn("Skipping Redis test - Redis not connected");
|
||||
return;
|
||||
}
|
||||
|
||||
const initialMemory = process.memoryUsage();
|
||||
console.log(`\n💾 Initial Memory Usage:`);
|
||||
console.log(` RSS: ${(initialMemory.rss / 1024 / 1024).toFixed(2)} MB`);
|
||||
console.log(
|
||||
` Heap Used: ${(initialMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`
|
||||
);
|
||||
|
||||
// Perform multiple rounds of purchases
|
||||
for (let round = 0; round < 3; round++) {
|
||||
// Reset test event
|
||||
const testTicketsKey = `event:${testEventId}:tickets`;
|
||||
await redisClient.client.del(testTicketsKey);
|
||||
const testTickets = Array.from(
|
||||
{ length: 20 },
|
||||
(_, i) => `round-${round}-ticket-${i + 1}`
|
||||
);
|
||||
await redisClient.client.lPush(testTicketsKey, testTickets);
|
||||
|
||||
// Purchase all tickets
|
||||
const purchasePromises = [];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json");
|
||||
|
||||
purchasePromises.push(promise);
|
||||
}
|
||||
|
||||
await Promise.all(purchasePromises);
|
||||
}
|
||||
|
||||
const finalMemory = process.memoryUsage();
|
||||
console.log(`\n💾 Final Memory Usage:`);
|
||||
console.log(` RSS: ${(finalMemory.rss / 1024 / 1024).toFixed(2)} MB`);
|
||||
console.log(
|
||||
` Heap Used: ${(finalMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`
|
||||
);
|
||||
|
||||
const memoryIncrease = finalMemory.heapUsed - initialMemory.heapUsed;
|
||||
const memoryIncreaseMB = memoryIncrease / 1024 / 1024;
|
||||
|
||||
console.log(`\n📈 Memory Change: ${memoryIncreaseMB.toFixed(2)} MB`);
|
||||
|
||||
// Memory should not increase excessively (less than 50MB increase)
|
||||
expect(memoryIncreaseMB).toBeLessThan(50);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Response Time Consistency", () => {
|
||||
test("should maintain consistent response times under varying load", async () => {
|
||||
if (!redisClient.isConnected) {
|
||||
console.warn("Skipping Redis test - Redis not connected");
|
||||
return;
|
||||
}
|
||||
|
||||
const responseTimes = [];
|
||||
const loadLevels = [10, 25, 50, 75, 100];
|
||||
|
||||
for (const loadLevel of loadLevels) {
|
||||
// Reset test event
|
||||
const testTicketsKey = `event:${testEventId}:tickets`;
|
||||
await redisClient.client.del(testTicketsKey);
|
||||
const testTickets = Array.from(
|
||||
{ length: loadLevel },
|
||||
(_, i) => `load-${loadLevel}-ticket-${i + 1}`
|
||||
);
|
||||
await redisClient.client.lPush(testTicketsKey, testTickets);
|
||||
|
||||
const startTime = Date.now();
|
||||
const purchasePromises = [];
|
||||
|
||||
for (let i = 0; i < loadLevel; i++) {
|
||||
const promise = request(server)
|
||||
.post(`/buy/${testEventId}`)
|
||||
.set("Content-Type", "application/json");
|
||||
|
||||
purchasePromises.push(promise);
|
||||
}
|
||||
|
||||
await Promise.all(purchasePromises);
|
||||
const endTime = Date.now();
|
||||
const responseTime = endTime - startTime;
|
||||
|
||||
responseTimes.push({
|
||||
loadLevel,
|
||||
responseTime,
|
||||
avgResponseTime: responseTime / loadLevel,
|
||||
});
|
||||
|
||||
console.log(`\n⚡ Load Level ${loadLevel}:`);
|
||||
console.log(` Total Time: ${responseTime}ms`);
|
||||
console.log(
|
||||
` Average Response: ${(responseTime / loadLevel).toFixed(2)}ms`
|
||||
);
|
||||
}
|
||||
|
||||
// Calculate consistency metrics
|
||||
const avgResponseTimes = responseTimes.map((r) => r.avgResponseTime);
|
||||
const minResponseTime = Math.min(...avgResponseTimes);
|
||||
const maxResponseTime = Math.max(...avgResponseTimes);
|
||||
const responseTimeVariance = maxResponseTime - minResponseTime;
|
||||
|
||||
console.log(`\n📊 Response Time Consistency:`);
|
||||
console.log(` Min Avg Response: ${minResponseTime.toFixed(2)}ms`);
|
||||
console.log(` Max Avg Response: ${maxResponseTime.toFixed(2)}ms`);
|
||||
console.log(` Variance: ${responseTimeVariance.toFixed(2)}ms`);
|
||||
|
||||
// Response times should be reasonably consistent (variance < 200ms)
|
||||
expect(responseTimeVariance).toBeLessThan(200);
|
||||
|
||||
// All response times should be reasonable (< 2 seconds average)
|
||||
avgResponseTimes.forEach((time) => {
|
||||
expect(time).toBeLessThan(2000);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user