initial commit

Author: ajtatey

.gitignore

@@ -0,0 +1,3 @@
+.serverless
+.env
+node_modules

EcommerceClient.js

@@ -0,0 +1,161 @@
+class EcommerceClient {
+    constructor(config = {}) {
+      this.baseURL = config.baseURL || 'https://your-api-endpoint.amazonaws.com';
+      this.timeout = config.timeout || 5000;
+      this.headers = {
+        'Content-Type': 'application/json',
+        ...(config.headers || {})
+      };
+    }
+  
+    // Helper method to handle API calls
+    async fetchWithTimeout(endpoint, options = {}) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+  
+      try {
+        const response = await fetch(`${this.baseURL}${endpoint}`, {
+          ...options,
+          headers: this.headers,
+          signal: controller.signal
+        });
+  
+        const responseData = await response.json().catch(() => ({}));
+  
+        if (!response.ok) {
+          throw new Error(`API Error: ${response.status} - ${responseData.error || response.statusText || 'Unknown error'} 
+            \nEndpoint: ${endpoint}
+            \nResponse: ${JSON.stringify(responseData)}`);
+        }
+  
+        return responseData.data;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  
+    // Users
+    async getAllUsers() {
+      return this.fetchWithTimeout('/users', {
+        method: 'GET'
+      });
+    }
+  
+    // Sales
+    async getSales() {
+      return this.fetchWithTimeout('/sales', {
+        method: 'GET'
+      });
+    }
+  
+    // Inventory
+    async getInventory() {
+      return this.fetchWithTimeout('/inventory', {
+        method: 'GET'
+      });
+    }
+  
+    async updateInventory(productId, warehouseId, quantity) {
+      return this.fetchWithTimeout('/inventory', {
+        method: 'PUT',
+        body: JSON.stringify({
+          product_id: productId,
+          warehouse_id: warehouseId,
+          quantity
+        })
+      });
+    }
+  
+    // Fulfillment
+    async createFulfillment(orderId, warehouseId, items) {
+      return this.fetchWithTimeout('/fulfillment', {
+        method: 'POST',
+        body: JSON.stringify({
+          order_id: orderId,
+          warehouse_id: warehouseId,
+          items
+        })
+      });
+    }
+  
+    async getFulfillmentStatus(fulfillmentId) {
+      return this.fetchWithTimeout(`/fulfillment/${fulfillmentId}`, {
+        method: 'GET'
+      });
+    }
+  }
+  
+  // Example usage
+  const runExample = async () => {
+    const client = new EcommerceClient({
+      baseURL: 'https://your-api-endpoint.amazonaws.com',
+      timeout: 5000,
+      headers: {
+        'Authorization': 'Bearer your-token-here'
+      }
+    });
+  
+    try {
+      // Get all users
+      const users = await client.getAllUsers();
+      console.log('Users:', users);
+  
+      // Get sales data
+      const sales = await client.getSales();
+      console.log('Sales:', sales);
+  
+      // Check inventory
+      const inventory = await client.getInventory();
+      console.log('Inventory:', inventory);
+  
+      // Update inventory
+      const updatedInventory = await client.updateInventory(1, 1, 10);
+      console.log('Updated Inventory:', updatedInventory);
+  
+      // Create a fulfillment
+      const fulfillment = await client.createFulfillment('ORD-2024-009', 1, [
+        { product_id: 1, quantity: 1 },
+        { product_id: 2, quantity: 2 }
+      ]);
+      console.log('Created Fulfillment:', fulfillment);
+  
+      // Check fulfillment status
+      const status = await client.getFulfillmentStatus(fulfillment.id);
+      console.log('Fulfillment Status:', status);
+  
+    } catch (error) {
+      console.error('Error:', error.message);
+    }
+  };
+  
+  // Test with fake data
+  const testClient = async () => {
+    const client = new EcommerceClient({
+      baseURL: 'https://fake-api.example.com'
+    });
+  
+    // Mock response for testing
+    globalThis.fetch = async (url, options) => {
+      const mockData = {
+        data: {
+          id: 1,
+          status: 'success',
+          timestamp: new Date().toISOString()
+        }
+      };
+  
+      return {
+        ok: true,
+        json: async () => mockData
+      };
+    };
+  
+    try {
+      const result = await client.getSales();
+      console.log('Test result:', result);
+    } catch (error) {
+      console.error('Test error:', error);
+    }
+  };
+  
+  module.exports = EcommerceClient;

app.js

@@ -0,0 +1,11 @@
+import EcommerceClient from './EcommerceClient.js';
+
+const client = new EcommerceClient({
+  baseURL: 'https://q25v3hkkfk.execute-api.us-east-1.amazonaws.com',
+  timeout: 5000,
+  
+});
+
+// Example call
+const inventory = await client.getInventory();
+console.log(inventory);

load-testing.js

@@ -0,0 +1,164 @@
+const EcommerceClient = require('./EcommerceClient');
+
+// Utility to add random delay
+const randomDelay = (min, max) => {
+  const delay = Math.floor(Math.random() * (max - min + 1) + min);
+  return new Promise(resolve => setTimeout(resolve, delay));
+};
+
+// Simulate a single user's behavior
+class VirtualUser {
+  constructor(userId, baseURL) {
+    this.userId = userId;
+    this.client = new EcommerceClient({
+      baseURL,
+      headers: {
+        'User-Agent': `Virtual-User-${userId}`,
+        'X-Test-User-Id': userId.toString()
+      }
+    });
+  }
+
+  async randomAction() {
+    // List of possible actions with their relative weights
+    const actions = [
+      { weight: 40, action: () => this.client.getInventory() },             // Most common
+      { weight: 30, action: () => this.client.getSales() },                 // Very common
+      { weight: 15, action: () => this.client.getFulfillmentStatus(1) },    // Less common
+      { weight: 10, action: () => this.client.getAllUsers() },              // Occasional
+      { weight: 5, action: () => this.createRandomFulfillment() }           // Rare
+    ];
+
+    // Choose random action based on weights
+    const totalWeight = actions.reduce((sum, action) => sum + action.weight, 0);
+    let random = Math.random() * totalWeight;
+    
+    for (const { weight, action } of actions) {
+      if (random < weight) return action();
+      random -= weight;
+    }
+  }
+
+  async createRandomFulfillment() {
+    const orderId = `ORD-${Date.now()}-${this.userId}`;
+    const warehouseId = Math.floor(Math.random() * 3) + 1;
+    const items = [
+      {
+        product_id: Math.floor(Math.random() * 5) + 1,
+        quantity: Math.floor(Math.random() * 3) + 1
+      }
+    ];
+    
+    return this.client.createFulfillment(orderId, warehouseId, items);
+  }
+
+  async simulateUserSession(duration = 60000) {
+    const startTime = Date.now();
+    const results = [];
+
+    while (Date.now() - startTime < duration) {
+      try {
+        const startActionTime = Date.now();
+        const result = await this.randomAction();
+        const endActionTime = Date.now();
+
+        results.push({
+          userId: this.userId,
+          success: true,
+          responseTime: endActionTime - startActionTime
+        });
+
+        // Random delay between actions (0.5 to 3 seconds)
+        await randomDelay(500, 3000);
+      } catch (error) {
+        results.push({
+          userId: this.userId,
+          success: false,
+          error: error.message
+        });
+      }
+    }
+
+    return results;
+  }
+}
+
+// Load test orchestrator
+class LoadTest {
+  constructor(config = {}) {
+    this.baseURL = config.baseURL || 'https://your-api-endpoint.amazonaws.com';
+    this.numUsers = config.numUsers || 10;
+    this.testDuration = config.testDuration || 60000; // 1 minute default
+    this.results = [];
+  }
+
+  async run() {
+    console.log(`Starting load test with ${this.numUsers} users for ${this.testDuration/1000} seconds`);
+    const startTime = Date.now();
+
+    // Create and start all virtual users
+    const users = Array.from({ length: this.numUsers }, 
+      (_, i) => new VirtualUser(i + 1, this.baseURL)
+    );
+
+    const userSessions = users.map(user => 
+      user.simulateUserSession(this.testDuration)
+    );
+
+    // Wait for all user sessions to complete
+    const allResults = await Promise.all(userSessions);
+    this.results = allResults.flat();
+
+    // Calculate statistics
+    this.printStatistics();
+  }
+
+  printStatistics() {
+    const totalRequests = this.results.length;
+    const successfulRequests = this.results.filter(r => r.success).length;
+    const failedRequests = totalRequests - successfulRequests;
+    
+    const responseTimes = this.results
+      .filter(r => r.success)
+      .map(r => r.responseTime);
+
+    const avgResponseTime = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
+    
+    console.log('\nLoad Test Results:');
+    console.log('==================');
+    console.log(`Total Requests: ${totalRequests}`);
+    console.log(`Successful Requests: ${successfulRequests}`);
+    console.log(`Failed Requests: ${failedRequests}`);
+    console.log(`Success Rate: ${((successfulRequests/totalRequests) * 100).toFixed(2)}%`);
+    console.log(`Average Response Time: ${avgResponseTime.toFixed(2)}ms`);
+    
+    // Print error distribution if any failures
+    if (failedRequests > 0) {
+      const errorCounts = this.results
+        .filter(r => !r.success)
+        .reduce((acc, curr) => {
+          acc[curr.error] = (acc[curr.error] || 0) + 1;
+          return acc;
+        }, {});
+
+      console.log('\nError Distribution:');
+      Object.entries(errorCounts).forEach(([error, count]) => {
+        console.log(`${error}: ${count} occurrences`);
+      });
+    }
+  }
+}
+
+// Example usage
+const runLoadTest = async () => {
+  const loadTest = new LoadTest({
+    baseURL: 'https://q25v3hkkfk.execute-api.us-east-1.amazonaws.com',
+    numUsers: 50,        // 50 concurrent users
+    testDuration: 300000 // 5 minutes
+  });
+
+  await loadTest.run();
+};
+
+// Run the test
+runLoadTest().catch(console.error);

neon-lambda/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.serverless