@chainlink/external-adapter-framework 0.0.8 → 0.0.12

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-payload-fail.json

@@ -0,0 +1,3 @@
+{
+  "requests": [{ "from": "" }]
+}

package/test-payload.js

@@ -0,0 +1,22 @@
+const fromVariables = ['ETH', 'BTC']
+
+const toVariables = ['USD', 'JPY']
+
+function generateTestPayload() {
+  const payload = {
+    requests: [],
+  }
+
+  for (const from of fromVariables) {
+    for (const to of toVariables) {
+      payload.requests.push({
+        from,
+        to,
+      })
+    }
+  }
+
+  return JSON.stringify(payload)
+}
+
+module.exports = generateTestPayload()

package/test-payload.json

@@ -0,0 +1,7 @@
+{
+    "requests": [{
+     "from": "ETH",
+     "to": "USD"
+    }]
+}
+   

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,25 @@
+{
+  "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,
+    "declaration": true // Emit a d.ts file
+  },
+  "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,23 @@
+const path = require('path')
+
+module.exports = {
+  entry: './src/index.ts',
+
+  devtool: 'inline-source-map',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+  },
+  output: {
+    filename: 'bundle.js',
+    path: path.resolve(__dirname, 'dist'),
+  },
+}

package/package/adapter.d.ts

@@ -1,88 +0,0 @@
-import { AdapterConfig, BaseAdapterConfig, SettingsMap } from './config';
-import { AdapterRateLimitTier } from './rate-limiting';
-import { AdapterDependencies, Transport } from './transports';
-import { InputParameters } from './validation/input-params';
-/**
- * Structure to describe rate limits specs for the Adapter
- */
-interface AdapterRateLimitingConfig {
-    /** Adapter rate limits, gotten from the specific tier requested */
-    tiers: Record<string, AdapterRateLimitTier>;
-}
-/**
- * Main structure of an External Adapter
- */
-export interface Adapter {
-    /** Name of the adapter */
-    name: string;
-    /** If present, the string that will be used for requests with no specified endpoint */
-    defaultEndpoint?: string;
-    /** List of [[AdapterEndpoint]]s in the adapter */
-    endpoints: AdapterEndpoint[];
-    /** Map of overrides to the default config values for an Adapter */
-    envDefaultOverrides?: Partial<BaseAdapterConfig>;
-    /** List of custom env vars for this particular adapter (e.g. RPC_URL) */
-    customSettings?: SettingsMap;
-    /** Configuration relevant to outbound (EA --\> DP) communication rate limiting */
-    rateLimiting?: AdapterRateLimitingConfig;
-    /** Overrides for converting the 'base' parameter that are hardcoded into the adapter. */
-    overrides?: Record<string, string>;
-}
-/**
- * Structure to describe rate limits specs for a specific adapter endpoint
- */
-export interface EndpointRateLimitingConfig {
-    /**
-     * How much of the total limit for the adapter will be assigned to this specific endpoint.
-     * Should be a non-zero positive number up to 100.
-     * Endpoints in the same adapter without a specific allocation will divide the remaining limits equally.
-     */
-    allocationPercentage: number;
-}
-/**
- * Structure to describe a specific endpoint in an [[Adapter]]
- */
-export interface AdapterEndpoint {
-    /** Name that will be used to match input params to this endpoint (case insensitive) */
-    name: string;
-    /** List of alternative endpoint names that will resolve to this same transport (case insensitive) */
-    aliases?: string[];
-    /** Transport that will be used to handle data processing and communication for this endpoint */
-    transport: Transport<any, any, any>;
-    /** Specification of what the body of a request hitting this endpoint should look like (used for validation) */
-    inputParameters: InputParameters;
-    /** Specific details related to the rate limiting for this endpoint in particular */
-    rateLimiting?: EndpointRateLimitingConfig;
-}
-/**
- * Structure to describe an adapter that has been initialized
- */
-export interface InitializedAdapter extends Adapter {
-    /** Object containing alias translations for all endpoints */
-    endpointsMap: Record<string, AdapterEndpoint>;
-    /** Initialized dependencies that the adapter will use */
-    dependencies: AdapterDependencies;
-    /** Configuration params for various adapter properties */
-    config: AdapterConfig;
-}
-/**
- * This function will process dependencies for an adapter, such as caches or rate limiters,
- * in order to inject them into transports and other relevant places later in the lifecycle.
- *
- * @param config - the configuration for this adapter
- * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
- * @param rateLimitingConfig - details from the adapter regarding rate limiting
- * @returns a set of AdapterDependencies all initialized
- */
-export declare const initializeDependencies: (adapter: Adapter, config: AdapterConfig, inputDependencies?: Partial<AdapterDependencies> | undefined) => AdapterDependencies;
-/**
- * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
- * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
- *
- * @param adapter - an instance of an Adapter
- * @param dependencies - dependencies that the adapter will need at initialization
- * @param config - configuration variables already processed and validated
- * @returns - the adapter with all transports initialized and aliases map built
- */
-export declare const initializeAdapter: (adapter: Adapter, config: AdapterConfig, dependencies?: Partial<AdapterDependencies> | undefined) => Promise<InitializedAdapter>;
-export {};