@chainlink/external-adapter-framework 0.0.8 → 0.0.12

package/test/cache/helper.ts

@@ -0,0 +1,100 @@
+import untypedTest, { TestFn } from 'ava'
+import axios, { AxiosError } from 'axios'
+import { AdapterDependencies, AdapterEndpoint } from '../../src/adapter'
+import { Cache } from '../../src/cache'
+import { AdapterRequest, AdapterResponse } from '../../src/util'
+import { NopTransport } from '../util'
+
+export const test = untypedTest as TestFn<{
+  serverAddress: string
+  cache: Cache
+  adapterEndpoint: AdapterEndpoint
+}>
+
+export class BasicCacheSetterTransport extends NopTransport {
+  cache!: Cache
+
+  override async initialize(dependencies: AdapterDependencies): Promise<void> {
+    this.cache = dependencies.cache
+  }
+
+  override async setup(req: AdapterRequest): Promise<void> {
+    const response: AdapterResponse = {
+      data: null,
+      statusCode: 200,
+      result: req.requestContext.data['factor'],
+    }
+    await this.cache.setMany(
+      [
+        {
+          key: req.requestContext.cacheKey,
+          value: response,
+        },
+      ],
+      10000,
+    )
+  }
+}
+
+export const cacheTests = () => {
+  test('returns value set in cache from setup', async (t) => {
+    const data = {
+      base: 'eth',
+      factor: 123,
+    }
+
+    const response = await axios.post(`${t.context.serverAddress}`, { data })
+    t.is(response.data.result, 123)
+  })
+
+  test('returns value already found in cache', async (t) => {
+    const data = {
+      base: 'qweqwe',
+      factor: 111,
+    }
+
+    const cacheKey = 'test-|base:qweqwe|factor:111'
+
+    // Inject values directly into the cache
+    const injectedEntry = {
+      data: null,
+      statusCode: 200,
+      result: 'injected',
+    }
+
+    t.context.cache.set(cacheKey, injectedEntry, 10000)
+
+    const response = await axios.post(`${t.context.serverAddress}`, { data })
+    t.is(response.data.result, 'injected')
+  })
+
+  test('skips expired cache entry and returns set up value', async (t) => {
+    const data = {
+      base: 'sdfghj',
+      factor: 24637,
+    }
+
+    const cacheKey = 'test-|base:sdfghj|factor:24637'
+
+    // Inject values directly into the cache
+    const injectedEntry = {
+      data: null,
+      statusCode: 200,
+      result: 'injected',
+    }
+
+    t.context.cache.set(cacheKey, injectedEntry, -10)
+
+    const response = await axios.post(`${t.context.serverAddress}`, { data })
+    t.is(response.data.result, 24637)
+  })
+
+  test('polls forever and returns timeout', async (t) => {
+    const makeRequest = () =>
+      axios.post(`${t.context.serverAddress}`, {
+        endpoint: 'nowork',
+      })
+    const error: AxiosError | undefined = await t.throwsAsync(makeRequest)
+    t.is(error?.response?.status, 504)
+  })
+}

package/test/cache/local.test.ts

@@ -0,0 +1,54 @@
+import { AddressInfo } from 'ws'
+import { expose } from '../../src'
+import { Adapter, AdapterDependencies } from '../../src/adapter'
+import { LocalCache } from '../../src/cache'
+import { SettingsMap } from '../../src/config'
+import { Transport } from '../../src/transports'
+import { NopTransport } from '../util'
+import { BasicCacheSetterTransport, cacheTests, test } from './helper'
+
+test.beforeEach(async (t) => {
+  const adapter: Adapter = {
+    name: 'test',
+    defaultEndpoint: 'test',
+    endpoints: [
+      {
+        name: 'test',
+        inputParameters: {
+          base: {
+            type: 'string',
+            required: true,
+          },
+          factor: {
+            type: 'number',
+            required: true,
+          },
+        },
+        transport: new BasicCacheSetterTransport() as Transport<unknown, unknown, SettingsMap>,
+      },
+      {
+        name: 'nowork',
+        inputParameters: {},
+        transport: new NopTransport(),
+      },
+    ],
+    envDefaultOverrides: {
+      CACHE_POLLING_SLEEP_MS: 10,
+      CACHE_POLLING_MAX_RETRIES: 3,
+    },
+  }
+
+  const cache = new LocalCache()
+  const dependencies: Partial<AdapterDependencies> = {
+    cache,
+  }
+
+  t.context.cache = cache
+  const server = await expose(adapter, dependencies)
+  if (!server) {
+    throw 'Server did not start'
+  }
+  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
+})
+
+cacheTests()

package/test/cache/redis.test.ts

@@ -0,0 +1,89 @@
+import Redis from 'ioredis'
+import { AddressInfo } from 'ws'
+import { expose } from '../../src'
+import { Adapter, AdapterDependencies } from '../../src/adapter'
+import { LocalCache, RedisCache } from '../../src/cache'
+import { SettingsMap } from '../../src/config'
+import { Transport } from '../../src/transports'
+import { NopTransport } from '../util'
+import { BasicCacheSetterTransport, cacheTests, test } from './helper'
+
+class RedisMock {
+  store = new LocalCache<string>()
+
+  get(key: string) {
+    return this.store.get(key)
+  }
+
+  del(key: string) {
+    return this.store.delete(key)
+  }
+
+  set(key: string, value: string, px: 'PX', ttl: number) {
+    return this.store.set(key, value, ttl)
+  }
+
+  multi() {
+    return new CommandChainMock(this)
+  }
+}
+
+class CommandChainMock {
+  promises: Promise<unknown>[] = []
+  constructor(private redisMock: RedisMock) {}
+
+  set(key: string, value: string, px: 'PX', ttl: number) {
+    this.promises.push(this.redisMock.set(key, value, px, ttl))
+    return this
+  }
+
+  exec() {
+    return Promise.all(this.promises)
+  }
+}
+
+test.beforeEach(async (t) => {
+  const adapter: Adapter = {
+    name: 'test',
+    defaultEndpoint: 'test',
+    endpoints: [
+      {
+        name: 'test',
+        inputParameters: {
+          base: {
+            type: 'string',
+            required: true,
+          },
+          factor: {
+            type: 'number',
+            required: true,
+          },
+        },
+        transport: new BasicCacheSetterTransport() as Transport<unknown, unknown, SettingsMap>,
+      },
+      {
+        name: 'nowork',
+        inputParameters: {},
+        transport: new NopTransport(),
+      },
+    ],
+    envDefaultOverrides: {
+      CACHE_POLLING_SLEEP_MS: 10,
+      CACHE_POLLING_MAX_RETRIES: 3,
+    },
+  }
+
+  const cache = new RedisCache(new RedisMock() as unknown as Redis) // Fake redis
+  const dependencies: Partial<AdapterDependencies> = {
+    cache,
+  }
+
+  t.context.cache = cache
+  const server = await expose(adapter, dependencies)
+  if (!server) {
+    throw 'Server did not start'
+  }
+  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
+})
+
+cacheTests()

package/test/correlation.test.ts

@@ -0,0 +1,114 @@
+import untypedTest, { TestFn } from 'ava'
+import axios from 'axios'
+import { AddressInfo } from 'net'
+import { expose } from '../src'
+import { Adapter, AdapterEndpoint } from '../src/adapter'
+import { AdapterResponse, sleep } from '../src/util'
+import { NopTransport } from './util'
+import { asyncLocalStorage, Store } from '../src/util/logger'
+
+const test = untypedTest as TestFn<{
+  serverAddress: string
+  adapterEndpoint: AdapterEndpoint
+}>
+
+const startAdapter = async (enabled: boolean) => {
+  process.env['CORRELATION_ID_ENABLED'] = enabled.toString()
+
+  const adapter: Adapter = {
+    name: 'test',
+    defaultEndpoint: 'test',
+    endpoints: [
+      {
+        name: 'test',
+        inputParameters: {},
+        transport: new (class extends NopTransport {
+          override async setup(): Promise<void | AdapterResponse<null>> {
+            const store = asyncLocalStorage.getStore() as Store
+            if (store !== undefined && store['correlationId'] === '1') {
+              await sleep(100)
+            }
+            return {
+              data: null,
+              statusCode: 200,
+              result: store as unknown as null,
+            }
+          }
+        })(),
+      },
+    ],
+  }
+
+  const server = await expose(adapter)
+  if (!server) {
+    throw 'Server did not start'
+  }
+  const serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
+  return serverAddress
+}
+
+test.serial('uses the correct correlation id when it is passed in a header', async (t) => {
+  const testId = 'test'
+  const serverAddress = await startAdapter(true)
+  const response = await axios.post(
+    serverAddress,
+    {
+      base: 'asd',
+    },
+    {
+      headers: {
+        'x-correlation-id': testId,
+      },
+    },
+  )
+  t.is(response.data.result.correlationId, testId)
+})
+
+test.serial('sets a correlation id when it is enabled as an env var', async (t) => {
+  const serverAddress = await startAdapter(true)
+  const response = await axios.post(serverAddress, {
+    base: 'asd',
+  })
+  t.is(typeof response.data.result.correlationId, 'string')
+})
+
+test.serial('correlation Id is not set when enabled is set to false', async (t) => {
+  const serverAddress = await startAdapter(false)
+  const response = await axios.post(serverAddress, {
+    base: 'asd',
+  })
+  t.is(response.data.result, undefined)
+})
+
+test.serial('preserves concurrency through subsequent calls', async (t) => {
+  const serverAddress = await startAdapter(true)
+  const request1 = await axios.post(
+    serverAddress,
+    {
+      base: 'asd',
+    },
+    {
+      headers: {
+        'x-correlation-id': '1',
+      },
+    },
+  )
+  // Send out second call normally
+
+  // Check that each call has the correct correlation Id
+  const request2 = axios.post(
+    serverAddress,
+    {
+      base: 'asd',
+    },
+    {
+      headers: {
+        'x-correlation-id': '2',
+      },
+    },
+  )
+  const response2 = await request2
+  const response1 = await request1
+  t.is(response1.data.result.correlationId === '1', true)
+  t.is(response2.data.result.correlationId === '2', true)
+})

package/test/index.test.ts

@@ -0,0 +1,37 @@
+import untypedTest, { TestFn } from 'ava'
+import axios from 'axios'
+import { AddressInfo } from 'net'
+import { expose } from '../src'
+import { Adapter } from '../src/adapter'
+import { NopTransport } from './util'
+
+const test = untypedTest as TestFn<{
+  serverAddress: string
+}>
+
+test.beforeEach(async (t) => {
+  const adapter: Adapter = {
+    name: 'test',
+    endpoints: [
+      {
+        name: 'test',
+        inputParameters: {},
+        transport: new NopTransport(),
+      },
+    ],
+  }
+
+  const server = await expose(adapter)
+  if (!server) {
+    throw 'Server did not start'
+  }
+  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
+})
+
+test('health endpoint returns health OK', async (t) => {
+  const response = await axios.get(`${t.context.serverAddress}/health`)
+  t.deepEqual(response.data, {
+    message: 'OK',
+    version: process.env['npm_package_version'],
+  })
+})

package/test/metrics/feed-id.test.ts

@@ -0,0 +1,38 @@
+import untypedTest, { TestFn } from 'ava'
+import { AdapterEndpoint } from '../../src/adapter'
+import { calculateFeedId } from '../../src/cache'
+import { AdapterConfig, buildAdapterConfig } from '../../src/config'
+import { NopTransport } from '../util'
+
+const feedIdTest = untypedTest as TestFn<{
+  adapterEndpoint: AdapterEndpoint
+  adapterConfig: AdapterConfig
+}>
+
+feedIdTest.beforeEach(async (t) => {
+  t.context.adapterEndpoint = {
+    name: 'test',
+    inputParameters: {},
+    transport: new (class extends NopTransport {})(),
+  }
+  t.context.adapterConfig = buildAdapterConfig({})
+})
+
+feedIdTest.serial('no parameters returns N/A', async (t) => {
+  t.is(calculateFeedId(t.context, {}), 'N/A')
+})
+
+feedIdTest.serial('builds feed ID correctly from input params', async (t) => {
+  t.context.adapterEndpoint.inputParameters = {
+    base: {
+      type: 'string',
+      required: true,
+    },
+    quote: {
+      type: 'string',
+      required: true,
+    },
+  }
+  const data = { base: 'ETH', quote: 'BTC' }
+  t.is(calculateFeedId(t.context, data), '|base:eth|quote:btc')
+})

package/test/metrics/helper.ts

@@ -0,0 +1,14 @@
+// Parse metrics scrape into object to use for tests
+export const parsePromMetrics = (data: string): Map<string, number> => {
+  const responseLines = data.split('\n')
+  const metricsMap = new Map<string, number>()
+  responseLines.forEach((line) => {
+    if (!line.startsWith('#') && line !== '') {
+      const metric = line.split(' ')
+      const nameLabel = metric[0]
+      const value = Number(metric[1])
+      metricsMap.set(nameLabel, value)
+    }
+  })
+  return metricsMap
+}

package/test/metrics/labels.test.ts

@@ -0,0 +1,36 @@
+import test from 'ava'
+import { cacheMetricsLabel } from '../../src/cache/metrics'
+import { connectionErrorLabels, messageSubsLabels } from '../../src/transports/metrics'
+
+test('Generate cache label test', (t) => {
+  const result = {
+    participant_id: 'test-|base:eth|quote:btc',
+    feed_id: '|base:eth|quote:btc',
+    cache_type: 'local',
+  }
+  t.deepEqual(cacheMetricsLabel('test-|base:eth|quote:btc', '|base:eth|quote:btc', 'local'), result)
+})
+
+test('Generate data provider metrics label test', (t) => {
+  const result = {
+    participant_id: 'test-|base:eth|quote:btc',
+    feed_id: '|base:eth|quote:btc',
+    cache_type: 'local',
+  }
+  t.deepEqual(cacheMetricsLabel('test-|base:eth|quote:btc', '|base:eth|quote:btc', 'local'), result)
+})
+
+test('Generate WS connection error label test', (t) => {
+  const result = {
+    message: 'error',
+  }
+  t.deepEqual(connectionErrorLabels('error'), result)
+})
+
+test('Generate WS message and subscription label test', (t) => {
+  const result = {
+    feed_id: '|base:eth|quote:btc',
+    subscription_key: 'test-|base:eth|quote:btc',
+  }
+  t.deepEqual(messageSubsLabels('|base:eth|quote:btc', 'test-|base:eth|quote:btc'), result)
+})