@chainlink/external-adapter-framework 0.0.14 → 0.0.16

package/examples/coingecko/test/integration/adapter.test.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-nested-callbacks */
+const index_1 = require("../../src/index");
+const __1 = require("../../../..");
+const supertest_1 = __importDefault(require("supertest"));
+const fixtures_1 = require("./fixtures");
+let adapterServer;
+function sleep(ms) {
+    // eslint-disable-next-line
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+describe('execute', () => {
+    const id = '1';
+    let req;
+    jest.setTimeout(10000);
+    const successfulRequests = {
+        crypto: {
+            id,
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        cryptoWithCoinid: {
+            id,
+            data: {
+                coinid: 'bitcoin',
+                quote: 'USD',
+            },
+        },
+        cryptoWithOverride: {
+            id,
+            data: {
+                base: 'BTC',
+                quote: 'EUR',
+                overrides: {
+                    coingecko: {
+                        BTC: 'solana',
+                    },
+                },
+            },
+        },
+        coins: {
+            id,
+            endpoint: 'coins',
+        },
+        marketcap: {
+            id,
+            endpoint: 'marketcap',
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        volume: {
+            id,
+            endpoint: 'volume',
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        globalmarketcap: {
+            id,
+            endpoint: 'globalmarketcap',
+            data: {
+                market: 'ETH',
+            },
+        },
+        dominance: {
+            id,
+            endpoint: 'dominance',
+            data: {
+                market: 'ETH',
+            },
+        },
+    };
+    const errorRequests = {
+        cryptoWithBadSymbol: {
+            id,
+            data: {
+                base: 'ZWXK',
+                quote: 'USD',
+            },
+        },
+        cryptoWithBadOverride: {
+            id,
+            data: {
+                base: 'LINK',
+                quote: 'USD',
+                overrides: {
+                    coingecko: {
+                        LINK: 'badtokenid',
+                    },
+                },
+            },
+        },
+        dominanceWithBadSymbol: {
+            id,
+            endpoint: 'dominance',
+            data: {
+                market: 'ZWXK',
+            },
+        },
+    };
+    beforeAll(async () => {
+        try {
+            adapterServer = await (0, __1.expose)(index_1.adapter);
+            req = (0, supertest_1.default)('localhost:8080');
+        }
+        catch {
+            throw new Error('Could not start server when running CoinGecko e2e tests');
+        }
+        if (!adapterServer) {
+            throw new Error('Could not start server when running CoinGecko e2e tests');
+        }
+        (0, fixtures_1.createMocks)();
+        // Send inital requests to warm the cache
+        const pendingRequests = [];
+        for (const reqData of Object.values(successfulRequests)) {
+            pendingRequests.push(req.post('/').send(reqData));
+        }
+        for (const reqData of Object.values(errorRequests)) {
+            pendingRequests.push(req.post('/').send(reqData));
+        }
+        // Wait for all the pending requests to be complete
+        Promise.all(pendingRequests);
+        // Sleep while the cache is filled
+        await sleep(5000);
+    });
+    afterAll((done) => {
+        if (adapterServer) {
+            adapterServer.close(done());
+        }
+    });
+    describe('crypto api', () => {
+        it('should return success', async () => {
+            // Send inital request to warm cache
+            const response = await req
+                .post('/')
+                .send(successfulRequests.crypto)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+        it('should return success with coinid', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.cryptoWithCoinid)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+        it('should return error message for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+        it('should return success with override', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.cryptoWithOverride)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+        it('should return 504 for bad override', async () => {
+            const response = await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadOverride)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+            expect(typeof response.body.result === 'string');
+        });
+        it('should return 504 for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+    });
+    describe('coins api', () => {
+        it('should return success', async () => {
+            await req
+                .post('/')
+                .send(successfulRequests.coins)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+        });
+    });
+    describe('volume api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.volume)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+    });
+    describe('marketcap api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.marketcap)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+    });
+    describe('globalmarketcap api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.globalmarketcap)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+    });
+    describe('dominance api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.dominance)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toMatchSnapshot();
+        });
+        it('should return 504 for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.dominanceWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+    });
+});