fixup! feat: dockerize blockfrost-ryo and enable blockfrost providers in e2e CI tests

Author: ginnun

.github/workflows/continuous-integration-e2e-blockfrost.yaml

@@ -28,6 +28,7 @@ env:
   TEST_CLIENT_STAKE_POOL_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:4000/"}'
   WS_PROVIDER_URL: 'http://localhost:4100/ws'
   # enable Blockfrost backed providers, the rest will use defaults
+  BLOCKFROST_CUSTOM_NETWORK_URL: 'http://localhost:3015'
   ASSET_PROVIDER: 'blockfrost'
   UTXO_PROVIDER: 'blockfrost'
   CHAIN_HISTORY_PROVIDER: 'blockfrost'

packages/cardano-services/src/Program/programs/types.ts

@@ -63,7 +63,8 @@ export enum ProviderServerOptionDescriptions {
   UseBlockfrost = 'Enables Blockfrost cached data DB',
   UseSubmitApi = 'Use cardano-submit-api provider',
   UseTypeormAssetProvider = 'Use the TypeORM Asset Provider (default is db-sync)',
-  UseWebSocketApi = 'Use WebSocket API'
+  UseWebSocketApi = 'Use WebSocket API',
+  BlockfrostCustomNetworkUrl = 'URL for custom hosted blockfrost-ryo'
 }
 
 export type ProviderServerArgs = CommonProgramOptions &

packages/cardano-services/src/cli.ts

@@ -379,6 +379,12 @@ addOptions(withOgmiosOptions(withHandlePolicyIdsOptions(providerServerWithCommon
     'USE_WEB_SOCKET_API',
     (val) => stringOptionToBoolean(val, Programs.ProviderServer, ProviderServerOptionDescriptions.UseWebSocketApi)
   ),
+  newOption(
+    '--blockfrost-custom-network-url <blockfrostCustomNetworkUrl>',
+    ProviderServerOptionDescriptions.BlockfrostCustomNetworkUrl,
+    'BLOCKFROST_CUSTOM_NETWORK_URL',
+    urlValidator(ProviderServerOptionDescriptions.BlockfrostCustomNetworkUrl, true)
+  ),
   ...providerSelectionOptions
 ]).action(async (serviceNames: ServiceNames[], args: ProviderServerArgs) =>
   runServer('Provider server', { args, serviceNames }, () =>

packages/cardano-services/src/util/BlockfrostProvider/BlockfrostClientFactory.ts

@@ -11,8 +11,18 @@ let blockfrostApi: BlockFrostAPI | undefined;
 export const getBlockfrostApi = () => {
   if (blockfrostApi !== undefined) return blockfrostApi;
 
+  // custom hosted instance
+  if (process.env.BLOCKFROST_CUSTOM_BACKEND_URL && process.env.BLOCKFROST_CUSTOM_BACKEND_URL !== '') {
+    blockfrostApi = new BlockFrostAPI({
+      customBackend: process.env.BLOCKFROST_CUSTOM_BACKEND_URL
+    });
+
+    return blockfrostApi;
+  }
+
+  // instance hosted by Blockfrost
   if (process.env.BLOCKFROST_API_KEY === undefined || process.env.BLOCKFROST_API_KEY === '')
-    throw new Error('BLOCKFROST_API_KEY environment variable is required');
+    throw new Error('BLOCKFROST_API_KEY or BLOCKFROST_CUSTOM_BACKEND_URL environment variable is required');
 
   if (process.env.NETWORK === undefined) throw new Error('NETWORK environment variable is required');
 

packages/cardano-services/test/cli.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable sonarjs/no-duplicate-string */
-import { DEFAULT_FUZZY_SEARCH_OPTIONS } from '../src';
+import { DEFAULT_FUZZY_SEARCH_OPTIONS, ProviderServerOptionDescriptions } from '../src';
 import { createLogger } from '@cardano-sdk/util-dev';
 import { fork } from 'child_process';
 import path from 'path';
@@ -1113,6 +1113,22 @@ describe('CLI', () => {
         }));
     });
 
+    describe('blockfrostCustomNetworkUrl', () => {
+      const blockfrostCustomNetworkUrl = 'https://test/';
+
+      testCli('accepts an URL', 'provider', {
+        args: ['--blockfrost-custom-network-url', blockfrostCustomNetworkUrl],
+        env: { BLOCKFROST_CUSTOM_NETWORK_URL: blockfrostCustomNetworkUrl },
+        expectedArgs: { args: { blockfrostCustomNetworkUrl } }
+      });
+
+      testCli('expects an URL', 'provider', {
+        args: ['--blockfrost-custom-network-url', 'invalid'],
+        env: { BLOCKFROST_CUSTOM_NETWORK_URL: 'invalid' },
+        expectedError: `${ProviderServerOptionDescriptions.BlockfrostCustomNetworkUrl} - "invalid" is not an URL`
+      });
+    });
+
     describe('provider implementation selection', () => {
       testCli('check defaults', 'provider', {
         expectedArgs: {

packages/cardano-services/test/util/BlockfrsotProvider/BlockfrostClientFactory.test.ts

@@ -9,7 +9,7 @@ describe('BlockfrostClientFactory', () => {
       delete process.env.NETWORK;
     });
 
-    it('gets correctly, first time', () => {
+    it('gets correctly', () => {
       process.env.BLOCKFROST_API_KEY = 'testing';
       process.env.NETWORK = 'preprod';
       const apiFirst = getBlockfrostApi();
@@ -24,11 +24,24 @@ describe('BlockfrostClientFactory', () => {
       expect(apiSecond).toBeInstanceOf(BlockFrostAPI);
     });
 
-    it('throws if env vars missing', () => {
-      expect(() => getBlockfrostApi()).toThrow(new Error('BLOCKFROST_API_KEY environment variable is required'));
+    it('gets custom backend correctly', () => {
+      process.env.BLOCKFROST_CUSTOM_BACKEND_URL = 'http://localhost';
+      const apiFirst = getBlockfrostApi();
+      expect(apiFirst).toBeDefined();
+      expect(apiFirst).toBeInstanceOf(BlockFrostAPI);
+
+      // deleting proves that we initialize only once
+      delete process.env.BLOCKFROST_CUSTOM_BACKEND_URL;
+      const apiSecond = getBlockfrostApi();
+      expect(apiSecond).toBeDefined();
+      expect(apiSecond).toBeInstanceOf(BlockFrostAPI);
     });
 
     it('throws if env vars missing', () => {
+      expect(() => getBlockfrostApi()).toThrow(
+        new Error('BLOCKFROST_API_KEY or BLOCKFROST_CUSTOM_BACKEND_URL environment variable is required')
+      );
+
       process.env.BLOCKFROST_API_KEY = 'testing';
       expect(() => getBlockfrostApi()).toThrow(new Error('NETWORK environment variable is required'));
     });