import { describe, it, expect, beforeEach, afterEach } from 'vitest'
import { HttpClient } from '../http-client'
import express from 'express'
import type { OpenAPIV3 } from 'openapi-types'
import type { Server } from 'http'
interface Pet {
id: number
name: string
species: string
age: number
status: 'available' | 'pending' | 'sold'
}
// Simple in-memory pet store
let pets: Pet[] = []
let nextId = 1
// Initialize/reset pets data
function resetPets() {
pets = [
{ id: 1, name: 'Fluffy', species: 'Cat', age: 3, status: 'available' },
{ id: 2, name: 'Max', species: 'Dog', age: 5, status: 'available' },
{ id: 3, name: 'Tweety', species: 'Bird', age: 1, status: 'sold' },
]
nextId = 4
}
function createTestServer(port: number): Server {
const app = express()
app.use(express.json())
// GET /pets - List all pets
app.get('/pets', (req, res) => {
const status = req.query.status
const filtered = status ? pets.filter((p) => p.status === status) : pets
res.json(filtered)
})
// POST /pets - Create a pet
app.post('/pets', (req, res) => {
const newPet: Pet = {
id: nextId++,
name: req.body.name,
species: req.body.species,
age: req.body.age,
status: 'available',
}
pets.push(newPet)
res.status(201).json(newPet)
})
// GET /pets/:id - Get a pet by ID
app.get('/pets/:id', (req: any, res: any) => {
const pet = pets.find((p) => p.id === Number(req.params.id))
if (!pet) {
return res.status(404).json({ error: 'Pet not found' })
}
res.json(pet)
})
// PUT /pets/:id - Update a pet
app.put('/pets/:id', (req: any, res: any) => {
const pet = pets.find((p) => p.id === Number(req.params.id))
if (!pet) {
return res.status(404).json({ error: 'Pet not found' })
}
if (req.body.status) pet.status = req.body.status
res.json(pet)
})
// DELETE /pets/:id - Delete a pet
app.delete('/pets/:id', (req: any, res: any) => {
const index = pets.findIndex((p) => p.id === Number(req.params.id))
if (index === -1) {
return res.status(404).json({ error: 'Pet not found' })
}
pets.splice(index, 1)
res.status(204).send()
})
return app.listen(port)
}
describe('HttpClient Integration Tests', () => {
let PORT: number
let BASE_URL: string
let server: Server
let openApiSpec: OpenAPIV3.Document
let client: HttpClient
beforeEach(async () => {
// Use a random port to avoid conflicts
PORT = 3000 + Math.floor(Math.random() * 1000)
BASE_URL = `http://localhost:${PORT}`
// Initialize pets data
resetPets()
// Start the test server
server = createTestServer(PORT)
// Create a minimal OpenAPI spec for the test server
openApiSpec = {
openapi: '3.0.0',
info: { title: 'Pet Store API', version: '1.0.0' },
servers: [{ url: BASE_URL }],
paths: {
'/pets': {
get: {
operationId: 'listPets',
parameters: [{ name: 'status', in: 'query', schema: { type: 'string' } }],
responses: { '200': { description: 'Success' } },
},
post: {
operationId: 'createPet',
requestBody: { content: { 'application/json': { schema: { type: 'object' } } } },
responses: { '201': { description: 'Created' } },
},
},
'/pets/{id}': {
get: {
operationId: 'getPet',
parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
responses: { '200': { description: 'Success' }, '404': { description: 'Not found' } },
},
put: {
operationId: 'updatePet',
parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
requestBody: { content: { 'application/json': { schema: { type: 'object' } } } },
responses: { '200': { description: 'Success' }, '404': { description: 'Not found' } },
},
delete: {
operationId: 'deletePet',
parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
responses: { '204': { description: 'Deleted' }, '404': { description: 'Not found' } },
},
},
},
}
// Create HTTP client
client = new HttpClient(
{
baseUrl: BASE_URL,
headers: {
Accept: 'application/json',
},
},
openApiSpec,
)
})
afterEach(async () => {
server.close()
})
it('should list all pets', async () => {
const operation = openApiSpec.paths['/pets']?.get
if (!operation) throw new Error('Operation not found')
const response = await client.executeOperation<Pet[]>(operation as OpenAPIV3.OperationObject & { method: string; path: string })
expect(response.status).toBe(200)
expect(Array.isArray(response.data)).toBe(true)
expect(response.data.length).toBeGreaterThan(0)
expect(response.data[0]).toHaveProperty('name')
expect(response.data[0]).toHaveProperty('species')
expect(response.data[0]).toHaveProperty('status')
})
it('should filter pets by status', async () => {
const operation = openApiSpec.paths['/pets']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
if (!operation) throw new Error('Operation not found')
const response = await client.executeOperation<Pet[]>(operation, { status: 'available' })
expect(response.status).toBe(200)
expect(Array.isArray(response.data)).toBe(true)
response.data.forEach((pet: Pet) => {
expect(pet.status).toBe('available')
})
})
it('should get a specific pet by ID', async () => {
const operation = openApiSpec.paths['/pets/{id}']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
if (!operation) throw new Error('Operation not found')
const response = await client.executeOperation<Pet>(operation, { id: 1 })
expect(response.status).toBe(200)
expect(response.data).toHaveProperty('id', 1)
expect(response.data).toHaveProperty('name')
expect(response.data).toHaveProperty('species')
})
it('should create a new pet', async () => {
const operation = openApiSpec.paths['/pets']?.post as OpenAPIV3.OperationObject & { method: string; path: string }
if (!operation) throw new Error('Operation not found')
const newPet = {
name: 'TestPet',
species: 'Dog',
age: 2,
}
const response = await client.executeOperation<Pet>(operation as OpenAPIV3.OperationObject & { method: string; path: string }, newPet)
expect(response.status).toBe(201)
expect(response.data).toMatchObject({
...newPet,
status: 'available',
})
expect(response.data.id).toBeDefined()
})
it("should update a pet's status", async () => {
const operation = openApiSpec.paths['/pets/{id}']?.put
if (!operation) throw new Error('Operation not found')
const response = await client.executeOperation<Pet>(operation as OpenAPIV3.OperationObject & { method: string; path: string }, {
id: 1,
status: 'sold',
})
expect(response.status).toBe(200)
expect(response.data).toHaveProperty('id', 1)
expect(response.data).toHaveProperty('status', 'sold')
})
it('should delete a pet', async () => {
// First create a pet to delete
const createOperation = openApiSpec.paths['/pets']?.post
if (!createOperation) throw new Error('Operation not found')
const createResponse = await client.executeOperation<Pet>(
createOperation as OpenAPIV3.OperationObject & { method: string; path: string },
{
name: 'ToDelete',
species: 'Cat',
age: 3,
},
)
const petId = createResponse.data.id
// Then delete it
const deleteOperation = openApiSpec.paths['/pets/{id}']?.delete
if (!deleteOperation) throw new Error('Operation not found')
const deleteResponse = await client.executeOperation(deleteOperation as OpenAPIV3.OperationObject & { method: string; path: string }, {
id: petId,
})
expect(deleteResponse.status).toBe(204)
// Verify the pet is deleted
const getOperation = openApiSpec.paths['/pets/{id}']?.get
if (!getOperation) throw new Error('Operation not found')
try {
await client.executeOperation(getOperation as OpenAPIV3.OperationObject & { method: string; path: string }, { id: petId })
throw new Error('Should not reach here')
} catch (error: any) {
expect(error.message).toContain('404')
}
})
it('should handle errors appropriately', async () => {
const operation = openApiSpec.paths['/pets/{id}']?.get as OpenAPIV3.OperationObject & { method: string; path: string }
if (!operation) throw new Error('Operation not found')
try {
await client.executeOperation(
operation as OpenAPIV3.OperationObject & { method: string; path: string },
{ id: 99999 }, // Non-existent ID
)
throw new Error('Should not reach here')
} catch (error: any) {
expect(error.message).toContain('404')
}
})
})
