Testing APIs

// APIForge test case planning for user registration endpoint
const testCases = {
  happyPath: {
    validRegistration: {
      input: { email: "dev@apiforge.com", password: "SecurePass123!" },
      expected: { status: 201, response: { userId: expect.any(String) } }
    }
  },
  
  errorConditions: {
    duplicateEmail: {
      input: { email: "existing@apiforge.com", password: "SecurePass123!" },
      expected: { status: 409, error: "Email already registered" }
    },
    weakPassword: {
      input: { email: "new@apiforge.com", password: "123" },
      expected: { status: 400, error: "Password must be at least 8 characters" }
    }
  },
  
  edgeCases: {
    emptyPayload: {
      input: {},
      expected: { status: 400, error: "Email and password required" }
    }
  }
};

// APIForge test environment setup script
const testSetup = {
  async beforeAll() {
    // Start test database container
    await docker.run('postgres:14', {
      env: { POSTGRES_DB: 'apiforge_test' },
      port: '5433:5432'
    });
    
    // Run database migrations
    await db.migrate();
    
    // Create test API keys
    this.testApiKey = await createTestApiKey('test-suite');
  },
  
  async beforeEach() {
    // Clean slate for each test
    await db.truncate(['users', 'projects', 'deployments']);
    
    // Seed minimal required data
    this.testUser = await createTestUser({
      email: 'test@apiforge.com',
      verified: true
    });
  },
  
  async afterAll() {
    // Cleanup test containers
    await docker.stop('apiforge-test-db');
  }
};

// APIForge automated test suite for project management API
describe('Project Management API', () => {
  let authToken, testProject;
  
  beforeEach(async () => {
    authToken = await getTestAuthToken();
    testProject = await createTestProject({
      name: 'Test Project',
      owner: testUser.id
    });
  });
  
  describe('GET /api/projects', () => {
    it('returns user projects with proper pagination', async () => {
      const response = await request(app)
        .get('/api/projects?page=1&limit=10')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);
      
      expect(response.body).toMatchObject({
        data: expect.arrayContaining([
          expect.objectContaining({
            id: expect.any(String),
            name: expect.any(String),
            createdAt: expect.any(String)
          })
        ]),
        pagination: {
          page: 1,
          limit: 10,
          total: expect.any(Number)
        }
      });
    });
    
    it('requires valid authentication', async () => {
      await request(app)
        .get('/api/projects')
        .expect(401)
        .expect(res => {
          expect(res.body.error).toBe('Authentication required');
        });
    });
  });
});

// APIForge comprehensive error handling tests
describe('Error Handling and Security', () => {
  describe('Input validation', () => {
    it('rejects malformed JSON with clear error', async () => {
      const response = await request(app)
        .post('/api/projects')
        .set('Authorization', `Bearer ${authToken}`)
        .send('{"name": invalid json}')
        .expect(400);
      
      expect(response.body).toMatchObject({
        error: 'Invalid JSON format',
        code: 'MALFORMED_JSON',
        details: expect.any(String)
      });
    });
    
    it('prevents SQL injection attempts', async () => {
      const maliciousInput = {
        name: "'; DROP TABLE projects; --",
        description: "Normal description"
      };
      
      const response = await request(app)
        .post('/api/projects')
        .set('Authorization', `Bearer ${authToken}`)
        .send(maliciousInput)
        .expect(201);
      
      // Verify project was created safely
      expect(response.body.name).toBe(maliciousInput.name);
      
      // Verify database wasn't compromised
      const projectCount = await db.count('projects');
      expect(projectCount).toBeGreaterThan(0);
    });
  });
  
  describe('Rate limiting', () => {
    it('enforces request limits per user', async () => {
      // Make requests up to limit
      for (let i = 0; i < 100; i++) {
        await request(app)
          .get('/api/projects')
          .set('Authorization', `Bearer ${authToken}`)
          .expect(200);
      }
      
      // 101st request should be rate limited
      const response = await request(app)
        .get('/api/projects')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(429);
      
      expect(response.headers['retry-after']).toBeDefined();
    });
  });
});

// APIForge load testing with artillery.js
module.exports = {
  config: {
    target: 'https://api.apiforge.com',
    phases: [
      { duration: '2m', arrivalRate: 10 }, // Warm up
      { duration: '5m', arrivalRate: 50 }, // Normal load  
      { duration: '2m', arrivalRate: 100 } // Peak load
    ],
    defaults: {
      headers: {
        'Authorization': 'Bearer {{ $processEnvironment.TEST_TOKEN }}',
        'Content-Type': 'application/json'
      }
    }
  },
  scenarios: [
    {
      name: 'Browse projects and deployments',
      weight: 60,
      flow: [
        { get: { url: '/api/projects' } },
        { think: 2 },
        { get: { url: '/api/projects/{{ project_id }}/deployments' } },
        { think: 3 }
      ]
    },
    {
      name: 'Create new deployment',
      weight: 20,
      flow: [
        { post: {
            url: '/api/deployments',
            json: {
              projectId: '{{ project_id }}',
              environment: 'staging',
              gitRef: 'main'
            }
        }},
        { think: 5 }
      ]
    },
    {
      name: 'Check deployment status',
      weight: 20,
      flow: [
        { get: { url: '/api/deployments/{{ deployment_id }}/status' } }
      ]
    }
  ]
};