@chainlink/external-adapter-framework 0.0.15 → 0.0.16

package/test/metrics/ws-metrics.test.ts

@@ -1,225 +0,0 @@
-import FakeTimers from '@sinonjs/fake-timers'
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosError } from 'axios'
-import { Server, WebSocket } from 'mock-socket'
-import { AddressInfo } from 'net'
-import { expose } from '../../src'
-import { Adapter, AdapterEndpoint } from '../../src/adapter'
-import { DEFAULT_SHARED_MS_BETWEEN_REQUESTS } from '../../src/rate-limiting'
-import { DEFAULT_WS_TTL, WebSocketClassProvider, WebSocketTransport } from '../../src/transports'
-import { ProviderResult } from '../../src/util'
-import { InputParameters } from '../../src/validation'
-import { MockCache } from '../util'
-import { parsePromMetrics } from './helper'
-
-export const test = untypedTest as TestFn<{
-  serverAddress: string
-  cache: MockCache
-  adapterEndpoint: AdapterEndpoint
-  server: Server
-}>
-
-interface AdapterRequestParams {
-  base: string
-  quote: string
-}
-
-export const inputParameters: InputParameters = {
-  base: {
-    type: 'string',
-    required: true,
-  },
-  quote: {
-    type: 'string',
-    required: true,
-  },
-}
-
-interface ProviderMessage {
-  pair: string
-  value: number
-}
-
-const URL = 'wss://test-ws.com/asd'
-
-/**
- * Sets the mocked websocket instance in the provided provider class.
- * We need this here, because the tests will connect using their instance of WebSocketClassProvider;
- * fetching from this library to the \@chainlink/ea-bootstrap package would access _another_ instance
- * of the same constructor. Although it should be a singleton, dependencies are different so that
- * means that the static classes themselves are also different.
- *
- * @param provider - singleton WebSocketClassProvider
- */
-export const mockWebSocketProvider = (provider: typeof WebSocketClassProvider): void => {
-  // Extend mock WebSocket class to bypass protocol headers error
-  class MockWebSocket extends WebSocket {
-    constructor(url: string, protocol: string | string[] | Record<string, string> | undefined) {
-      super(url, protocol instanceof Object ? undefined : protocol)
-    }
-  }
-
-  // Need to disable typing, the mock-socket impl does not implement the ws interface fully
-  provider.set(MockWebSocket as any) // eslint-disable-line @typescript-eslint/no-explicit-any
-}
-
-export const websocketTransport = new WebSocketTransport({
-  url: URL,
-  handlers: {
-    async open() {
-      return
-    },
-
-    message(message: ProviderMessage): ProviderResult<AdapterRequestParams>[] {
-      const [base, quote] = message.pair.split('/')
-      return [
-        {
-          params: { base, quote },
-          value: message.value,
-        },
-      ]
-    },
-  },
-  builders: {
-    subscribeMessage: (params: AdapterRequestParams) => ({
-      request: 'subscribe',
-      pair: `${params.base}/${params.quote}`,
-    }),
-    unsubscribeMessage: (params: AdapterRequestParams) => ({
-      request: 'unsubscribe',
-      pair: `${params.base}/${params.quote}`,
-    }),
-  },
-})
-
-const base = 'ETH'
-const quote = 'USD'
-const price = 1234
-
-export const webSocketEndpoint: AdapterEndpoint = {
-  name: 'test',
-  transport: websocketTransport,
-  inputParameters,
-}
-
-const CACHE_MAX_AGE = 1000
-
-const adapter: Adapter = {
-  name: 'test',
-  defaultEndpoint: 'test',
-  endpoints: [webSocketEndpoint],
-  envDefaultOverrides: {
-    CACHE_MAX_AGE,
-  },
-}
-
-const clock = FakeTimers.install()
-
-test.before(async (t) => {
-  process.env['METRICS_ENABLED'] = 'true'
-  process.env['METRICS_PORT'] = '9093'
-  // Disable retries to make the testing flow easier
-  process.env['CACHE_POLLING_MAX_RETRIES'] = '0'
-
-  // Mock WS
-  mockWebSocketProvider(WebSocketClassProvider)
-  const mockWsServer = new Server(URL, { mock: false })
-  mockWsServer.on('connection', (socket) => {
-    let counter = 0
-    const parseMessage = () => {
-      if (counter++ === 0) {
-        socket.send(
-          JSON.stringify({
-            pair: `${base}/${quote}`,
-            value: price,
-          }),
-        )
-      }
-    }
-    socket.on('message', parseMessage)
-  })
-
-  // Create mocked cache so we can listen when values are set
-  // This is a more reliable method than expecting precise clock timings
-  const mockCache = new MockCache()
-
-  // Start up adapter
-  const server = await expose(adapter, {
-    cache: mockCache,
-  })
-  t.context.serverAddress = `http://localhost:${(server?.address() as AddressInfo)?.port}`
-  t.context.cache = mockCache
-  t.context.server = mockWsServer
-})
-
-test.after(async () => {
-  clock.uninstall()
-})
-
-test.serial('Test WS connection, subscription, and message metrics', async (t) => {
-  const makeRequest = () =>
-    axios.post(t.context.serverAddress, {
-      data: {
-        base,
-        quote,
-      },
-    })
-
-  // Expect the first response to time out
-  // The polling behavior is tested in the cache tests, so this is easier here.
-  // Start the request:
-  const errorPromise: Promise<AxiosError | undefined> = t.throwsAsync(makeRequest)
-  // Advance enough time for the initial request async flow
-  clock.tickAsync(10)
-  // Wait for the failed cache get -> instant 504
-  const error = await errorPromise
-  t.is(error?.response?.status, 504)
-
-  // Advance clock so that the batch warmer executes once again and wait for the cache to be set
-  const cacheValueSetPromise = t.context.cache.waitForNextSet()
-  await clock.tickAsync(DEFAULT_SHARED_MS_BETWEEN_REQUESTS + 10)
-  await cacheValueSetPromise
-
-  // Second request should find the response in the cache
-  let response = await makeRequest()
-
-  t.is(response.status, 200)
-
-  // Check connection, subscription active, subscription total, and message total metrics when subscribed to feed
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  response = await axios.get(metricsAddress)
-  let metricsMap = parsePromMetrics(response.data)
-  let expectedLabel = '{app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`ws_connection_active${expectedLabel}`), 1)
-  expectedLabel =
-    '{feed_id="|base:eth|quote:usd",subscription_key="test-|base:eth|quote:usd",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`ws_subscription_active${expectedLabel}`), 1)
-  t.is(metricsMap.get(`ws_subscription_total${expectedLabel}`), 1)
-  t.is(metricsMap.get(`ws_message_total${expectedLabel}`), 1)
-
-  // Wait until the cache expires, and the subscription is out
-  await clock.tickAsync(Math.ceil(CACHE_MAX_AGE / DEFAULT_WS_TTL) * DEFAULT_WS_TTL + 1)
-
-  // Now that the cache is out and the subscription no longer there, this should time out
-  const error2: AxiosError | undefined = await t.throwsAsync(makeRequest)
-  t.is(error2?.response?.status, 504)
-
-  // Check connection, subscription active, subscription total, and message total metrics when unsubscribed from feed
-  response = await axios.get(metricsAddress)
-  metricsMap = parsePromMetrics(response.data)
-  expectedLabel = '{app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`ws_connection_active${expectedLabel}`), 1)
-  expectedLabel =
-    '{feed_id="|base:eth|quote:usd",subscription_key="test-|base:eth|quote:usd",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`ws_subscription_active${expectedLabel}`), 0)
-  t.is(metricsMap.get(`ws_subscription_total${expectedLabel}`), 1)
-  t.is(metricsMap.get(`ws_message_total${expectedLabel}`), 2)
-
-  t.context.server.close()
-
-  // Check connection metric after connection closed
-  response = await axios.get(metricsAddress)
-  metricsMap = parsePromMetrics(response.data)
-  expectedLabel = '{app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`ws_connection_active${expectedLabel}`), 0)
-})

package/test/rate-limit-config.test.ts

@@ -1,242 +0,0 @@
-import test from 'ava'
-import { expose } from '../src'
-import { Adapter, AdapterDependencies } from '../src/adapter'
-import { SimpleCountingRateLimiter } from '../src/rate-limiting'
-import { NopTransport } from './util'
-
-test('empty tiers in rate limiting fails on startup', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-    rateLimiting: {
-      tiers: {},
-    },
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'The tiers object is defined, but has no entries',
-  })
-})
-
-test('selected tier is not a valid option', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-    rateLimiting: {
-      tiers: {
-        free: {
-          rateLimit1s: 123,
-        },
-        pro: {
-          rateLimit1s: 1234,
-        },
-      },
-    },
-    envDefaultOverrides: {
-      RATE_LIMIT_API_TIER: 'asdasdasd',
-    },
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'The selected rate limit tier "asdasdasd" is not valid (can be one of "free", "pro")',
-  })
-})
-
-test('throws error if explicit allocation leaves no room for implicitly allocated endpoints', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-        rateLimiting: {
-          allocationPercentage: 100,
-        },
-      },
-      {
-        name: 'test2',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-    rateLimiting: {
-      tiers: {
-        free: {
-          rateLimit1s: 123,
-        },
-        pro: {
-          rateLimit1s: 1234,
-        },
-      },
-    },
-    envDefaultOverrides: {
-      RATE_LIMIT_API_TIER: 'asdasdasd',
-    },
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'The explicit allocation is at 100% but there are endpoints with implicit allocation',
-  })
-})
-
-test('throws error if explicit allocation exceeds 100%', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-        rateLimiting: {
-          allocationPercentage: 80,
-        },
-      },
-      {
-        name: 'test2',
-        inputParameters: {},
-        transport: new NopTransport(),
-        rateLimiting: {
-          allocationPercentage: 30,
-        },
-      },
-    ],
-    rateLimiting: {
-      tiers: {
-        free: {
-          rateLimit1s: 123,
-        },
-        pro: {
-          rateLimit1s: 1234,
-        },
-      },
-    },
-    envDefaultOverrides: {
-      RATE_LIMIT_API_TIER: 'asdasdasd',
-    },
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'The total allocation set for all endpoints summed cannot exceed 100%',
-  })
-})
-
-test('uses most restrictive tier if none is specified in settings', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async initialize(dependencies: AdapterDependencies): Promise<void> {
-            t.true(dependencies.requestRateLimiter instanceof SimpleCountingRateLimiter)
-            t.is(
-              (dependencies.requestRateLimiter as unknown as Record<string, number>)[
-                'perSecondLimit'
-              ],
-              123,
-            )
-          }
-        })(),
-      },
-    ],
-    rateLimiting: {
-      tiers: {
-        asd: {
-          rateLimit1s: 5234,
-          rateLimit1m: 3000 * 60,
-        },
-        free: {
-          rateLimit1s: 123,
-          rateLimit1h: 1000 * 60,
-        },
-        pro: {
-          rateLimit1m: 1234 * 60,
-        },
-      },
-    },
-  }
-
-  await expose(adapter)
-})
-
-test('uses unlimited tier if none is specified in settings', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async initialize(dependencies: AdapterDependencies): Promise<void> {
-            t.true(dependencies.requestRateLimiter instanceof SimpleCountingRateLimiter)
-            t.is(
-              (dependencies.requestRateLimiter as unknown as Record<string, number>)[
-                'perSecondLimit'
-              ],
-              Infinity,
-            )
-          }
-        })(),
-      },
-    ],
-  }
-
-  await expose(adapter)
-})
-
-test('uses specified tier if present in settings', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async initialize(dependencies: AdapterDependencies): Promise<void> {
-            t.true(dependencies.requestRateLimiter instanceof SimpleCountingRateLimiter)
-            t.is(
-              (dependencies.requestRateLimiter as unknown as Record<string, number>)[
-                'perSecondLimit'
-              ],
-              1234,
-            )
-          }
-        })(),
-      },
-    ],
-    rateLimiting: {
-      tiers: {
-        asd: {
-          rateLimit1s: 5234,
-          rateLimit1m: 3000 * 60,
-        },
-        free: {
-          rateLimit1s: 123,
-          rateLimit1h: 1000 * 60,
-        },
-        pro: {
-          rateLimit1s: 1234,
-        },
-      },
-    },
-    envDefaultOverrides: {
-      RATE_LIMIT_API_TIER: 'pro',
-    },
-  }
-
-  await expose(adapter)
-})

package/test/smoke/smoke.test.ts

@@ -1,166 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import { AddressInfo } from 'net'
-import nock from 'nock'
-import { expose } from '../../src'
-import { Adapter, AdapterEndpoint } from '../../src/adapter'
-import { EmptySettings } from '../../src/config'
-import { RestTransport } from '../../src/transports'
-import { AdapterRequest, AdapterResponse } from '../../src/util'
-import { loadTestPayload } from '../../src/util/test-payload-loader'
-
-const test = untypedTest as TestFn
-
-const URL = 'http://test-url.com'
-const endpoint = '/price'
-
-interface AdapterRequestParams {
-  from: string
-  to: string
-}
-
-interface ProviderRequestBody {
-  base: string
-  quote: string
-}
-
-interface ProviderResponseBody {
-  price: number
-}
-
-const createAdapterEndpoint = (): AdapterEndpoint => {
-  const restEndpointTransport = new RestTransport<
-    AdapterRequestParams,
-    ProviderRequestBody,
-    ProviderResponseBody,
-    EmptySettings
-  >({
-    prepareRequest: (
-      req: AdapterRequest<AdapterRequestParams>,
-    ): AxiosRequestConfig<ProviderRequestBody> => {
-      return {
-        baseURL: URL,
-        url: endpoint,
-        method: 'GET',
-        params: {
-          base: req.requestContext.data.from,
-          quote: req.requestContext.data.to,
-        },
-      }
-    },
-    parseResponse: (
-      req: AdapterRequest<AdapterRequestParams>,
-      res: AxiosResponse<ProviderResponseBody>,
-    ): AdapterResponse<ProviderResponseBody> => {
-      return {
-        data: res.data,
-        statusCode: 200,
-        result: res.data.price,
-      }
-    },
-    options: {
-      coalescing: true,
-    },
-  })
-
-  return {
-    name: 'test',
-    inputParameters: {
-      from: {
-        type: 'string',
-        required: true,
-      },
-      to: {
-        type: 'string',
-        required: true,
-      },
-    },
-    transport: restEndpointTransport,
-  }
-}
-
-const adapter: Adapter = {
-  name: 'test',
-  defaultEndpoint: 'test',
-  endpoints: [createAdapterEndpoint()],
-}
-
-test.before(async () => {
-  nock.disableNetConnect()
-  nock.enableNetConnect('localhost')
-})
-
-test.after(() => {
-  nock.restore()
-})
-
-const base = 'ETH'
-const quote = 'USD'
-const price = 1234
-
-test('Test payload loader static', async (t) => {
-  const testPayload = loadTestPayload('test/smoke/test-payload.json')
-  if (testPayload.isDefault) {
-    t.fail('Test payload loader return isDefault request unexpectedly')
-    return
-  }
-  t.deepEqual(testPayload.requests[0], { from: base, to: quote })
-})
-
-test('Test payload loader dynamic', async (t) => {
-  const testPayload = loadTestPayload('test/smoke/test-payload.js')
-  if (testPayload.isDefault) {
-    t.fail('Test payload loader return isDefault request unexpectedly')
-    return
-  }
-  t.deepEqual(testPayload.requests[0], { from: 'ETH', to: 'USD' })
-  t.deepEqual(testPayload.requests[1], { from: 'ETH', to: 'JPY' })
-  t.deepEqual(testPayload.requests[2], { from: 'BTC', to: 'USD' })
-  t.deepEqual(testPayload.requests[3], { from: 'BTC', to: 'JPY' })
-})
-
-test.only('Test payload loader bad file name', async (t) => {
-  const testPayload = loadTestPayload('test/smoke/test-payload-bad.json')
-  t.is(testPayload.isDefault, true)
-})
-
-test.serial('Test smoke endpoint success', async (t) => {
-  process.env['SMOKE_TEST_PAYLOAD_FILE_NAME'] = 'test/smoke/test-payload.json'
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  const address = `http://localhost:${(server?.address() as AddressInfo)?.port}`
-  const instance = nock(URL)
-    .get(endpoint)
-    .query({
-      base,
-      quote,
-    })
-    .reply(200, { price })
-  let response: AxiosResponse
-  try {
-    response = await axios.get(`${address}/smoke`)
-  } catch (e: unknown) {
-    t.fail('Smoke endpoint errored unexpectedly')
-    return
-  }
-  t.is(response.data, 'OK')
-  instance.done()
-})
-
-test.serial('Test smoke endpoint failure', async (t) => {
-  process.env['SMOKE_TEST_PAYLOAD_FILE_NAME'] = 'test/smoke/test-payload-fail.json'
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  const address = `http://localhost:${(server?.address() as AddressInfo)?.port}`
-  try {
-    await axios.get(`${address}/smoke`)
-  } catch (e: unknown) {
-    t.is((e as AxiosError).response?.status, 500)
-    return
-  }
-  t.fail('Smoke endpoint passed unexpectedly')
-})

package/test/smoke/test-payload-fail.json

@@ -1,3 +0,0 @@
-{
-  "requests": [{ "from": "" }]
-}

package/test/smoke/test-payload.js

@@ -1,22 +0,0 @@
-const fromVariables = ['ETH', 'BTC']
-
-const toVariables = ['USD', 'JPY']
-
-function generateTestPayload() {
-  const payload = {
-    requests: [],
-  }
-
-  for (const from of fromVariables) {
-    for (const to of toVariables) {
-      payload.requests.push({
-        from,
-        to,
-      })
-    }
-  }
-
-  return JSON.stringify(payload)
-}
-
-module.exports = generateTestPayload()

package/test/smoke/test-payload.json

@@ -1,7 +0,0 @@
-{
-    "requests": [{
-     "from": "ETH",
-     "to": "USD"
-    }]
-}
-