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

package/test/database/sequelize/SequelizeModelManager.test.ts

@@ -1,206 +0,0 @@
-import { DataTypes } from '@sequelize/core';
-import { SequelizeConnection, SequelizeModelManager } from '../../../dist';
-import { config } from './SequealizeDefinitions';
-
-interface Test {
-    testId: number,
-    name: string
-}
-
-interface TestB {
-    testId: number,
-    name: string
-}
-
-const connection = new SequelizeConnection(config);
-const manager = new SequelizeModelManager<Test>({
-    name: 'Test',
-    attributes: {
-        testId: {
-            type: DataTypes.INTEGER,
-            allowNull: false,
-            unique: true
-        },
-        name: {
-            type: DataTypes.STRING,
-            allowNull: false
-        }
-    }
-});
-
-const managerB = new SequelizeModelManager<TestB>({
-    name: 'TestB',
-    attributes: {
-        name: {
-            type: DataTypes.STRING,
-            allowNull: false
-        }
-    }
-});
-
-const managerC = new SequelizeModelManager<TestB>({
-    name: 'TestC',
-    attributes: {
-        name: {
-            type: DataTypes.STRING,
-            allowNull: false
-        }
-    }
-});
-
-describe("Testing Sequelize Model Manager", () => {
-    beforeAll(async () => {
-        await connection.connect();
-        await managerB.define(connection);
-        await managerC.define(connection);
-    });
-    afterAll(async() => {
-        await connection.disconnect();
-    });
-    test("Init Model", async () => {
-        await manager.define(connection);
-        let result = await manager.sync();
-        expect(result.name).toMatch('Test');
-        expect(result.tableName).toMatch('Tests');
-    });
-    test("Insert", async () => {
-        expect.assertions(2);
-        return manager.create({
-            testId: 1,
-            name: 'test1'
-        }).then((response: any) => {
-            expect(response.dataValues.testId).toBe(1);
-            expect(response.dataValues.name).toMatch('test1');
-        });
-    });
-    test("Insert Fail", async () => {
-        expect.assertions(2);
-        return manager.create({
-            testId: 1,
-            name: 'test1'
-        }).catch((err: any) => {
-            expect(err.name).toMatch('SequelizeUniqueConstraintError');
-            expect(err.errors[0].message).toMatch('testId must be unique');
-        });
-    });
-    test("Insert Many", async () => {
-        expect.assertions(4);
-        return manager.bulkCreate([{
-            testId: 2,
-            name: 'test2'
-        }, {
-            testId: 3,
-            name: 'test3'
-        }]).then((response: any) => {
-            expect(response[0].dataValues.testId).toBe(2);
-            expect(response[0].dataValues.name).toMatch('test2');
-            expect(response[1].dataValues.testId).toBe(3);
-            expect(response[1].dataValues.name).toMatch('test3');
-        });
-    });
-    test("Update", async () => {
-        expect.assertions(1);
-        return manager.update({
-            name: 'test2'
-        }, {
-            where: {
-                testId: 1
-            }
-        }).then((response: any) => {
-            expect(response[0]).toBeGreaterThan(0);
-        });
-    });
-    test("Find All", async () => {
-        expect.assertions(2);
-        return manager.findAll({
-            where: {
-                testId: 1
-            }
-        }).then((response: any) => {
-            expect(response[0].dataValues.testId).toBe(1);
-            expect(response[0].dataValues.name).toMatch('test2');
-        });
-    });
-    test("Delete", async () => {
-        expect.assertions(1);
-        return manager.destroy({
-            where: {
-                testId: [1, 2, 3]
-            }
-        }).then((response: any) => {
-            expect(response).toBeGreaterThan(0);
-        });
-    });
-    test("> testing hasOne:", async () => {
-        let response = await manager.hasOne(managerB);
-        console.log("> hasOne response:", response);
-        expect(response.accessors.create).toMatch("createTestB");
-        expect(response.accessors.get).toMatch("getTestB");
-        expect(response.accessors.set).toMatch("setTestB");
-        expect(response.inverse.accessors.create).toMatch("createTest");
-        expect(response.inverse.accessors.get).toMatch("getTest");
-        expect(response.inverse.accessors.set).toMatch("setTest");
-        expect(response.inverse.foreignKey).toMatch("testId");
-        expect(response.inverse.options.as).toMatch("test");
-    });
-    test("> testing hasMany:", async () => {
-        let response = await manager.hasMany(managerB);
-        console.log("> hasMany response:", response);
-        expect(response.accessors.add).toMatch("addTestB");
-        expect(response.accessors.addMultiple).toMatch("addTestBs");
-        expect(response.accessors.count).toMatch("countTestBs");
-        expect(response.accessors.create).toMatch("createTestB");
-        expect(response.accessors.get).toMatch("getTestBs");
-        expect(response.accessors.hasAll).toMatch("hasTestBs");
-        expect(response.accessors.hasSingle).toMatch("hasTestB");
-        expect(response.accessors.remove).toMatch("removeTestB");
-        expect(response.accessors.removeMultiple).toMatch("removeTestBs");
-        expect(response.accessors.set).toMatch("setTestBs");
-        expect(response.inverse.accessors.create).toMatch("createTest");
-        expect(response.inverse.accessors.get).toMatch("getTest");
-        expect(response.inverse.accessors.set).toMatch("setTest");
-        expect(response.inverse.foreignKey).toMatch("testId");
-        expect(response.inverse.options.as).toMatch("test");
-    });
-    test("> testing belongsTo:", async () => {
-        let response = await managerB.belongsTo(manager);
-        console.log("> belongsTo:", response);
-        expect(response.accessors.create).toMatch("createTest");
-        expect(response.accessors.get).toMatch("getTest");
-        expect(response.accessors.set).toMatch("setTest");
-        expect(response.parentAssociation.accessors.create).toMatch("createTestB");
-        expect(response.parentAssociation.accessors.get).toMatch("getTestB");
-        expect(response.parentAssociation.accessors.set).toMatch("setTestB");
-        expect(response.foreignKey).toMatch("testId");
-        expect(response.options.as).toMatch("test");
-    });
-    test("> testing belongsToMany:", async () => {
-        let response = await managerC.belongsToMany(managerB, { through: "" });
-        console.log("> belongsToMany:", response);
-        expect(response.accessors.add).toMatch("addTestB");
-        expect(response.accessors.addMultiple).toMatch("addTestBs");
-        expect(response.accessors.count).toMatch("countTestBs");
-        expect(response.accessors.create).toMatch("createTestB");
-        expect(response.accessors.get).toMatch("getTestBs");
-        expect(response.accessors.hasAll).toMatch("hasTestBs");
-        expect(response.accessors.hasSingle).toMatch("hasTestB");
-        expect(response.accessors.remove).toMatch("removeTestB");
-        expect(response.accessors.removeMultiple).toMatch("removeTestBs");
-        expect(response.accessors.set).toMatch("setTestBs");
-        expect(response.fromSourceToThrough.accessors.add).toMatch("addTestBsTestC");
-        expect(response.fromSourceToThrough.accessors.addMultiple).toMatch("addTestBsTestCs");
-        expect(response.fromSourceToThrough.accessors.count).toMatch("countTestBsTestCs");
-        expect(response.fromSourceToThrough.accessors.create).toMatch("createTestBsTestC");
-        expect(response.fromSourceToThrough.accessors.get).toMatch("getTestBsTestCs");
-        expect(response.fromSourceToThrough.accessors.hasAll).toMatch("hasTestBsTestCs");
-        expect(response.fromSourceToThrough.accessors.hasSingle).toMatch("hasTestBsTestC");
-        expect(response.fromSourceToThrough.accessors.remove).toMatch("removeTestBsTestC");
-        expect(response.fromSourceToThrough.accessors.removeMultiple).toMatch("removeTestBsTestCs");
-        expect(response.fromSourceToThrough.accessors.set).toMatch("setTestBsTestCs");
-        expect(response.fromSourceToThrough.inverse.accessors.create).toMatch("createTestC");
-        expect(response.fromSourceToThrough.inverse.accessors.get).toMatch("getTestC");
-        expect(response.fromSourceToThrough.inverse.accessors.set).toMatch("setTestC");
-        expect(response.fromSourceToThrough.inverse.foreignKey).toMatch("testCId");
-        expect(response.fromSourceToThrough.inverse.options.as).toMatch("testC");
-    });
-});

package/test/log/Logger.test.ts

@@ -1,44 +0,0 @@
-import { Logger } from '../../dist';
-import { v4 as uuidv4, validate } from 'uuid';
-import MockAdapter from "axios-mock-adapter";
-import axios from "axios";
-
-const EXECUTOR = "https://services.itrmachines.com/log-executor/";
-const LOGGER = "https://services.itrmachines.com/log-executor/send";
-
-const logger: Logger = new Logger(EXECUTOR, LOGGER);
-
-describe("> testing Logger", () => {
-    let mock: MockAdapter;
-    let executionId: string;
-    beforeAll(() => {
-        mock = new MockAdapter(axios);
-    });
-    afterEach(() => {
-        mock.reset();
-    });
-    test("> testing request a new extecution Id", async () => {
-        mock.onPost(`${EXECUTOR}/generateid`).reply(200, uuidv4() + "87");
-        executionId = await logger.requestExecutionId();
-        expect(executionId.length).toBeGreaterThan(36);
-        expect(validate(executionId.substring(0, 36))).toBeTruthy();
-    });
-    test("> testing sending a log", async () => {
-        mock.onPost(LOGGER).reply(404, { log: {} });
-        return await logger.send({})
-        .catch((err: any) => {
-            expect(err.message).toMatch('Request failed with status code 404');
-            expect(err.response.status).toBe(404);
-        });
-    });
-    test("> testing sending a log", async () => {
-        mock.onPost(LOGGER).reply(200, 'Ok');
-        return await logger.send({
-            timestamp: 10000000,
-            executionId: '7752a2cc-676f-4c0f-881f-8bb6086ab7f21',
-            data: {}
-        }).then((response: any) => {
-            expect(response).toMatch('Ok');
-        });
-    });
-});

package/test/web3/coingecko/CoingeckoPriceFinder.test.ts

@@ -1,72 +0,0 @@
-import { Coin, CoingeckoPriceFinder, RequestAxiosCall } from "../../../dist";
-import MockAdapter from "axios-mock-adapter";
-import axios from "axios";
-
-const finderETH = new CoingeckoPriceFinder();
-const finderUSD = new CoingeckoPriceFinder('usd');
-const dates = [ '01-01-2022', '02-02-2022', '03-03-2022', '04-04-2022', '05-05-2022' ];
-const coins = [ Coin.BTC, Coin.MANA, Coin.DAI, Coin.SAND ];
-const symbolId = [ 'bitcoin', 'decentraland', 'dai', 'the-sandbox' ];
-
-const testCoins = [
-    Coin.APE, Coin.ARTX, Coin.ATRI, Coin.BTC, Coin.CUBE, Coin.DAI, Coin.MANA,
-    Coin.MATIC, Coin.RARI, Coin.SAND, Coin.SCOTT, Coin.USDC, Coin.WBTC
-];
-const testSymbolIds = [
-    "apecoin", "artx", "atari", "bitcoin", "somnium-space-cubes",
-    "dai", "decentraland", "matic-network", "rarible", "the-sandbox",
-    "scotty-beam", "usd-coin", "bitcoin"
-];
-
-async function findEthValues(coinIndex: number, dateIndex: number) {
-    let info = dates[dateIndex].split('-');
-    let year = parseInt(info[2]);
-    let month = parseInt(info[1]);
-    let day = parseInt(info[0]);
-    let price = await finderETH.getPrice(coins[coinIndex], new Date(year, month - 1, day, 0, 0, 0));
-    let coinGeckoPrice: any = await RequestAxiosCall.get(`https://api.coingecko.com/api/v3/coins/${symbolId[coinIndex]}/history?date=${dates[dateIndex]}`);
-    return {
-        original: coinGeckoPrice.market_data.current_price.eth,
-        price: price
-    };
-}
-
-async function findUsdValues(coinIndex: number, dateIndex: number) {
-    let info = dates[dateIndex].split('-');
-    let year = parseInt(info[2]);
-    let month = parseInt(info[1]);
-    let day = parseInt(info[0]);
-    let price = await finderUSD.getPrice(coins[coinIndex], new Date(year, month - 1, day, 0, 0, 0));
-    let coinGeckoPrice: any = await RequestAxiosCall.get(`https://api.coingecko.com/api/v3/coins/${symbolId[coinIndex]}/history?date=${dates[dateIndex]}`);
-    return {
-        original: coinGeckoPrice.market_data.current_price.usd,
-        price: price
-    };
-}
-
-describe('testing Checkable Router', () => {
-    let mock: MockAdapter;
-    beforeAll(() => {
-        mock = new MockAdapter(axios);
-        for (let symbol of symbolId)
-            for (let date of dates)
-                mock.onGet(`https://api.coingecko.com/api/v3/coins/${symbol}/history?date=${date}`).reply(200, { market_data: { current_price: { eth: Math.random(), usd: 1200 * Math.random() } } });
-    });
-    afterAll(() => {
-        mock.reset();
-    });
-    test('ETH Finder Random', async() => {
-        let coinIndex: number = Math.floor(Math.random() * coins.length);
-        let dateIndex: number = Math.floor(Math.random() * dates.length);
-        let values: any;
-        if (Math.random() < 0.5)
-            values = await findEthValues(coinIndex, dateIndex);
-        else
-            values = await findUsdValues(coinIndex, dateIndex);
-        expect(values.price).toBe(values.price);
-    });
-    test('Testing symbolId function', () => {
-        for (let i = 0; i < testCoins.length; i++)
-            expect(finderETH.parseSymbolId(testCoins[i])).toMatch(testSymbolIds[i]);
-    })
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es2022",
-    "declaration": true,
-    "moduleResolution": "node",
-    "sourceMap": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "allowJs": false,
-    "strict": true,
-    "esModuleInterop": true,
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/*.spec.ts"
-  ]
-}