itrm-tools 1.3.5-beta.1 → 1.3.5-beta.2

package/test/api/request/PostRequest.test.ts

@@ -1,237 +0,0 @@
-import { Request, Response } from "express";
-import { RequestContext, PostRequest, APIService, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { config } from "../APITestDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-class TestRequest extends PostRequest {
-    constructor() {
-        super({
-            path: '/test/:method/type',
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "value", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.QUERY,
-                properties: [{ name: "option", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.QUERY,
-                properties: [
-                    { name: "x", type: RequestParameterType.STRING },
-                    { name: "y", type: RequestParameterType.STRING }
-                ]
-            }, {
-                context: RequestContext.PARAMS,
-                properties: [{ name: "method", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.BODY,
-                properties: [{ name: "date", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.BODY,
-                properties: [
-                    { name: "time", type: RequestParameterType.STRING },
-                    { name: "timestamp", type: RequestParameterType.NUMBER }
-                ]
-            }]
-        });
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        const { method } = req.params;
-        const { value, option, x, y } = req.query;
-        const { date, time, timestamp, values } = req.body;
-        return res.status(200).json({ message: "Success", method: method, type: value, option: option, date: date, time: time, x: x, y: y, timestamp: timestamp, values: values });
-    }
-}
-
-class UnexpectedErrorTestRequest extends PostRequest {
-    constructor() {
-        super({
-            path: '/test/error',
-            params: []
-        });
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        throw 'Unexpected error';
-    }
-}
-
-const testUrl = `http://localhost:${config.port}/test/testing/type?value=get`;
-const testUrl2 = `http://localhost:${config.port}/test/testing/type?option=1`;
-const testUrl3 = `http://localhost:${config.port}/test/testing/type?x=10&y=20`;
-const testUrlMissingQuery = `http://localhost:${config.port}/test/testing/type`;
-const testUrlUnexpectedError = `http://localhost:${config.port}/test/error`;
-
-describe('testing POST Request', () => {
-    beforeAll(async () => {
-        await service.run(() => { });
-    });
-    afterAll(async () => {
-        await service.close(() => { })
-    });
-    test('Refuse request when API Request does not exist', async () => {
-        try {
-            await RequestAxiosCall.post(testUrl, { date: 'date' }, {
-                headers: { 'Content-Type': 'application/json', 'Origin': 'https://valid.com' }
-            });
-        } catch (err: any) {
-            //console.log("> Refuse request when API Request does not exist, error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(404);
-            expect(err.response.statusText).toMatch("Not Found");
-        }
-    });
-    test('Request Query Ok parameter group 1', async () => {
-        try {
-            await service.addRequest(new TestRequest());
-            let response: any = await RequestAxiosCall.post(testUrl, { date: 'date' }, {
-                headers: { 'Content-Type': 'application/json', 'Origin': 'https://valid.com' }
-            });
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toMatch("get");
-            expect(response.option).toBeUndefined();
-            expect(response.x).toBeUndefined();
-            expect(response.y).toBeUndefined();
-        } catch (err: any) {
-            console.log("> Request Query Ok parameter group 1, error:", err);
-        }
-    });
-    test('Request Query Ok parameter group 2', async () => {
-        try {
-            let response: any = await RequestAxiosCall.post(testUrl2, { date: 'date' });
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toBeUndefined();
-            expect(response.option).toMatch("1");
-            expect(response.x).toBeUndefined();
-            expect(response.y).toBeUndefined();
-        } catch (err: any) {
-            console.log("> Request Query Ok parameter group 2, error:", err);
-        }
-    });
-    test('Request Query Ok parameter group 3', async () => {
-        try {
-            let response: any = await RequestAxiosCall.post(testUrl3, { date: 'date' });
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toBeUndefined();
-            expect(response.option).toBeUndefined();
-            expect(response.x).toMatch("10");
-            expect(response.y).toMatch("20");
-        } catch (err: any) {
-            console.log("> Request Query Ok parameter group 3, error:", err);
-        }
-    });
-    test('Request Query Ok parameter group 4', async () => {
-        try {
-            let response: any = await RequestAxiosCall.post(testUrl3, { date: 'date' })
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toBeUndefined();
-            expect(response.option).toBeUndefined();
-            expect(response.x).toMatch("10");
-            expect(response.y).toMatch("20");
-            expect(response.date).toMatch("date");
-            expect(response.time).toBeUndefined();
-            expect(response.timestamp).toBeUndefined();
-        } catch (err: any) {
-            console.log("> Request Query Ok parameter group 4, error:", err);
-        }
-    });
-    test('Request Query Ok parameter group 5', async () => {
-        try {
-            let response: any = await RequestAxiosCall.post(testUrl3, { time: 'time', timestamp: 10000000 });
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toBeUndefined();
-            expect(response.option).toBeUndefined();
-            expect(response.x).toMatch("10");
-            expect(response.y).toMatch("20");
-            expect(response.date).toBeUndefined();
-            expect(response.time).toMatch("time");
-            expect(response.timestamp).toBe(10000000);
-        } catch (err: any) {
-            console.log("> Request Query Ok parameter group 5, error:", err);
-        }
-    });
-    test('Request Error: missing parameter in query', async () => {
-        try {
-            await RequestAxiosCall.post(testUrlMissingQuery, { date: 'date' });
-        } catch (err: any) {
-            //console.log("> Request Error: missing parameter in query, error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(400);
-            expect(err.response.statusText).toMatch("Bad Request");
-            expect(err.response.data.status).toMatch("Error");
-            expect(err.response.data.message).toMatch("Parameters 'x', 'y' were not found in query");
-        }
-    });
-    test('Check values property', async () => {
-        try {
-            let response: any = await RequestAxiosCall.post(testUrl3, {
-                values: [{ date: 'date' }, { time: 'time', timestamp: 10000000 }]
-            });
-            expect(response.message).toMatch("Success");
-            expect(response.method).toMatch("testing");
-            expect(response.type).toBeUndefined();
-            expect(response.option).toBeUndefined();
-            expect(response.x).toMatch("10");
-            expect(response.y).toMatch("20");
-            expect(response.date).toBeUndefined();
-            expect(response.time).toBeUndefined();
-            expect(response.timestamp).toBeUndefined();
-            expect(response.values).toBeDefined();
-            expect(response.values.length).toBe(2);
-            expect(response.values[0].date).toMatch("date");
-            expect(response.values[1].time).toMatch("time");
-            expect(response.values[1].timestamp).toBe(10000000);
-        } catch (err: any) {
-            console.log("> Check values property, error:", err);
-        }
-    });
-    test('Check missing property in values', async () => {
-        try {
-            await RequestAxiosCall.post(testUrl3, {
-                values: [{ date: 'date' }, { time: 'time' }]
-            });
-        } catch (err: any) {
-            //console.log("> Check missing property in values, error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(400);
-            expect(err.response.statusText).toMatch("Bad Request");
-            expect(err.response.data.status).toMatch("Error");
-            expect(err.response.data.message).toMatch("Parameters 'timestamp' were not found in body, item 2");
-        }
-    });
-    test('Check missing parameter and wrong type in values', async () => {
-        try {
-            await RequestAxiosCall.post(testUrl3, {
-                values: [{ date: 'date' }, { timestamp: 'time' }]
-            });
-        } catch (err: any) {
-            //console.log("> Check missing parameter and wrong type in values, error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(400);
-            expect(err.response.statusText).toMatch("Bad Request");
-            expect(err.response.data.status).toMatch("Error");
-            expect(err.response.data.message).toMatch("Parameters 'time' were not found in body and 'timestamp' have invalid type , item 2");
-        }
-    });
-    test('Check wrong type in values', async () => {
-        try {
-            await RequestAxiosCall.post(testUrl3, {
-                values: [{ date: 'date' }, { time: 'time', timestamp: 'time' }]
-            });
-        } catch (err: any) {
-            //console.log("> Check wrong type in values, error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(400);
-            expect(err.response.statusText).toMatch("Bad Request");
-            expect(err.response.data.status).toMatch("Error");
-            expect(err.response.data.message).toMatch("Parameters 'timestamp' have invalid type , item 2");
-        }
-    });
-});

package/test/api/request/PutRequest.test.ts

@@ -1,166 +0,0 @@
-import { Request, Response } from "express";
-import { RequestContext, PutRequest, APIService, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { config } from "../APITestDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-class TestRequest extends PutRequest {
-    constructor() {
-        super({
-            path: '/test/:method/type',
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "value", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.QUERY,
-                properties: [{ name: "option", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.QUERY,
-                properties: [
-                    { name: "x", type: RequestParameterType.STRING },
-                    { name: "y", type: RequestParameterType.STRING }
-                ]
-            }, {
-                context: RequestContext.PARAMS,
-                properties: [{ name: "method", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.BODY,
-                properties: [{ name: "date", type: RequestParameterType.STRING }]
-            }, {
-                context: RequestContext.BODY,
-                properties: [
-                    { name: "time", type: RequestParameterType.STRING },
-                    { name: "timestamp", type: RequestParameterType.STRING }
-                ]
-            }]
-        });
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        const { method } = req.params;
-        const { value, option, x, y } = req.query;
-        const { date, time, timestamp } = req.body;
-        return res.status(200).json({ message: "Success", method: method, type: value, option: option, date: date, time: time, x: x, y: y, timestamp: timestamp });
-    }
-}
-
-class UnexpectedErrorTestRequest extends PutRequest {
-    constructor() {
-        super({
-            path: '/test/error',
-            params: []
-        });
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        throw 'Unexpected error';
-    }
-}
-
-const testUrl = `http://localhost:${config.port}/test/testing/type?value=get`;
-const testUrl2 = `http://localhost:${config.port}/test/testing/type?option=1`;
-const testUrl3 = `http://localhost:${config.port}/test/testing/type?x=10&y=20`;
-const testUrlMissingQuery = `http://localhost:${config.port}/test/testing/type`;
-const testUrlUnexpectedError = `http://localhost:${config.port}/test/error`;
-
-describe('testing PUT Request', () => {
-    beforeAll(async () => {
-        await service.run(() => { });
-    });
-    afterAll(async () => {
-        await service.close(() => { })
-    });
-    test('Refuse request when API Request does not exist', async () => {
-        expect.assertions(3);
-        return RequestAxiosCall.put(testUrl, { date: 'date' })
-            .catch(err => {
-                expect(err.code).toMatch("ERR_BAD_REQUEST");
-                expect(err.response.status).toBe(404);
-                expect(err.response.statusText).toMatch("Not Found");
-            });
-    });
-    test('Request Query Ok parameter group 1', async () => {
-        expect.assertions(6);
-        await service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrl, { date: 'date' })
-            .then(async (response: any) => {
-                expect(response.message).toMatch("Success");
-                expect(response.method).toMatch("testing");
-                expect(response.type).toMatch("get");
-                expect(response.option).toBeUndefined();
-                expect(response.x).toBeUndefined();
-                expect(response.y).toBeUndefined();
-            });
-    });
-    test('Request Query Ok parameter group 2', async () => {
-        expect.assertions(6);
-        await service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrl2, { date: 'date' })
-            .then(async (response: any) => {
-                expect(response.message).toMatch("Success");
-                expect(response.method).toMatch("testing");
-                expect(response.type).toBeUndefined();
-                expect(response.option).toMatch("1");
-                expect(response.x).toBeUndefined();
-                expect(response.y).toBeUndefined();
-            });
-    });
-    test('Request Query Ok parameter group 3', async () => {
-        expect.assertions(6);
-        await service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrl3, { date: 'date' })
-            .then(async (response: any) => {
-                expect(response.message).toMatch("Success");
-                expect(response.method).toMatch("testing");
-                expect(response.type).toBeUndefined();
-                expect(response.option).toBeUndefined();
-                expect(response.x).toMatch("10");
-                expect(response.y).toMatch("20");
-            });
-    });
-    test('Request Query Ok parameter group 4', async () => {
-        expect.assertions(9);
-        await service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrl3, { date: 'date' })
-            .then(async (response: any) => {
-                expect(response.message).toMatch("Success");
-                expect(response.method).toMatch("testing");
-                expect(response.type).toBeUndefined();
-                expect(response.option).toBeUndefined();
-                expect(response.x).toMatch("10");
-                expect(response.y).toMatch("20");
-                expect(response.date).toMatch("date");
-                expect(response.time).toBeUndefined();
-                expect(response.timestamp).toBeUndefined();
-            });
-    });
-    test('Request Query Ok parameter group 5', async () => {
-        expect.assertions(9);
-        await service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrl3, { time: 'time', timestamp: 'timestamp' })
-            .then(async (response: any) => {
-                expect(response.message).toMatch("Success");
-                expect(response.method).toMatch("testing");
-                expect(response.type).toBeUndefined();
-                expect(response.option).toBeUndefined();
-                expect(response.x).toMatch("10");
-                expect(response.y).toMatch("20");
-                expect(response.date).toBeUndefined();
-                expect(response.time).toMatch("time");
-                expect(response.timestamp).toMatch("timestamp");
-            });
-    });
-    test('Request Error: missing parameter in query', async () => {
-        expect.assertions(5);
-        service.addRequest(new TestRequest());
-        return RequestAxiosCall.put(testUrlMissingQuery, { property: 'body' })
-            .catch(async err => {
-                expect(err.code).toMatch("ERR_BAD_REQUEST");
-                expect(err.response.status).toBe(400);
-                expect(err.response.statusText).toMatch("Bad Request");
-                expect(err.response.data.status).toMatch("Error");
-                expect(err.response.data.message).toMatch("Parameters 'x', 'y' were not found in query");
-            });
-    });
-});

package/test/database/mongoose/MongooseModelManager.test.ts

@@ -1,139 +0,0 @@
-import { MongooseModelManager } from "../../../dist";
-import { MongoMemoryServer } from 'mongodb-memory-server';
-import mongoose, { connect, disconnect } from "mongoose";
-
-mongoose.set('strictQuery', false);
-
-interface TestValue {
-    value: string
-}
-
-interface Test {
-    testId: number,
-    name: string,
-    values: TestValue[]
-}
-
-class TestManager extends MongooseModelManager<Test> {
-    constructor() {
-        super("test", {
-            testId: { type: Number, required: true },
-            name: { type: String, required: true },
-            values: {
-                type: [{
-                    value: { type: String, required: true }
-                }],
-                required: true
-            }
-        });
-    }
-}
-
-const manager = new TestManager();
-let mongodb: MongoMemoryServer | undefined = undefined;
-
-describe("> Testing Mongoose Model Manager", () => {
-    beforeAll(async() => {
-        mongodb  = await MongoMemoryServer.create();
-        let url = await mongodb?.getUri() || "NONE";
-        await connect(url);
-    });
-    afterAll(async() => {
-        await disconnect();
-        await mongodb?.stop();
-    });
-    test("> Create", async() => {
-        let token: any = await manager.create({
-            name: 'test1',
-            testId: 1,
-            values: [{ value: 'value1' }]
-        });
-        expect(token.name).toMatch('test1');
-        expect(token.testId).toBe(1);
-    });
-    test("> Create Many", async() => {
-        let result = await manager.createMany([{
-            name: 'test2',
-            testId: 2,
-            values: [{ value: 'value2' }]
-        }, {
-            name: 'test3',
-            testId: 3,
-            values: [{ value: 'value3' }]
-        }]);
-        expect(result.insertedCount).toBe(2);
-    });
-    test("> Exists", async() => {
-        let result = await manager.exists({ testId: 2 });
-        expect(result).toBeDefined();
-        result = await manager.exists({ testId: 4 });
-        expect(result).toBeNull();
-    });
-    test("> Find", async() => {
-        let token: any = await manager.find({ testId: 1 });
-        expect(token.name).toMatch('test1');
-        expect(token.testId).toBe(1);
-    });
-    test("> Find Many", async() => {
-        let tokens: any[] = await manager.findMany({
-            testId: { $gt: 1 }
-        });
-        expect(tokens.length).toBe(2);
-        expect(tokens[0].name).toMatch('test2');
-        expect(tokens[0].testId).toBe(2);
-        expect(tokens[1].name).toMatch('test3');
-        expect(tokens[1].testId).toBe(3);
-    });
-    test("> Batch", async() => {
-        let tokens: any[] = await manager.batch({}, 1, 2);
-        expect(tokens.length).toBe(2);
-        expect(tokens[0].name).toMatch('test2');
-        expect(tokens[0].testId).toBe(2);
-        expect(tokens[1].name).toMatch('test3');
-        expect(tokens[1].testId).toBe(3);
-    });
-    test("Bulk Write", async() => {
-        await manager.bulkWrite([{
-            updateOne: {
-                filter: { testId: 1 },
-                update: { name: 'test_1' },
-            }
-        }, {
-            insertOne: {
-                document: {
-                    name: 'test4',
-                    testId: 4,
-                    values: [{ value: 'value4' }]
-                }
-            }
-        }, {
-            deleteOne: {
-                filter: { testId: 2 }
-            }
-        }]);
-        let update = await manager.find({ testId: 1 });
-        expect(update?.name).toMatch('test_1');
-        let insertion = await manager.find({ testId: 4 });
-        expect(insertion?.name).toMatch('test4');
-        let deletion = await manager.find({ testId: 2 });
-        expect(deletion).toBeNull();
-    });
-    test("> Count Documents", async() => {
-        expect(await manager.countDocuments({
-            testId: { $gt: 1 }
-        })).toBe(2);
-    });
-    test("> Delete", async() => {
-        let deletion = await manager.delete({ testId: 1 });
-        expect(deletion.deletedCount).toBe(1);
-        expect(await manager.countDocuments({})).toBe(2);
-        expect(await manager.find({ testId: 1 })).toBeNull();
-    });
-    test("> Delete Many", async() => {
-        let deletion = await manager.deleteMany({ testId: { $gt: 1 } });
-        expect(deletion.deletedCount).toBe(2);
-        expect(await manager.countDocuments({})).toBe(0);
-        expect(await manager.find({ testId: 3 })).toBeNull();
-        expect(await manager.find({ testId: 4 })).toBeNull();
-    });
-});

package/test/database/redis/RedisConnection.test.ts

@@ -1,7 +0,0 @@
-import { createClient } from "redis";
-
-let client = createClient();
-
-describe('Testing Redis', () => {
-    test('test', () => {});
-});

package/test/database/sequelize/SequealizeDefinitions.ts

@@ -1,6 +0,0 @@
-import { Options } from '@sequelize/core';
-
-export const config: Options<any> = {
-    dialect: "sqlite3",
-    logging: false
-};

package/test/database/sequelize/SequelizeConnection.test.ts

@@ -1,30 +0,0 @@
-import { SequelizeConnection } from '../../../dist';
-import { config } from './SequealizeDefinitions';
-import { DataTypes } from '@sequelize/core';
-
-const validConnection = new SequelizeConnection(config);
-
-describe("Testing Sequalize Connection", () => {
-    test("Connect OK", async () => {
-        expect(await validConnection.connect()).toBeUndefined();
-    });
-    test("Define Model", async () => {
-        let model = await validConnection.define('Test', {
-            testId: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            name: {
-                type: DataTypes.STRING,
-                allowNull: false
-            }
-        }, {
-            tableName: 'Tests'
-        });
-        expect(model.name).toMatch('Test');
-        expect(model.tableName).toMatch('Tests');
-    });
-    test("Disconnect OK", async () => {
-        expect(await validConnection.disconnect()).toBeUndefined();
-    });
-});