yasumi/test/e2e/http/error-handling.test.ts

import {
	beforeAll,
	afterAll,
	afterEach,
	beforeEach,
	describe,
	expect,
	it, vi,
} from 'vitest';
import {request} from 'http';
import {constants} from 'http2';
import {Backend} from '../../../src/backend';
import {application, resource, validation as v, Resource, Application} from '../../../src/common';
import { autoIncrement } from '../../fixtures';
import {createTestClient, TestClient, DummyDataSource, DummyError} from '../../utils';
import {DataSource} from '../../../src/backend/data-source';

const PORT = 4001;
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('error handling', () => {
	let Piano: Resource;
	let app: Application;
	let dataSource: DataSource;
	let backend: Backend;
	let server: ReturnType<Backend['createHttpServer']>;
	let client: TestClient;

	beforeAll(() => {
		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(),
			});

		app = application({
			name: 'piano-service',
		})
			.resource(Piano);

		dataSource = new DummyDataSource();

		backend = app.createBackend({
			dataSource,
		});

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

		client = createTestClient({
			host: HOST,
			port: PORT,
		})
			.acceptMediaType(ACCEPT)
			.acceptLanguage(ACCEPT_LANGUAGE)
			.acceptCharset(ACCEPT_CHARSET)
			.contentType(CONTENT_TYPE)
			.contentCharset(CONTENT_TYPE_CHARSET);

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

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

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

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

			resolve();
		});
	}));

	describe('serving collections', () => {
		beforeEach(() => {
			Piano.canFetchCollection();
		});

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

		it('throws on query', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getMultiple')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'GET',
				path: `${BASE_PATH}/pianos`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano Collection');
		});

		it('throws on HEAD method', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getMultiple')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'HEAD',
				path: `${BASE_PATH}/pianos`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano Collection');
		});
	});

	describe('serving items', () => {
		beforeEach(() => {
			Piano.canFetchItem();
		});

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

		it('throws on query', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'GET',
				path: `${BASE_PATH}/pianos/2`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano');
		});

		it('throws on HEAD method', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'HEAD',
				path: `${BASE_PATH}/pianos/2`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano');
		});

		it('throws on item not found', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockResolvedValueOnce(null as never);

			const [res] = await client({
				method: 'GET',
				path: `${BASE_PATH}/pianos/2`,
			});

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

		it('throws on item not found on HEAD method', async () => {
			const getById = vi.spyOn(DummyDataSource.prototype, 'getById');
			getById.mockResolvedValueOnce(null as never);

			const [res] = await client({
				method: 'HEAD',
				path: `${BASE_PATH}/pianos/2`,
			});

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

	describe('creating items', () => {
		const newData = {
			brand: 'K. Kawai'
		};

		const existingResource = {
			...newData,
			id: 1,
		};

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

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

		it('throws on error assigning ID', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'newId')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'POST',
				path: `${BASE_PATH}/pianos`,
				body: newData,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Assign ID From Piano Data Source');
		});

		it('throws on error creating resource', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'newId')
				.mockResolvedValueOnce(existingResource.id as never);

			vi
				.spyOn(DummyDataSource.prototype, 'create')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'POST',
				path: `${BASE_PATH}/pianos`,
				body: newData,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Create Piano');
		});
	});

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

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

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

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

		// TODO add more tests

		it('throws on unable to fetch existing item', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'PATCH',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
				body: newData,
				headers: {
					'content-type': 'application/merge-patch+json',
				},
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano');
		});

		it('throws on item to patch not found', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockResolvedValueOnce(null as never);

			const [res] = await client({
				method: 'PATCH',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
				body: newData,
				headers: {
					'content-type': 'application/merge-patch+json',
				},
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
			expect(res).toHaveProperty('statusMessage', 'Patch Non-Existing Piano');
		});
	});

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

		beforeEach(() => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockResolvedValueOnce(existingResource as never);
		});

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

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

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

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

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

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

		it('throws on unable to check if item exists', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'DELETE',
				path: `${BASE_PATH}/pianos/2`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Fetch Piano');
		});

		it('throws on item not found', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockResolvedValueOnce(null as never);

			const [res] = await client({
				method: 'DELETE',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_NOT_FOUND);
			expect(res).toHaveProperty('statusMessage', 'Delete Non-Existing Piano');
		});

		it('throws on unable to delete item', async () => {
			vi
				.spyOn(DummyDataSource.prototype, 'getById')
				.mockResolvedValueOnce(existingResource as never);

			vi
				.spyOn(DummyDataSource.prototype, 'delete')
				.mockImplementationOnce(() => { throw new DummyError() });

			const [res] = await client({
				method: 'DELETE',
				path: `${BASE_PATH}/pianos/${existingResource.id}`,
			});

			expect(res).toHaveProperty('statusCode', constants.HTTP_STATUS_INTERNAL_SERVER_ERROR);
			expect(res).toHaveProperty('statusMessage', 'Unable To Delete Piano');
		});
	});
});