yasumi/test/e2e/http.test.ts

import {
	beforeAll,
	afterAll,
	afterEach,
	beforeEach,
	describe,
	expect,
	it,
} from 'vitest';
import {
	tmpdir
} from 'os';
import {
	mkdtemp,
	rm,
	writeFile,
} from 'fs/promises';
import {
	join
} from 'path';
import {request} from 'http';
import {constants} from 'http2';
import {BackendBuilder, dataSources} from '../../src/backend';
import { application, resource, validation as v, Resource } from '../../src/common';
import { autoIncrement } from '../fixtures';

const PORT = 3000;
const HOST = '127.0.0.1';
const BASE_PATH = '/api';
const ACCEPT = 'application/json';
const ACCEPT_LANGUAGE = 'en';
const CONTENT_TYPE_CHARSET = 'utf-8';
const CONTENT_TYPE = ACCEPT;

describe('yasumi HTTP', () => {
	let baseDir: string;
	beforeAll(async () => {
		try {
			baseDir = await mkdtemp(join(tmpdir(), 'yasumi-'));
		} catch {
			// noop
		}
	});
	afterAll(async () => {
		try {
			await rm(baseDir, {
				recursive: true,
			});
		} catch {
			// noop
		}
	});

	let Piano: Resource;
	beforeEach(() => {
		Piano = resource(v.object(
			{
				brand: v.string()
			},
			v.never()
		))
			.name('Piano' as const)
			.route('pianos' as const)
			.id('id' as const, {
				generationStrategy: autoIncrement,
				serialize: (id) => id?.toString() ?? '0',
				deserialize: (id) => Number.isFinite(Number(id)) ? Number(id) : 0,
				schema: v.number(),
			});
	});

	let backend: BackendBuilder;
	let server: ReturnType<BackendBuilder['createHttpServer']>;
	beforeEach(() => {
		const app = application({
			name: 'piano-service',
		})
			.resource(Piano);

		backend = app.createBackend({
			dataSource: new dataSources.jsonlFile.DataSource(baseDir),
		});

		server = backend.createHttpServer({
			basePath: BASE_PATH
		});

		return new Promise((resolve, reject) => {
			server.on('error', (err) => {
				reject(err);
			});

			server.on('listening', () => {
				resolve();
			});

			server.listen({
				port: PORT
			});
		});
	});

	afterEach(() => new Promise((resolve, reject) => {
		server.close((err) => {
			if (err) {
				reject(err);
			}

			resolve();
		});
	}));

	describe('happy path', () => {
		describe('serving collections', () => {
			beforeEach(() => {
				Piano.canFetchCollection();
				return new Promise((resolve) => {
					setTimeout(() => {
						resolve();
					});
				});
			});

			afterEach(() => {
				Piano.canFetchCollection(false);
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('GET');
							expect(allowedMethods).toContain('HEAD');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('returns data', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos`,
							method: 'GET',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							// TODO test status messsages
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual([]);
								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('returns data on HEAD method', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos`,
							method: 'HEAD',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe('serving items', () => {
			const existingResource = {
				id: 1,
				brand: 'Yamaha'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(existingResource));
			});

			beforeEach(() => {
				Piano.canFetchItem();
				return new Promise((resolve) => {
					setTimeout(() => {
						resolve();
					});
				});
			});

			afterEach(() => {
				Piano.canFetchItem(false);
			});

			it('returns data', () => {
				return new Promise<void>((resolve, reject) => {
					// TODO all responses should have serialized ids
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'GET',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual(existingResource);
								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('returns data on HEAD method', () => {
				return new Promise<void>((resolve, reject) => {
					// TODO all responses should have serialized ids
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'HEAD',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('GET');
							expect(allowedMethods).toContain('HEAD');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe('creating items', () => {
			const existingResource = {
				id: 1,
				brand: 'Yamaha'
			};

			const newResourceData = {
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(existingResource));
			});

			beforeEach(() => {
				Piano.canCreate();
			});

			afterEach(() => {
				Piano.canCreate(false);
			});

			it('returns data', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos`,
							method: 'POST',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
								'Content-Type': `${CONTENT_TYPE}; charset="${CONTENT_TYPE_CHARSET}"`,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_CREATED);
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual({
									...newResourceData,
									id: 2
								});

								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.write(JSON.stringify(newResourceData));
					req.end();
				});
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('POST');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe('patching items', () => {
			const existingResource = {
				id: 1,
				brand: 'Yamaha'
			};

			const patchData = {
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(existingResource));
			});

			beforeEach(() => {
				Piano.canPatch();
			});

			afterEach(() => {
				Piano.canPatch(false);
			});

			it('returns data', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'PATCH',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
								'Content-Type': `${CONTENT_TYPE}; charset="${CONTENT_TYPE_CHARSET}"`,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual({
									...existingResource,
									...patchData,
								});
								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.write(JSON.stringify(patchData));
					req.end();
				});
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('PATCH');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe('emplacing items', () => {
			const existingResource = {
				id: 1,
				brand: 'Yamaha'
			};

			const emplaceResourceData = {
				id: 1,
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(existingResource));
			});

			beforeEach(() => {
				Piano.canEmplace();
			});

			afterEach(() => {
				Piano.canEmplace(false);
			});

			it('returns data for replacement', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${emplaceResourceData.id}`,
							method: 'PUT',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
								'Content-Type': `${CONTENT_TYPE}; charset="${CONTENT_TYPE_CHARSET}"`,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual(emplaceResourceData);
								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.write(JSON.stringify(emplaceResourceData));
					req.end();
				});
			});

			it('returns data for creation', () => {
				return new Promise<void>((resolve, reject) => {
					const newId = 2;

					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${newId}`,
							method: 'PUT',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
								'Content-Type': `${CONTENT_TYPE}; charset="${CONTENT_TYPE_CHARSET}"`,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_CREATED);
							expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));

							let resBuffer = Buffer.from('');
							res.on('data', (c) => {
								resBuffer = Buffer.concat([resBuffer, c]);
							});

							res.on('close', () => {
								const resBufferJson = resBuffer.toString(CONTENT_TYPE_CHARSET);
								const resData = JSON.parse(resBufferJson);
								expect(resData).toEqual({
									...emplaceResourceData,
									id: newId,
								});
								resolve();
							});
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.write(JSON.stringify({
						...emplaceResourceData,
						id: newId,
					}));
					req.end();
				});
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('PUT');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe('deleting items', () => {
			const existingResource = {
				id: 1,
				brand: 'Yamaha'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(existingResource));
			});

			beforeEach(() => {
				Piano.canDelete();
			});

			afterEach(() => {
				Piano.canDelete(false);
			});

			it('responds', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'DELETE',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('returns options', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/${existingResource.id}`,
							method: 'OPTIONS',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
							const allowedMethods = res.headers.allow?.split(',').map((s) => s.trim()) ?? [];
							expect(allowedMethods).toContain('DELETE');
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});
	});

	describe('error handling', () => {
		describe.skip('serving collections', () => {
			beforeEach(() => {
				Piano.canFetchCollection();
				return new Promise((resolve) => {
					setTimeout(() => {
						resolve();
					});
				});
			});

			afterEach(() => {
				Piano.canFetchCollection(false);
			});
		});

		describe('serving items', () => {
			const data = {
				id: 1,
				brand: 'Yamaha'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(data));
			});

			beforeEach(() => {
				Piano.canFetchItem();
				return new Promise((resolve) => {
					setTimeout(() => {
						resolve();
					});
				});
			});

			afterEach(() => {
				Piano.canFetchItem(false);
			});

			it('throws on item not found', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/2`,
							method: 'GET',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								Piano.canFetchItem(false);
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});

			it('throws on item not found on HEAD method', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/2`,
							method: 'HEAD',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								Piano.canFetchItem(false);
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});

		describe.skip('creating items', () => {
			const data = {
				id: 1,
				brand: 'Yamaha'
			};

			const newData = {
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(data));
			});

			beforeEach(() => {
				Piano.canCreate();
			});

			afterEach(() => {
				Piano.canCreate(false);
			});
		});

		describe('patching items', () => {
			const data = {
				id: 1,
				brand: 'Yamaha'
			};

			const newData = {
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(data));
			});

			beforeEach(() => {
				Piano.canPatch();
			});

			afterEach(() => {
				Piano.canPatch(false);
			});

			it('throws on item to patch not found', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/2`,
							method: 'PATCH',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
								'Content-Type': `${CONTENT_TYPE}; charset="${CONTENT_TYPE_CHARSET}"`,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.write(JSON.stringify(newData));
					req.end();
				});
			});
		});

		describe.skip('emplacing items', () => {
			const data = {
				id: 1,
				brand: 'Yamaha'
			};

			const newData = {
				id: 1,
				brand: 'K. Kawai'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(data));
			});

			beforeEach(() => {
				Piano.canEmplace();
			});

			afterEach(() => {
				Piano.canEmplace(false);
			});
		});

		describe('deleting items', () => {
			const data = {
				id: 1,
				brand: 'Yamaha'
			};

			beforeEach(async () => {
				const resourcePath = join(baseDir, 'pianos.jsonl');
				await writeFile(resourcePath, JSON.stringify(data));
			});

			beforeEach(() => {
				Piano.canDelete();
				backend.throwsErrorOnDeletingNotFound();
			});

			afterEach(() => {
				Piano.canDelete(false);
				backend.throwsErrorOnDeletingNotFound(false);
			});

			it('throws on item not found', () => {
				return new Promise<void>((resolve, reject) => {
					const req = request(
						{
							host: HOST,
							port: PORT,
							path: `${BASE_PATH}/pianos/2`,
							method: 'DELETE',
							headers: {
								'Accept': ACCEPT,
								'Accept-Language': ACCEPT_LANGUAGE,
							},
						},
						(res) => {
							res.on('error', (err) => {
								reject(err);
							});

							expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
							resolve();
						},
					);

					req.on('error', (err) => {
						reject(err);
					});

					req.end();
				});
			});
		});
	});
});