@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/test/transports/websocket.test.ts

@@ -1,183 +0,0 @@
-import FakeTimers from '@sinonjs/fake-timers'
-import test 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'
-
-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}`,
-    }),
-  },
-})
-
-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,
-  },
-}
-
-test('connects to websocket, subscribes, gets message, unsubscribes', async (t) => {
-  const clock = FakeTimers.install()
-
-  // Disable retries to make the testing flow easier
-  process.env['CACHE_POLLING_MAX_RETRIES'] = '0'
-
-  const base = 'ETH'
-  const quote = 'DOGE'
-  const price = 251324
-
-  // 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,
-  })
-  const address = `http://localhost:${(server?.address() as AddressInfo)?.port}`
-
-  const makeRequest = () =>
-    axios.post(address, {
-      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 = mockCache.waitForNextSet()
-  await clock.tickAsync(DEFAULT_SHARED_MS_BETWEEN_REQUESTS + 10)
-  await cacheValueSetPromise
-
-  // Second request should find the response in the cache
-  const response = await makeRequest()
-
-  t.is(response.status, 200)
-  t.deepEqual(response.data, {
-    data: null,
-    result: price,
-    statusCode: 200,
-  })
-
-  // 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)
-
-  clock.uninstall()
-})

package/test/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "include": ["./**/*.ts"],
-  "exclude": ["../src/**/*.ts"]
-}

package/test/util.ts

@@ -1,76 +0,0 @@
-import { InstalledClock } from '@sinonjs/fake-timers'
-import { LocalCache } from '../src/cache'
-import { SettingsMap } from '../src/config'
-import { AdapterDependencies, Transport } from '../src/transports'
-import { AdapterRequest, AdapterResponse } from '../src/util'
-
-export class NopTransport implements Transport<null, null, SettingsMap> {
-  async initialize(dependencies: AdapterDependencies): Promise<void> {
-    return
-  }
-  async hasBeenSetUp(): Promise<boolean> {
-    return false
-  }
-  async setup(req: AdapterRequest<unknown>): Promise<void | AdapterResponse<null>> {
-    return
-  }
-}
-
-type Resolve<T> = (value: T) => void
-export const deferredPromise = <T>(): [Promise<T>, Resolve<T>] => {
-  let resolve!: Resolve<T>
-  const promise = new Promise<T>((r) => {
-    resolve = r
-  })
-  return [promise, resolve]
-}
-
-export class MockCache extends LocalCache {
-  private awaitingPromiseResolve?: (value: unknown) => void
-
-  waitForNextSet() {
-    // eslint-disable-next-line no-promise-executor-return
-    return new Promise((resolve) => (this.awaitingPromiseResolve = resolve))
-  }
-  override async set(key: string, value: unknown, ttl: number): Promise<void> {
-    super.set(key, value, ttl)
-    if (this.awaitingPromiseResolve) {
-      this.awaitingPromiseResolve(value)
-    }
-  }
-}
-
-export async function runPeriodicAsyncBackgroundExecution(
-  clock: InstalledClock,
-  {
-    interval,
-    times,
-    stepValidation,
-  }: {
-    interval: number
-    times: number
-    stepValidation: (iteration: number) => boolean
-  },
-) {
-  for (let i = 0; i < times; i++) {
-    // Tick once for the interval
-    await clock.tickAsync(interval)
-
-    // Then use auxiliary method to ensure that the background process, if it
-    // spawns new timers, gets executed to completion
-    await runAllUntil(clock, () => stepValidation(i))
-  }
-}
-
-async function runAllUntil(clock: InstalledClock, isComplete: () => boolean): Promise<void> {
-  while (!isComplete()) {
-    await clock.nextAsync()
-  }
-}
-
-export async function runAllUntilTime(clock: InstalledClock, time: number): Promise<void> {
-  const targetTime = clock.now + time
-  while (clock.now < targetTime) {
-    await clock.nextAsync()
-  }
-}

package/test/validation.test.ts

@@ -1,169 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosError } from 'axios'
-import { AddressInfo } from 'net'
-import { expose } from '../src'
-import { Adapter, AdapterEndpoint } from '../src/adapter'
-import { AdapterResponse } from '../src/util'
-import { NopTransport } from './util'
-
-const test = untypedTest as TestFn<{
-  serverAddress: string
-  adapterEndpoint: AdapterEndpoint
-}>
-
-test.beforeEach(async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new (class extends NopTransport {
-          override async setup(): Promise<void | AdapterResponse<null>> {
-            return {
-              data: null,
-              statusCode: 200,
-              result: null,
-            }
-          }
-        })(),
-      },
-    ],
-  }
-
-  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}`
-})
-
-/**
- * NOTE: The tests here are run serially, because to avoid setting up and tearing down the adapter
- * for each one, we're just modifying the inputParameters and sending a new request every time
- */
-test.serial('any content-type other than application/json throws 400', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {}
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, 'test string', {
-      headers: {
-        'Content-Type': 'text/plain',
-      },
-    }),
-  )
-  t.is(error?.response?.status, 400)
-})
-
-test.serial('no body in request throws 400', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {}
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, '', {
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    }),
-  )
-  t.is(error?.response?.status, 400)
-})
-
-test.serial('invalid endpoint name throws 404', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {}
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, {
-      endpoint: 'random',
-    }),
-  )
-  t.is(error?.response?.status, 404)
-})
-
-test.serial('no endpoint without default throws 400', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {}
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, {
-      data: {},
-    }),
-  )
-  t.is(error?.response?.status, 400)
-})
-
-test.serial('no params returns 200', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {}
-
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {},
-    endpoint: 'test',
-  })
-  t.is(response.status, 200)
-})
-
-test.serial('missing required param throws 400', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-  }
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, {
-      data: {},
-    }),
-  )
-  t.is(error?.response?.status, 400)
-})
-
-test.serial('wrongly typed param throws 400', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-  }
-
-  const error: AxiosError | undefined = await t.throwsAsync(() =>
-    axios.post(`${t.context.serverAddress}`, {
-      data: {
-        base: 123,
-      },
-      endpoint: 'test',
-    }),
-  )
-  t.is(error?.response?.status, 400)
-})
-
-test.serial('correctly typed param returns 200', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: true,
-    },
-  }
-
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {
-      base: 'asd',
-    },
-    endpoint: 'test',
-  })
-  t.is(response.status, 200)
-})
-
-test.serial('omitted optional param returns 200', async (t) => {
-  t.context.adapterEndpoint.inputParameters = {
-    base: {
-      type: 'string',
-      required: false,
-    },
-  }
-
-  const response = await axios.post(`${t.context.serverAddress}`, {
-    data: {},
-    endpoint: 'test',
-  })
-  t.is(response.status, 200)
-})

package/test.sh

@@ -1,20 +0,0 @@
-# for i in {1..100}; do
-#   if (( $i % 50 == 0 )); then
-#     echo "sent $i" 
-#   fi
-#   curl -XPOST http://localhost:8080 -s \
-#   -H 'Content-Type: application/json' \
-#   -d '{"endpoint":"test", "data": {"base": "ethereum", "quote": "usd"}}' > /tmp/null &
-#   sleep 0.1
-# done
-
-# wait
-
-# echo "done"
-
-curl -XPOST http://localhost:8080 -s \
--H 'Content-Type: application/json' \
--d '{"endpoint":"batch", "data": {"base": "ethereum", "quote": "usd"}}' > /tmp/null &
-
-
-wait

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": ".",
-    "target": "es2020",
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "module": "CommonJS",
-    "resolveJsonModule": true,
-
-    // Type checking
-    "allowUnreachableCode": false,
-    "allowUnusedLabels": false,
-    "alwaysStrict": true,
-    "noImplicitAny": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": false,
-    "noImplicitThis": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noUnusedLocals": true,
-    "strict": true
-  },
-  "include": ["./src/**/*"]
-}

package/typedoc.json

@@ -1,6 +0,0 @@
-{
-  "$schema": "https://typedoc.org/schema.json",
-  "entryPoints": ["./src/index.ts"],
-  "out": "docs",
-  "includeVersion": true
-}