yasumi/test/e2e/http/default.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 {constants} from 'http2';
import {Backend, dataSources} from '../../../src/backend';
import { application, resource, validation as v, Resource } from '../../../src/common';
import { autoIncrement } from '../../fixtures';
import {createTestClient, TestClient} from '../../utils';

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

describe('happy path', () => {
	let client: TestClient;
	beforeEach(() => {
		client = createTestClient({
			host: HOST,
			port: PORT,
		})
			.acceptMediaType(ACCEPT)
			.acceptLanguage(ACCEPT_LANGUAGE)
			.acceptCharset(ACCEPT_CHARSET)
			.contentType(CONTENT_TYPE)
			.contentCharset(CONTENT_TYPE_CHARSET);
	});

	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: Backend;
	let server: ReturnType<Backend['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('serving collections', () => {
		beforeEach(() => {
			Piano.canFetchCollection();
			return new Promise((resolve) => {
				setTimeout(() => {
					resolve();
				});
			});
		});

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

		it('returns data', async () => {
			const [res, resData] = await client({
				method: 'GET',
				path: `${BASE_PATH}/pianos`,
			});

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

			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual([]);
		});

		it('returns data on HEAD method', async () => {
			const [res] = await client({
				method: 'HEAD',
				path: `${BASE_PATH}/pianos`,
			});

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

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos`,
			});

			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');
		});
	});

	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', async () => {
			const [res, resData] = await client({
				method: 'GET',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_OK);
			expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));
			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual(existingResource);
		});

		it('returns data on HEAD method', async () => {
			const [res] = await client({
				method: 'HEAD',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

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

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

			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');
		});
	});

	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', async () => {
			const [res, resData] = await client({
				path: `${BASE_PATH}/pianos`,
				method: 'POST',
				body: newResourceData,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_CREATED);
			expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));
			expect(res.headers).toHaveProperty('location', `${BASE_PATH}/pianos/2`);

			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual({
				...newResourceData,
				id: 2
			});
		});

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos`,
			});

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

	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', async () => {
			const [res, resData] = await client({
				method: 'PATCH',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
				body: patchData,
			});

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

			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual({
				...existingResource,
				...patchData,
			});
		});

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

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

	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', async () => {
			const [res, resData] = await client({
				method: 'PUT',
				path: `${BASE_PATH}/pianos/${emplaceResourceData.id}`,
				body: emplaceResourceData,
			});

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

			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual(emplaceResourceData);
		});

		it('returns data for creation', async () => {
			const newId = 2;

			const [res, resData] = await client({
				method: 'PUT',
				path: `${BASE_PATH}/pianos/${newId}`,
				body: {
					...emplaceResourceData,
					id: newId,
				},
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_CREATED);
			expect(res.headers).toHaveProperty('content-type', expect.stringContaining(ACCEPT));
			expect(res.headers).toHaveProperty('location', `${BASE_PATH}/pianos/${newId}`);

			if (typeof resData === 'undefined') {
				expect.fail('Response body must be defined.');
				return;
			}

			expect(resData).toEqual({
				...emplaceResourceData,
				id: newId,
			});
		});

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

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

	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', async () => {
			const [res, resData] = await client({
				method: 'DELETE',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NO_CONTENT);
			expect(res.headers).not.toHaveProperty('content-type');
			expect(resData).toBeUndefined();
		});

		it('returns options', async () => {
			const [res] = await client({
				method: 'OPTIONS',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

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