@chainlink/external-adapter-framework 0.0.14 → 0.0.15

package/test/transports/websocket.test.ts

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

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

package/test/util.ts

@@ -0,0 +1,77 @@
+import { InstalledClock } from '@sinonjs/fake-timers'
+import { AdapterDependencies } from '../src/adapter'
+import { LocalCache } from '../src/cache'
+import { SettingsMap } from '../src/config'
+import { 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

@@ -0,0 +1,178 @@
+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('endpoint in data object', async (t) => {
+  t.context.adapterEndpoint.inputParameters = {}
+
+  const response = await axios.post(`${t.context.serverAddress}`, {
+    data: { endpoint: 'test' },
+  })
+  t.is(response.status, 200)
+})
+
+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

@@ -0,0 +1,20 @@
+# 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/test2.sh

@@ -0,0 +1,2 @@
+curl -H "Accept: application/vnd.github+json" -H "Authorization: Bearer  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" \
+  "https://api.github.com/repos/smartcontractkit/ea-framework-js/actions/secrets"

package/tsconfig.json

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

package/typedoc.json

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

package/webpack.config.js

@@ -0,0 +1,57 @@
+const path = require('path')
+const glob = require('glob')
+
+module.exports = {
+  target: 'node',
+  // entry: './src/index.ts',
+  // entry: glob.sync('./src/**/*.test.{ts,tsx}').reduce((acc, file) => {
+  //   acc[file.replace(/^\.\/src\//, '')] = file
+  //   return acc
+  // }, {}),
+  mode: 'development', // This shouldn't be used in production, but is fine for now since the pkg is in active development.
+  devtool: 'inline-source-map', // This shouldn't be used in production, but is fine for now since the pkg is in active development.
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+      { test: /\.json$/, type: 'json' },
+      // { test: /\.js$/, type: 'js' },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js', '.json'],
+    fallback: {
+      // buffer: require.resolve('buffer'),
+      // https: require.resolve('https-browserify'),
+      // assert: require.resolve('assert'),
+      // http: require.resolve('stream-http'),
+      // querystring: require.resolve('querystring-es3'),
+      // url: require.resolve('url'),
+      // stream: require.resolve('stream-browserify'),
+      // crypto: require.resolve('crypto-browserify'),
+      // path: require.resolve('path-browserify'),
+      // os: require.resolve('os-browserify/browser'),
+      // process: require.resolve('process/browser'),
+      // fs: false,
+      // tls: false,
+      long: false,
+    },
+    // alias: {
+    //   'node:async_hooks': 'async_hooks',
+    // },
+  },
+  output: {
+    // filename: 'bundle.js',
+    path: path.resolve(__dirname, 'dist'),
+    // filename: '[name].[contenthash].js',
+    filename: '[name].js',
+  },
+  optimization: {
+    splitChunks: {
+      chunks: 'all',
+    },
+  },
+}