web_plsql 0.3.2 → 0.5.0

package/test/{config.ts → __tests__/config.ts}

@@ -1,41 +1,41 @@
-import {assert} from 'chai';
-import {validate} from '../src/config';
-
-describe('configuration options', () => {
-	it('should allow the following options', () => {
-		[
-			undefined, // eslint-disable-line no-undefined
-			{},
-			{cgi: {fast: 'on'}},
-			{pathAlias: {alias: 'r', procedure: 'p'}},
-			{errorStyle: 'debug'}
-		].forEach(options => {
-			assert.strictEqual(typeof validate(options), 'object', JSON.stringify(options));
-		});
-	});
-});
-
-describe('configuration errors', () => {
-	[
-		{config: null, error: 'Invalid configuration object was given'},
-		{config: {invalid: ''}, error: 'Invalid configuration options "invalid"'},
-		{config: {defaultPage: 1}, error: 'The option "defaultPage" must be of type string and cannot be empty'},
-		{config: {defaultPage: ''}, error: 'The option "defaultPage" must be of type string and cannot be empty'},
-		{config: {doctable: 1}, error: 'The option "doctable" must be of type string and cannot be empty'},
-		{config: {doctable: ''}, error: 'The option "doctable" must be of type string and cannot be empty'},
-		{config: {cgi: ''}, error: 'The option "cgi" must be an object where all keys and values are of type string'},
-		{config: {cgi: {a: 1}}, error: 'The option "cgi" must be an object where all keys and values are of type string'},
-		{config: {pathAlias: {alias: 'r', procedure: ''}}, error: 'The option "pathAlias" must be an object with the non-empty string properties "alias" and "procedure"'},
-		{config: {errorStyle: ''}, error: 'The optional option "errorStyle" must be "basic" or "debug"'},
-		{config: {errorStyle: 'on'}, error: 'The optional option "errorStyle" must be "basic" or "debug"'},
-		{config: {trace: true}, error: 'The optional option "trace" must be "on" or "off"'},
-		{config: {trace: ''}, error: 'The optional option "trace" must be "on" or "off"'},
-		{config: {trace: 'enabled'}, error: 'The optional option "trace" must be "on" or "off"'},
-	].forEach(test => {
-		it(`should throw the exception "${test.error}"`, () => {
-			assert.throws(() => {
-				validate(test.config);
-			}, test.error);
-		});
-	});
-});
+import {describe, it, expect} from '@jest/globals';
+import {validate} from '../../src/config';
+
+describe('configuration options', () => {
+	it('should allow the following options', () => {
+		[
+			undefined, // eslint-disable-line no-undefined
+			{},
+			{cgi: {fast: 'on'}},
+			{pathAlias: {alias: 'r', procedure: 'p'}},
+			{errorStyle: 'debug'}
+		].forEach(options => {
+			expect(typeof validate(options as unknown as Record<string, unknown>)).toBe('object');
+		});
+	});
+});
+
+describe('configuration errors', () => {
+	[
+		{config: null, error: 'Invalid configuration object was given'},
+		{config: {invalid: ''}, error: 'Invalid configuration options "invalid"'},
+		{config: {defaultPage: 1}, error: 'The option "defaultPage" must be of type string and cannot be empty'},
+		{config: {defaultPage: ''}, error: 'The option "defaultPage" must be of type string and cannot be empty'},
+		{config: {doctable: 1}, error: 'The option "doctable" must be of type string and cannot be empty'},
+		{config: {doctable: ''}, error: 'The option "doctable" must be of type string and cannot be empty'},
+		{config: {cgi: ''}, error: 'The option "cgi" must be an object where all keys and values are of type string'},
+		{config: {cgi: {a: 1}}, error: 'The option "cgi" must be an object where all keys and values are of type string'},
+		{config: {pathAlias: {alias: 'r', procedure: ''}}, error: 'The option "pathAlias" must be an object with the non-empty string properties "alias" and "procedure"'},
+		{config: {errorStyle: ''}, error: 'The optional option "errorStyle" must be "basic" or "debug"'},
+		{config: {errorStyle: 'on'}, error: 'The optional option "errorStyle" must be "basic" or "debug"'},
+		{config: {trace: true}, error: 'The optional option "trace" must be "on" or "off"'},
+		{config: {trace: ''}, error: 'The optional option "trace" must be "on" or "off"'},
+		{config: {trace: 'enabled'}, error: 'The optional option "trace" must be "on" or "off"'},
+	].forEach(test => {
+		it(`should throw the exception "${test.error}"`, () => {
+			expect(() => {
+				validate(test.config as unknown as Record<string, unknown>);
+			}).toThrow(test.error);
+		});
+	});
+});

package/test/__tests__/errorPage.ts

@@ -0,0 +1,101 @@
+import {describe, beforeAll, afterAll, it, expect} from '@jest/globals';
+import {errorPage} from '../../src/errorPage';
+import {RequestError} from '../../src/requestError';
+import {ProcedureError} from '../../src/procedureError';
+import {oracleExpressMiddleware$options} from '../../src/config';
+
+describe('errorPage', () => {
+	let errorSave: any;
+
+	beforeAll(() => {
+		errorSave = console.error;
+		console.error = () => {}; // eslint-disable-line @typescript-eslint/no-empty-function
+	});
+
+	afterAll(() => {
+		console.error = errorSave;
+	});
+
+	let errorText = '';
+	let errorHtml = '';
+
+	const options: oracleExpressMiddleware$options = {
+		errorStyle: 'debug',
+		trace: 'off'
+	};
+
+	const req: any = {};
+	const res: any = {
+		status() {
+			return this;
+		},
+		send(error: string) {
+			errorHtml = error;
+			return this;
+		}
+	};
+	const trace: any = {
+		write(error: string) {
+			errorText = error;
+		}
+	};
+
+	it('should report a "error message" in text and html format', () => {
+		errorPage(req, res, options, trace, new Error('error message'));
+
+		expect(/error message/.test(errorText)).toBeTruthy();
+		expect(/ERROR/.test(errorText)).toBeTruthy();
+		expect(/REQUEST/.test(errorText)).toBeTruthy();
+		expect(/error message/.test(errorHtml)).toBeTruthy();
+		expect(/TIMESTAMP/.test(errorHtml)).toBeTruthy();
+		expect(/ERROR/.test(errorHtml)).toBeTruthy();
+	});
+
+	it('should report a "Error" in text and html format', () => {
+		errorPage(req, res, options, trace, new Error('throw Error'));
+
+		expect(/throw Error/.test(errorText)).toBeTruthy();
+		expect(/ERROR/.test(errorText)).toBeTruthy();
+		expect(/REQUEST/.test(errorText)).toBeTruthy();
+		expect(/throw Error/.test(errorHtml)).toBeTruthy();
+		expect(/TIMESTAMP/.test(errorHtml)).toBeTruthy();
+		expect(/ERROR/.test(errorHtml)).toBeTruthy();
+	});
+
+	it('should report a "RequestError" in text and html format', () => {
+		errorPage(req, res, options, trace, new RequestError('throw RequestError'));
+
+		expect(/throw RequestError/.test(errorText)).toBeTruthy();
+		expect(/ERROR/.test(errorText)).toBeTruthy();
+		expect(/REQUEST/.test(errorText)).toBeTruthy();
+		expect(/throw RequestError/.test(errorHtml)).toBeTruthy();
+		expect(/TIMESTAMP/.test(errorHtml)).toBeTruthy();
+		expect(/ERROR/.test(errorHtml)).toBeTruthy();
+	});
+
+	it('should report a "ProcedureError" in text and html format', () => {
+		const environment = {dad: 'dad'};
+		const sql = 'sql';
+		const bind = {p1: '1'};
+
+		errorPage(req, res, options, trace, new ProcedureError('throw ProcedureError', environment, sql, bind));
+
+		expect(/throw ProcedureError/.test(errorText)).toBeTruthy();
+		expect(/ERROR/.test(errorText)).toBeTruthy();
+		expect(/REQUEST/.test(errorText)).toBeTruthy();
+		expect(/PROCEDURE/.test(errorText)).toBeTruthy();
+		expect(/ENVIRONMENT/.test(errorText)).toBeTruthy();
+		expect(/throw ProcedureError/.test(errorHtml)).toBeTruthy();
+		expect(/TIMESTAMP/.test(errorHtml)).toBeTruthy();
+		expect(/ERROR/.test(errorHtml)).toBeTruthy();
+		expect(/PROCEDURE/.test(errorHtml)).toBeTruthy();
+		expect(/ENVIRONMENT/.test(errorHtml)).toBeTruthy();
+	});
+
+	it('should only report a "404" error when in basic mode', () => {
+		options.errorStyle = 'basic';
+		errorPage(req, res, options, trace, new Error('error message'));
+
+		expect(/error message/.test(errorText)).toBeTruthy();
+	});
+});

package/test/{oracledb_mock.ts → __tests__/oracledb_mock.ts}

@@ -1,98 +1,98 @@
-import {assert} from 'chai';
-import {setExecuteCallback, createPool, Connection, getConnection, ConnectionPool, Lob, BLOB} from './mock/oracledb';
-
-describe('oracledb', () => {
-	it('createPool', async () => {
-		const connectionPool = await _createPool();
-		assert.isTrue(connectionPool instanceof ConnectionPool);
-		return connectionPool;
-	});
-
-	it('getConnection', async () => {
-		const connection = await _getConnection();
-		assert.isTrue(connection instanceof Connection);
-		return connection;
-	});
-});
-
-describe('ConnectionPool', () => {
-	it('getConnection', async () => {
-		const connectionPool = await _createPool();
-		const connection = await connectionPool.getConnection();
-
-		assert.isTrue(connection instanceof Connection);
-
-		return connection;
-	});
-
-	it('close', async () => {
-		const connectionPool = await _createPool();
-		await connectionPool.close();
-	});
-});
-
-describe('Connection', () => {
-	it('getConnection', async () => {
-		const connection = await _getConnection();
-		assert.isTrue(connection instanceof Connection);
-		return connection;
-	});
-
-	it('createLob', async () => {
-		const connection = await _getConnection();
-		const lob = await connection.createLob(BLOB);
-		assert.isTrue(lob instanceof Lob);
-		return lob;
-	});
-
-	it('release', async () => {
-		const connection = await _getConnection();
-		return connection.release();
-	});
-});
-
-describe('Connection.execute', () => {
-	beforeEach(() => {
-		setExecuteCallback();
-	});
-
-	it('execute', async () => {
-		const connection = await _getConnection();
-		assert.deepEqual(await connection.execute('select * from dual'), {});
-	});
-
-	it('execute with execution callback', async () => {
-		const connection = await _getConnection();
-		const SQL = 'select * from dual';
-
-		// register an execute callback
-		setExecuteCallback((sql: string) => {
-			assert.strictEqual(sql, SQL);
-			return {sql: SQL};
-		});
-
-		assert.deepEqual(await connection.execute(SQL), {sql: SQL});
-	});
-});
-
-/*
-*	get connection pool
-*/
-function _createPool() {
-	return createPool({
-		user: 'sample',
-		password: 'sample',
-		connectString: 'localhost:1521/TEST'
-	});
-}
-
-/*
-*	get connection
-*/
-function _getConnection() {
-	return getConnection({
-		user: 'sample',
-		password: 'sample',
-		connectString: 'localhost:1521/TEST'
-	});
-}
+import {describe, beforeEach, it, expect} from '@jest/globals';
+import {setExecuteCallback, createPool, Connection, getConnection, ConnectionPool, Lob, BLOB} from '../mock/oracledb';
+
+describe('oracledb', () => {
+	it('createPool', async () => {
+		const connectionPool = await _createPool();
+		expect(connectionPool).toBeInstanceOf(ConnectionPool);
+		return connectionPool;
+	});
+
+	it('getConnection', async () => {
+		const connection = await _getConnection();
+		expect(connection).toBeInstanceOf(Connection);
+		return connection;
+	});
+});
+
+describe('ConnectionPool', () => {
+	it('getConnection', async () => {
+		const connectionPool = await _createPool();
+		const connection = await connectionPool.getConnection();
+
+		expect(connection).toBeInstanceOf(Connection);
+
+		return connection;
+	});
+
+	it('close', async () => {
+		const connectionPool = await _createPool();
+		await connectionPool.close();
+	});
+});
+
+describe('Connection', () => {
+	it('getConnection', async () => {
+		const connection = await _getConnection();
+		expect(connection).toBeInstanceOf(Connection);
+		return connection;
+	});
+
+	it('createLob', async () => {
+		const connection = await _getConnection();
+		const lob = await connection.createLob(BLOB);
+		expect(lob).toBeInstanceOf(Lob);
+		return lob;
+	});
+
+	it('release', async () => {
+		const connection = await _getConnection();
+		return connection.release();
+	});
+});
+
+describe('Connection.execute', () => {
+	beforeEach(() => {
+		setExecuteCallback();
+	});
+
+	it('execute', async () => {
+		const connection = await _getConnection();
+		expect(await connection.execute('select * from dual')).toStrictEqual({});
+	});
+
+	it('execute with execution callback', async () => {
+		const connection = await _getConnection();
+		const SQL = 'select * from dual';
+
+		// register an execute callback
+		setExecuteCallback((sql: string) => {
+			expect(sql).toBe(SQL);
+			return {sql: SQL};
+		});
+
+		expect(await connection.execute(SQL)).toStrictEqual({sql: SQL});
+	});
+});
+
+/*
+*	get connection pool
+*/
+function _createPool() {
+	return createPool({
+		user: 'sample',
+		password: 'sample',
+		connectString: 'localhost:1521/TEST'
+	});
+}
+
+/*
+*	get connection
+*/
+function _getConnection() {
+	return getConnection({
+		user: 'sample',
+		password: 'sample',
+		connectString: 'localhost:1521/TEST'
+	});
+}