@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/test/background-executor.test.ts

@@ -1,109 +0,0 @@
-import test from 'ava'
-import FakeTimers from '@sinonjs/fake-timers'
-import { expose } from '../src'
-import { Adapter } from '../src/adapter'
-import { AdapterContext } from '../src/transports'
-import { deferredPromise, NopTransport } from './util'
-
-test('background executor calls transport function with background context', async (t) => {
-  const [promise, resolve] = deferredPromise<AdapterContext>()
-
-  const transport = new (class extends NopTransport {
-    async backgroundExecute(context: AdapterContext): Promise<number> {
-      resolve(context)
-      return 100
-    }
-  })()
-
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport,
-      },
-      {
-        name: 'skipped',
-        inputParameters: {},
-        transport: new NopTransport(), // Also add coverage for skipped executors
-      },
-    ],
-  }
-
-  await expose(adapter)
-  const context = await promise
-  t.is(context.adapterEndpoint.name, 'test')
-})
-
-// Needs to be serial to avoid mocking global clock more than once at the same time
-// TODO: Inject clock?
-test.serial(
-  'background executor calls transport function second time after sleeping',
-  async (t) => {
-    const clock = FakeTimers.install()
-    let timesCalled = 0
-
-    const transport = new (class extends NopTransport {
-      async backgroundExecute(): Promise<number> {
-        timesCalled++
-        return 1000
-      }
-    })()
-
-    const adapter: Adapter = {
-      name: 'test',
-      endpoints: [
-        {
-          name: 'test',
-          inputParameters: {},
-          aliases: ['other'], // Add an alias to ensure it's not called once per alias
-          transport,
-        },
-      ],
-    }
-
-    await expose(adapter)
-    t.is(timesCalled, 1)
-    await clock.tickAsync(999)
-    t.is(timesCalled, 1)
-    await clock.tickAsync(1)
-    t.is(timesCalled, 2)
-
-    clock.uninstall()
-  },
-)
-
-test.serial('background executor ends recursive chain on server close', async (t) => {
-  const clock = FakeTimers.install()
-  let timesCalled = 0
-
-  const transport = new (class extends NopTransport {
-    async backgroundExecute(): Promise<number> {
-      timesCalled++
-      return 1000
-    }
-  })()
-
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport,
-      },
-    ],
-  }
-
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.is(timesCalled, 1)
-  server.close()
-  await clock.tickAsync(999999)
-  t.is(timesCalled, 1) // The background process closed, so this was never called again
-
-  clock.uninstall()
-})

package/test/cache/cache-key.test.ts

@@ -1,96 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios from 'axios'
-import { AddressInfo } from 'net'
-import { expose } from '../../src'
-import { Adapter, AdapterEndpoint } from '../../src/adapter'
-import { Cache } from '../../src/cache'
-import { BaseSettings } from '../../src/config'
-import { AdapterRequest, AdapterResponse } from '../../src/util'
-import { NopTransport } from '../util'
-
-const test = untypedTest as TestFn<{
-  serverAddress: string
-  cache: Cache
-  adapterEndpoint: AdapterEndpoint
-}>
-
-test.beforeEach(async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    defaultEndpoint: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async setup(
-            req: AdapterRequest<unknown>,
-          ): Promise<void | AdapterResponse<null>> {
-            return {
-              data: null,
-              statusCode: 200,
-              result: req.requestContext.cacheKey,
-            }
-          }
-        })(),
-      },
-    ],
-  }
-
-  t.context.adapterEndpoint = adapter.endpoints[0]
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
-})
-
-test.serial('no parameters returns default cache key', async (t) => {
-  const response = await axios.post(`${t.context.serverAddress}`, {})
-  t.is(response.data.result, BaseSettings.DEFAULT_CACHE_KEY.default)
-})
-
-test.serial('builds cache key correctly from input params', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-    quote: {
-      type: 'string',
-      required: false,
-    },
-    factor: {
-      type: 'number',
-      required: true,
-    },
-    proper: {
-      type: 'boolean',
-      required: false,
-    },
-    details: {
-      type: 'object',
-      required: true,
-    },
-    nullable: {
-      type: 'object',
-      required: false,
-    },
-  }
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {
-      base: 'eth',
-      factor: 123,
-      proper: true,
-      details: {
-        asd: 'qwe',
-        zxc: 432,
-      },
-      nullable: null,
-    },
-  })
-  t.is(
-    response.data.result,
-    'test-|base:eth|factor:123|proper:true|details:{"asd":"qwe","zxc":432}',
-  )
-})

package/test/cache/helper.ts

@@ -1,101 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosError } from 'axios'
-import { AdapterEndpoint } from '../../src/adapter'
-import { Cache } from '../../src/cache'
-import { AdapterDependencies } from '../../src/transports'
-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

@@ -1,54 +0,0 @@
-import { AddressInfo } from 'ws'
-import { expose } from '../../src'
-import { Adapter } from '../../src/adapter'
-import { LocalCache } from '../../src/cache'
-import { SettingsMap } from '../../src/config'
-import { AdapterDependencies, 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

@@ -1,89 +0,0 @@
-import Redis from 'ioredis'
-import { AddressInfo } from 'ws'
-import { expose } from '../../src'
-import { Adapter } from '../../src/adapter'
-import { LocalCache, RedisCache } from '../../src/cache'
-import { SettingsMap } from '../../src/config'
-import { AdapterDependencies, 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

@@ -1,114 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,33 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import { AdapterEndpoint } from '../../src/adapter'
-import { calculateFeedId } from '../../src/cache'
-import { NopTransport } from '../util'
-
-const feedIdTest = untypedTest as TestFn<{ adapterEndpoint: AdapterEndpoint }>
-
-feedIdTest.beforeEach(async (t) => {
-  t.context.adapterEndpoint = {
-    name: 'test',
-    inputParameters: {},
-    transport: new (class extends NopTransport {})(),
-  }
-})
-
-feedIdTest.serial('no parameters returns N/A', async (t) => {
-  t.is(calculateFeedId(t.context.adapterEndpoint, {}), '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.adapterEndpoint, data), '|base:eth|quote:btc')
-})

package/test/metrics/helper.ts

@@ -1,14 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-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)
-})