@chainlink/external-adapter-framework 0.0.6 → 0.0.8

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,243 +0,0 @@
-import test from 'ava'
-import { expose } from '../src'
-import { Adapter } from '../src/adapter'
-import { SimpleCountingRateLimiter } from '../src/rate-limiting'
-import { AdapterDependencies } from '../src/transports'
-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)
-})