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

package/test/api/check/CheckablePostRequest.test.ts

@@ -1,108 +0,0 @@
-import { Request, Response } from "express";
-import { APIService, CheckablePostRequest, RequestContext, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { config } from "../APITestDefinitions";
-import { check, unexpectedErrorCheck } from "./CheckDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-export class TestRequest extends CheckablePostRequest {
-    constructor() {
-        super({
-            path: "/check",
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "key", type: RequestParameterType.STRING }]
-            }]
-        });
-    }
-
-    public getCheckConfiguration() {
-        return {
-            key: 'valid'
-        };
-    }
-
-    public async apply(req: Request, res: Response): Promise<any> {
-        return res.status(200).json({ message: 'Success' });
-    }
-}
-
-export class InvalidCheckConfigurationTestRequest extends CheckablePostRequest {
-    constructor() {
-        super({
-            path: "/invalid-check",
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "key", type: RequestParameterType.STRING }]
-            }]
-        });
-    }
-
-    public getCheckConfiguration() { // invalid configuration
-        return {
-            password: 'valid'
-        };
-    }
-
-    public async apply(req: Request, res: Response): Promise<any> {
-        return res.status(200).json({ message: 'Success' });
-    }
-}
-
-const validKeyUrl = `http://localhost:${config.port}/check?key=valid`;
-const invalidKeyUrl = `http://localhost:${config.port}/check?key=invalid`;
-const invalidUnknownKeyUrl = `http://localhost:${config.port}/check?key=unknown`;
-
-describe('testing Checkable POST Request', () => {
-    let request = new TestRequest();
-    beforeAll(async () => {
-        await service.run(() => { });
-    });
-    afterAll(async () => {
-        await service.close(() => { })
-    });
-    test('Refuse request when API Request does not exist', async () => {
-        try {
-            await RequestAxiosCall.post(validKeyUrl, {});
-        } catch (err: any) {
-            //console.log("> Refuse request when API Request does not exist:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(404);
-            expect(err.response.statusText).toMatch("Not Found");
-        }
-    });
-    test('Checking valid', async () => {
-        try {
-            request.addCheck(check);
-            service.addRequest(request);
-            let response: any = await RequestAxiosCall.post(validKeyUrl, {});
-            console.log("> Checking valid, response:", response);
-            expect(response.message).toMatch("Success");
-        } catch(err: any) {
-            console.log("> Checking valid, test error:", err);
-        }
-    });
-    test('Checking invalid', async () => {
-        try {
-            await RequestAxiosCall.post(invalidKeyUrl, {});
-        } catch(err: any) {
-            //console.log("> Checking invalid, test error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(401);
-            expect(err.response.statusText).toMatch("Unauthorized");
-            expect(err.response.data.message).toMatch("key does not match");
-        }
-    });
-    test('Checking invalid with no unauthorization reason', async () => {
-        try {
-            await RequestAxiosCall.post(invalidUnknownKeyUrl, {})
-        } catch(err: any) {
-            //console.log("> Checking invalid with no unauthorization reason, test error:", err);
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(401);
-            expect(err.response.statusText).toMatch("Unauthorized");
-            expect(err.response.data.message).toMatch("Unknown reason");
-        }
-    });
-});

package/test/api/check/CheckablePutRequest.test.ts

@@ -1,99 +0,0 @@
-import { Request, Response } from "express";
-import { APIService, CheckablePutRequest, RequestContext, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { config } from "../APITestDefinitions";
-import { check, unexpectedErrorCheck } from "./CheckDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-export class TestRequest extends CheckablePutRequest {
-    constructor() {
-        super({
-            path: "/check",
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "key", type: RequestParameterType.STRING }]
-            }]
-        });
-    }
-
-    public getCheckConfiguration() {
-        return {
-            key: 'valid'
-        };
-    }
-
-    public async apply(req: Request, res: Response): Promise<any> {
-        return res.status(200).json({ message: 'Success' });
-    }
-}
-
-export class InvalidCheckConfigurationTestRequest extends CheckablePutRequest {
-    constructor() {
-        super({
-            path: "/invalid-check",
-            params: [{
-                context: RequestContext.QUERY,
-                properties: [{ name: "key", type: RequestParameterType.STRING }]
-            }]
-        });
-    }
-
-    public getCheckConfiguration() { // invalid configuration
-        return {
-            password: 'valid'
-        };
-    }
-
-    public async apply(req: Request, res: Response): Promise<any> {
-        return res.status(200).json({ message: 'Success' });
-    }
-}
-
-const validKeyUrl = `http://localhost:${config.port}/check?key=valid`;
-const invalidKeyUrl = `http://localhost:${config.port}/check?key=invalid`;
-const invalidUnknownKeyUrl = `http://localhost:${config.port}/check?key=unknown`;
-
-describe('testing Checkable PUT Request', () => {
-    let request = new TestRequest();
-    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(validKeyUrl, {}).catch(err => {
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(404);
-            expect(err.response.statusText).toMatch("Not Found");
-        });
-    });
-    test('Checking valid', async () => {
-        expect.assertions(1);
-        request.addCheck(check);
-        await service.addRequest(request);
-        return RequestAxiosCall.put(validKeyUrl, {}).then(async (response: any) => {
-            expect(response.message).toMatch("Success");
-        });
-    });
-    test('Checking invalid', async () => {
-        expect.assertions(4);
-        return RequestAxiosCall.put(invalidKeyUrl, {}).catch(err => {
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(401);
-            expect(err.response.statusText).toMatch("Unauthorized");
-            expect(err.response.data.message).toMatch("key does not match");
-        });
-    });
-    test('Checking invalid with no unauthorization reason', async () => {
-        expect.assertions(4);
-        return RequestAxiosCall.put(invalidUnknownKeyUrl, {}).catch(err => {
-            expect(err.code).toMatch("ERR_BAD_REQUEST");
-            expect(err.response.status).toBe(401);
-            expect(err.response.statusText).toMatch("Unauthorized");
-            expect(err.response.data.message).toMatch("Unknown reason");
-        });
-    });
-});

package/test/api/docs/DocumentationRequest.test.ts

@@ -1,192 +0,0 @@
-import { APIRequestBuilder, APIService, GetRequest, PostRequest, PutRequest, RequestAxiosCall, RequestContext, RequestParameterType, SimpleCheckableAPIRouter } from "../../../dist";
-import { Request, Response } from "express";
-import { config } from "../APITestDefinitions";
-import puppeteer from 'puppeteer';
-
-jest.useFakeTimers();
-
-const service = new APIService(config);
-service.init();
-
-class TestRequest extends GetRequest {
-    constructor(builder: APIRequestBuilder) {
-        super(builder.buildApiRequestConfig("/test/:method/type"));
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        const { method } = req.params;
-        const { value, option, x, y } = req.query;
-        return res.status(200).json({ message: "Success", method: method, type: value, option: option, x: x, y: y });
-    }
-}
-
-export class TestRequestBuilder extends APIRequestBuilder {
-    constructor() {
-        super();
-    }
-
-    public buildParams() {
-        return [{
-            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.HEADERS,
-            properties: [{ name: "x-header", type: RequestParameterType.STRING }]
-        }
-    ];
-    }
-
-    public buildDocDetails() {
-        return {
-            description: "Get Request",
-            samples: [{
-                status: 200,
-                input: { x: 5, y: 2 },
-                output: {
-                    message: "hola cómo estás"
-                }
-            }, {
-                status: 400,
-                input: { x: 5 },
-                output: {
-                    message: "Falta la y",
-                    error: "Missing parameters",
-                }
-            }]
-        }
-    }
-
-    public buildApiRequestConfig(path: string) {
-        return {
-            path: path,
-            params: this.buildParams(),
-            details: this.buildDocDetails()
-        }
-    }
-}
-
-class TestPostRequest extends PostRequest {
-    constructor() {
-        super({
-            path: '/test/:method/type',
-            params: [{
-                context: RequestContext.BODY,
-                properties: [{ name: "value", type: RequestParameterType.OBJECT }]
-            }, {
-                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 TestPutRequest extends PutRequest {
-    constructor() {
-        super({
-            path: '/test/:method',
-            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 }]
-            }],
-        });
-    }
-
-    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 });
-    }
-}
-
-const router = new SimpleCheckableAPIRouter("/route");
-
-router.init();
-router.addRequest(new TestRequest(new TestRequestBuilder()));
-router.addRequest(new TestPostRequest());
-router.addRequest(new TestPutRequest());
-
-service.addRouter(router);
-
-service.enableDocumentation();
-
-const swaggerUrl = `http://localhost:${config.port}/api-docs`;
-
-describe('Testing Documentation', () => {
-    beforeAll(async () => {
-        await service.run(() => { });
-    });
-    afterAll(async () => {
-        await service.close(() => { })
-    });
-    test('Testing JSON', async () => {
-        // expect.assertions(1);
-        return RequestAxiosCall.get(swaggerUrl).then((response: any) => {
-            console.log("get");
-        });
-    });
-    // jest.setTimeout(300000);
-    // test('Testing Swagger UI', async () => {
-    //     const browser = await puppeteer.launch({ headless: false });
-    //     const page = await browser.newPage();
-    //     await page.goto(`http://localhost:${config.port}/api-docs`);
-    //     // await browser.close();
-    //     await new Promise(r => setTimeout(r, 300000));
-    //     return RequestAxiosCall.get(swaggerUrl).then((response: any) => {
-    //         console.log(response);
-    //     });
-    // });
-});
-

package/test/api/request/DeleteRequest.test.ts

@@ -1,117 +0,0 @@
-import { Request, Response } from "express";
-import { RequestContext, DeleteRequest, APIService, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { config } from "../APITestDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-class TestRequest extends DeleteRequest {
-    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 }]
-            }]
-        });
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        const { method } = req.params;
-        const { value, option, x, y } = req.query;
-        return res.status(200).json({ message: "Success", method: method, type: value, option: option, x: x, y: y });
-    }
-}
-
-class UnexpectedErrorTestRequest extends DeleteRequest {
-    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 GET 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.delete(testUrl).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 () => {
-        await service.addRequest(new TestRequest());
-        let response: any = await RequestAxiosCall.delete(testUrl);
-        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.delete(testUrl2).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.delete(testUrl3).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 Error: missing parameter in query', async () => {
-        expect.assertions(5);
-        service.addRequest(new TestRequest());
-        return RequestAxiosCall.delete(testUrlMissingQuery).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/api/request/GetRequest.test.ts

@@ -1,140 +0,0 @@
-import { APIService, GetRequest, RequestContext, RequestAxiosCall, RequestParameterType } from "../../../dist";
-import { APIRequestBuilder } from "../../../dist/api/APIRequestBuilder";
-import { Request, Response } from "express";
-import { config } from "../APITestDefinitions";
-
-const service = new APIService(config);
-service.init();
-
-class TestRequest extends GetRequest {
-    constructor(builder: APIRequestBuilder) {
-        super(builder.buildApiRequestConfig("/test/:method/type"));
-    }
-
-    async apply(req: Request, res: Response): Promise<any> {
-        const { method } = req.params;
-        const { value, option, x, y } = req.query;
-        return res.status(200).json({ message: "Success", method: method, type: value, option: option, x: x, y: y });
-    }
-}
-
-export class TestRequestBuilder extends APIRequestBuilder {
-    constructor() {
-        super();
-    }
-
-    public buildParams() {
-        return [{
-            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.PARAMS,
-            properties: [{ name: "success", type: RequestParameterType.BOOLEAN }]
-        }];
-    }
-
-    public buildDocDetails() {
-        return {
-            description: "Get Request",
-            samples: [{
-                status: 200,
-                input: { x: 5, y: 2 },
-                output: {
-                    message: "hola cómo estás"
-                }
-            }]
-        }
-    }
-
-    public buildApiRequestConfig(path: string) {
-        return {
-            path: path,
-            params: this.buildParams(),
-            details: this.buildDocDetails()
-        }
-    }
-}
-
-const testRequest = new TestRequest(new TestRequestBuilder());
-
-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 GET 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.get(testUrl).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(testRequest);
-        return RequestAxiosCall.get(testUrl).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(testRequest);
-        return RequestAxiosCall.get(testUrl2).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(testRequest);
-        return RequestAxiosCall.get(testUrl3).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 Error: missing parameter in query', async () => {
-        expect.assertions(5);
-        service.addRequest(testRequest);
-        return RequestAxiosCall.get(testUrlMissingQuery).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");
-        });
-    });
-});