@rosen-bridge/utils 0.0.1

package/tests/data/octokit.data.ts

@@ -0,0 +1,121 @@
+import { GithubRelease } from '../../lib/types';
+
+export type PartialReleases = Partial<GithubRelease>[];
+
+export const mainNetPrereleaseRelease = {
+  id: 1,
+  prerelease: true,
+  assets: [
+    {
+      browser_download_url:
+        'https://example.com/contracts-awesomechain-mainnet-7.json',
+      name: 'contracts-awesomechain-mainnet-7.json',
+    } as any,
+    {
+      browser_download_url: 'https://example.com/tokensMap-mainnet-7.json',
+      name: 'tokensMap-mainnet-6.json',
+    } as any,
+  ],
+};
+
+export const mainNetStableRelease = {
+  id: 2,
+  prerelease: false,
+  assets: [
+    {
+      browser_download_url:
+        'https://example.com/contracts-awesomechain-mainnet-6.json',
+      name: 'contracts-awesomechain-mainnet-6.json',
+    } as any,
+    {
+      browser_download_url: 'https://example.com/tokensMap-mainnet-6.json',
+      name: 'tokensMap-mainnet-6.json',
+    } as any,
+  ],
+};
+
+export const testNetPrereleaseRelease = {
+  id: 4,
+  prerelease: true,
+  assets: [
+    {
+      browser_download_url:
+        'https://example.com/contracts-awesomechain-testnet-1.json',
+      name: 'contracts-awesomechain-testnet-1.json',
+    } as any,
+  ],
+};
+
+export const testNetStableRelease = {
+  id: 5,
+  prerelease: false,
+  assets: [
+    {
+      browser_download_url:
+        'https://example.com/contracts-awesomechain-testnet-1.json',
+      name: 'contracts-awesomechain-testnet-1.json',
+    } as any,
+  ],
+};
+
+export const releases = [
+  mainNetPrereleaseRelease,
+  mainNetStableRelease,
+  {
+    id: 3,
+    prerelease: false,
+    assets: [
+      {
+        browser_download_url:
+          'https://example.com/contracts-awesomechain-mainnet-5.json',
+        name: 'contracts-awesomechain-mainnet-5.json',
+      } as any,
+    ],
+  },
+  testNetPrereleaseRelease,
+  testNetStableRelease,
+  {
+    id: 6,
+    prerelease: false,
+    assets: [
+      {
+        browser_download_url:
+          'https://example.com/contracts-awesomechain-mainnet-4.json',
+        name: 'contracts-awesomechain-mainnet-4.json',
+      } as any,
+    ],
+  },
+  {
+    id: 7,
+    prerelease: false,
+    assets: [
+      {
+        browser_download_url:
+          'https://example.com/contracts-awesomechain-mainnet-3.json',
+        name: 'contracts-awesomechain-mainnet-3.json',
+      } as any,
+    ],
+  },
+  {
+    id: 8,
+    prerelease: false,
+    assets: [
+      {
+        browser_download_url:
+          'https://example.com/contracts-awesomechain-mainnet-2.json',
+        name: 'contracts-awesomechain-mainnet-2.json',
+      } as any,
+    ],
+  },
+  {
+    id: 9,
+    prerelease: false,
+    assets: [
+      {
+        browser_download_url:
+          'https://example.com/contracts-awesomechain-mainnet-1.json',
+        name: 'contracts-awesomechain-mainnet-1.json',
+      } as any,
+    ],
+  },
+] satisfies PartialReleases;

package/tests/downloadRosenAssets.spec.ts

@@ -0,0 +1,170 @@
+import download from 'download';
+
+import downloadRosenAssets from '../lib/downloadRosenAssets';
+
+import { RosenAssetsDownloadError } from '../lib';
+
+import {
+  mainNetPrereleaseRelease,
+  mainNetStableRelease,
+} from './data/octokit.data';
+
+import { mockOctokit } from './mocks/octokit.mock';
+
+jest.mock('download');
+
+describe('downloadRosenAssets', () => {
+  beforeEach(() => {
+    mockOctokit();
+  });
+
+  /**
+   * @target `downloadRosenAssets` should download Rosen assets correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - call `downloadRosenAssets` with mainnet chain type and `rosen` download
+   *   directory
+   * @expected
+   * - `download` function should be called with first asset of mainnet stable
+   *    release download url, `rosen` download directory and corresponding
+   *    truncated asset name
+   * - `download` function should be called with second asset of mainnet stable
+   *    release download url, `rosen` download directory and corresponding
+   *    truncated asset name
+   */
+  it('should download Rosen assets correctly', async () => {
+    await downloadRosenAssets('mainnet', 'rosen');
+
+    expect(download).toHaveBeenCalledWith(
+      mainNetStableRelease.assets[0].browser_download_url,
+      'rosen',
+      {
+        filename: 'contracts-awesomechain.json',
+      }
+    );
+    expect(download).toHaveBeenCalledWith(
+      mainNetStableRelease.assets[1].browser_download_url,
+      'rosen',
+      {
+        filename: 'tokensMap.json',
+      }
+    );
+  });
+
+  /**
+   * @target `downloadRosenAssets` should download Rosen assets correctly when
+   * including prereleases
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - call `downloadRosenAssets` with mainnet chain type, `rosen` download
+   *   directory and including prereleases
+   * @expected
+   * - `download` function should be called with first asset of mainnet
+   *    prerelease release download url, `rosen` download directory and
+   *    corresponding truncated asset name
+   * - `download` function should be called with second asset of mainnet
+   *    prerelease release download url, `rosen` download directory and
+   *    corresponding truncated asset name
+   */
+  it('should download Rosen assets correctly when including prereleases', async () => {
+    await downloadRosenAssets('mainnet', 'rosen', true);
+
+    expect(download).toHaveBeenCalledWith(
+      mainNetPrereleaseRelease.assets[0].browser_download_url,
+      'rosen',
+      {
+        filename: 'contracts-awesomechain.json',
+      }
+    );
+    expect(download).toHaveBeenCalledWith(
+      mainNetPrereleaseRelease.assets[1].browser_download_url,
+      'rosen',
+      {
+        filename: 'tokensMap.json',
+      }
+    );
+  });
+
+  /**
+   * @target `downloadRosenAssets` should download Rosen assets and add a suffix
+   * correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - call `downloadRosenAssets` with mainnet chain type, `rosen` download
+   *   directory, including prereleases and a providing a suffix
+   * @expected
+   * - `download` function should be called with first asset of mainnet stable
+   *    release download url, `rosen` download directory and corresponding
+   *    truncated asset name
+   * - `download` function should be called with second asset of mainnet stable
+   *    release download url, `rosen` download directory and corresponding
+   *    truncated asset name
+   */
+  it('should download Rosen assets and add a suffix correctly', async () => {
+    await downloadRosenAssets('mainnet', 'rosen', false, 'suffix');
+
+    expect(download).toHaveBeenCalledWith(
+      mainNetStableRelease.assets[0].browser_download_url,
+      'rosen',
+      {
+        filename: 'contracts-awesomechain-suffix.json',
+      }
+    );
+    expect(download).toHaveBeenCalledWith(
+      mainNetStableRelease.assets[1].browser_download_url,
+      'rosen',
+      {
+        filename: 'tokensMap-suffix.json',
+      }
+    );
+  });
+
+  /**
+   * @target `downloadRosenAssets` should not call `download` function when no
+   * matching release is found
+   * @dependencies
+   * - mocked Octokit
+   * - emptied mocked download package
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - clear download package mock data (so that we can check calls count)
+   * - call `downloadRosenAssets` with "no-release-net" chain type and `rosen`
+   *   download directory
+   * @expected
+   * - `download` function should not get called
+   */
+  it('should not call `download` function when no matching release is found', async () => {
+    jest.mocked(download).mockClear();
+
+    await downloadRosenAssets('no-release-net', 'rosen');
+
+    expect(download).toHaveBeenCalledTimes(0);
+  });
+
+  /**
+   * @target `downloadRosenAssets` should throw an error when an error happens
+   * @dependencies
+   * - mocked Octokit
+   * - mocked download package
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - mock download package to throw an error
+   * - call `downloadRosenAssets` with mainnet chain type and `rosen` download
+   *   directory
+   * @expected
+   * - `download` function should throw `RosenAssetsDownloadError`
+   */
+  it('should throw an error when an error happens', async () => {
+    jest.mocked(download).mockRejectedValue(new Error('Bad!'));
+
+    const downloadPromise = downloadRosenAssets('mainnet', 'rosen');
+
+    await expect(downloadPromise).rejects.toThrow(RosenAssetsDownloadError);
+  });
+});

package/tests/mocks/octokit.mock.ts

@@ -0,0 +1,23 @@
+import { Octokit } from 'octokit';
+
+import { releases } from '../data/octokit.data';
+
+import { DEFAULT_RELEASES_FETCHING_PAGE_SIZE } from '../../lib/constants';
+
+export const mockOctokit = () =>
+  jest.mocked(Octokit).mockImplementation(() => {
+    let page = 0;
+    return {
+      rest: {
+        repos: {
+          listReleases: async () => {
+            const currentIndex = DEFAULT_RELEASES_FETCHING_PAGE_SIZE * page;
+            page += 1;
+            return {
+              data: releases.slice(currentIndex, currentIndex + 5),
+            };
+          },
+        },
+      },
+    } as any;
+  });

package/tests/setup.ts

@@ -0,0 +1 @@
+jest.mock('octokit');

package/tests/utils/github.spec.ts

@@ -0,0 +1,237 @@
+import {
+  fetchReleasesPage,
+  findLatestRelease,
+  hasAssetForChainType,
+  findLastRelease,
+  isStableReleaseForChainType,
+  findLatestStableRelease,
+} from '../../lib/utils/github';
+
+import {
+  mainNetPrereleaseRelease,
+  mainNetStableRelease,
+  releases,
+  testNetPrereleaseRelease,
+  testNetStableRelease,
+} from '../data/octokit.data';
+
+import { mockOctokit } from '../mocks/octokit.mock';
+
+describe('fetchReleasesPage', () => {
+  /**
+   * @target `fetchReleasesPage` should generate releases correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - create an iterator by calling `fetchReleasesPage` generator function
+   * - get results by consuming iterator
+   * @expected
+   * - first result value should have length of 5
+   * - second result value should have length of 4
+   * - third result value should be undefined
+   * - third result done property should be true
+   */
+  it('should generate releases correctly', async () => {
+    mockOctokit();
+
+    const iterator = fetchReleasesPage();
+
+    expect((await iterator.next()).value).toHaveLength(5);
+    expect((await iterator.next()).value).toHaveLength(4);
+    expect((await iterator.next()).value).toEqual(undefined);
+    expect((await iterator.next()).done).toEqual(true);
+  });
+});
+
+describe('findLastRelease', () => {
+  beforeEach(() => {
+    mockOctokit();
+  });
+
+  /**
+   * @target `findLastRelease` should find last release correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - get result by calling `findLastRelease` with a predicate
+   * @expected
+   * - result id should equal mainnet stable release id
+   */
+  it('should find last releases correctly when a predicate is provided', async () => {
+    const foundRelease = await findLastRelease(
+      (release) => release.id === mainNetStableRelease.id
+    );
+
+    expect(foundRelease?.id).toEqual(mainNetStableRelease.id);
+  });
+
+  /**
+   * @target `findLastRelease` should return last release when no predicate is
+   * provided
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - get result by calling `findLastRelease` without a predicate
+   * @expected
+   * - result id should equal the last release id
+   */
+  it('should return last release when no predicate is provided', async () => {
+    const foundRelease = await findLastRelease();
+
+    expect(foundRelease?.id).toEqual(releases[0].id);
+  });
+
+  /**
+   * @target `findLastRelease` should return null when no matching release is
+   * found
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - get result by calling `findLastRelease` with a predicate which does not
+   *   match any release
+   * @expected
+   * - result should be null
+   */
+  it('should return null when no matching release is found', async () => {
+    const foundRelease = await findLastRelease((release) => release.id === 100);
+
+    expect(foundRelease).toEqual(null);
+  });
+});
+
+describe('hasAssetForChainType', () => {
+  /**
+   * @target `hasAssetForChainType` should return `true` if a release has asset
+   * for a specific chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `hasAssetForChainType('mainnet')` with a mainnet
+   *   release
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if a release has asset for a specific chain type', () => {
+    const hasAssetForMainNet = hasAssetForChainType('mainnet')(
+      mainNetPrereleaseRelease as any
+    );
+
+    expect(hasAssetForMainNet).toEqual(true);
+  });
+  /**
+   * @target `hasAssetForChainType` should return `false` if a release does not
+   * have asset for a specific chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `hasAssetForChainType('mainnet')` with a mainnet
+   *   release
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a release does not have asset for a specific chain type', () => {
+    const hasAssetForMainNet = hasAssetForChainType('mainnet')(
+      testNetPrereleaseRelease as any
+    );
+
+    expect(hasAssetForMainNet).toEqual(false);
+  });
+});
+
+describe('isStableReleaseForChainType', () => {
+  /**
+   * @target `isStableReleaseForChainType`
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForChainType('mainnet')` with a
+   *   mainnet stable release
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if a release is stable (that is, non-prerelease) and has asset for a specific chain type', () => {
+    const isMatchingRelease = isStableReleaseForChainType('mainnet')(
+      mainNetStableRelease as any
+    );
+
+    expect(isMatchingRelease).toEqual(true);
+  });
+  /**
+   * @target `isStableReleaseForChainType` should return `false` if a release
+   * has asset for a specific chain type but is prerelease
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForChainType('mainnet')` with a
+   *   mainnet prerelease release
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a release has asset for a specific chain type but is prerelease', () => {
+    const isMatchingRelease = isStableReleaseForChainType('mainnet')(
+      mainNetPrereleaseRelease as any
+    );
+
+    expect(isMatchingRelease).toEqual(false);
+  });
+  /**
+   * @target `isStableReleaseForChainType` should return `false` if a release is
+   * stable (that is, non-prerelease) but does not have asset for a specific
+   * chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForChainType('mainnet')` with a
+   *   testnet stable release
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a release is stable (that is, non-prerelease) but does not have asset for a specific chain type', () => {
+    const isMatchingRelease = isStableReleaseForChainType('mainnet')(
+      testNetStableRelease as any
+    );
+
+    expect(isMatchingRelease).toEqual(false);
+  });
+});
+
+describe('findLatestRelease', () => {
+  /**
+   * @target `findLatestRelease` should find latest release for a chain type
+   * correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - get result by calling `findLatestRelease` with mainnet chain type
+   * @expected
+   * - result id should equal mainnet prerelease release id
+   */
+  it('should find latest release for a chain type correctly', async () => {
+    mockOctokit();
+
+    const latestMainNet = await findLatestRelease('mainnet');
+
+    expect(latestMainNet?.id).toEqual(mainNetPrereleaseRelease.id);
+  });
+});
+
+describe('findLatestStableRelease', () => {
+  /**
+   * @target `findLatestStableRelease` should find latest stable (that is,
+   * non-prerelease) release for a chain type correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return 9 releases
+   * - get result by calling `findLatestStableRelease` with mainnet chain type
+   * @expected
+   * - result id should equal mainnet stable release id
+   */
+  it('should find latest stable (that is, non-prerelease) release for a chain type correctly', async () => {
+    mockOctokit();
+
+    const latestMainNet = await findLatestStableRelease('mainnet');
+
+    expect(latestMainNet?.id).toEqual(mainNetStableRelease.id);
+  });
+});

package/tests/utils/rosen.spec.ts

@@ -0,0 +1,145 @@
+import { isValidAssetName, truncateAssetName } from '../../lib/utils/rosen';
+
+describe('isValidAssetName', () => {
+  /**
+   * @target
+   * `isValidAssetName` should return `true` if an address file name matches a
+   * chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidAssetName('mainnet')` with a mainnet
+   *   address file name
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if an address file name matches a chain type', () => {
+    const matchAssetName = 'contracts-awesomechain-mainnet-1.json';
+    const isMatchingAssetName = isValidAssetName('mainnet')(matchAssetName);
+
+    expect(isMatchingAssetName).toEqual(true);
+  });
+
+  /**
+   * @target
+   * `isValidAssetName` should return `false` if an address file name does not
+   * match a chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidAssetName('mainnet')` with a testnet
+   *   address file name
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if an address file name does not match a chain type', () => {
+    const notMatchAssetName = 'contracts-awesomechain-testnet-1.json';
+    const isMatchingAssetName = isValidAssetName('mainnet')(notMatchAssetName);
+
+    expect(isMatchingAssetName).toEqual(false);
+  });
+
+  /**
+   * @target
+   * `isValidAssetName` should return `true` if a tokensMap file name matches a
+   * chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidAssetName('mainnet')` with a mainnet
+   *   tokensMap file name
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if a tokensMap file name matches a chain type', () => {
+    const matchAssetName = 'tokensMap-mainnet-1.json';
+    const isMatchingAssetName = isValidAssetName('mainnet')(matchAssetName);
+
+    expect(isMatchingAssetName).toEqual(true);
+  });
+
+  /**
+   * @target
+   * `isValidAssetName` should return `false` if a tokensMap file name does not
+   * match a chain type
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidAssetName('mainnet')` with a testnet
+   *   tokensMap file name
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a tokensMap file name does not match a chain type', () => {
+    const notMatchAssetName = 'tokensMap-testnet-1.json';
+    const isMatchingAssetName = isValidAssetName('mainnet')(notMatchAssetName);
+
+    expect(isMatchingAssetName).toEqual(false);
+  });
+
+  /**
+   * @target
+   * `isValidAssetName` should return false when asset name doesn't match Rosen
+   * format assets
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidAssetName('mainnet')` with an invalid asset
+   *   file name
+   * @expected
+   * - result should be false
+   */
+  it("should return false when asset name doesn't match Rosen format assets", () => {
+    const invalidAssetName = 'invalid-name.json';
+    const isMatchingAssetName = isValidAssetName('mainnet')(invalidAssetName);
+
+    expect(isMatchingAssetName).toEqual(false);
+  });
+});
+
+describe('truncateAssetName', () => {
+  /**
+   * @target
+   * `truncateAssetName` should truncate contract file names correctly
+   * @dependencies
+   * @scenario
+   * - get result by calling `truncateAssetName` with a contract file name
+   * @expected
+   * - result should be truncated name
+   */
+  it('should truncate contract file names correctly', () => {
+    const addressAssetName = 'contracts-awesomechain-mainnet-1.json';
+    const truncatedName = truncateAssetName(addressAssetName);
+
+    expect(truncatedName).toEqual('contracts-awesomechain.json');
+  });
+
+  /**
+   * @target
+   * `truncateAssetName` should truncate tokensMap file names correctly
+   * @dependencies
+   * @scenario
+   * - get result by calling `truncateAssetName` with a tokensMap file name
+   * @expected
+   * - result should be truncated name
+   */
+  it('should truncate contract file names correctly', () => {
+    const tokensMapAssetName = 'tokensMap-mainnet-1.json';
+    const truncatedName = truncateAssetName(tokensMapAssetName);
+
+    expect(truncatedName).toEqual('tokensMap.json');
+  });
+
+  /**
+   * @target
+   * `truncateAssetName` should truncate asset name and append suffix correctly
+   * @dependencies
+   * @scenario
+   * - get result by calling `truncateAssetName` with an asset name
+   * @expected
+   * - result should be truncated name with suffix
+   */
+  it('should truncate asset name and append suffix correctly', () => {
+    const assetName = 'contracts-awesomechain-mainnet-1.json';
+    const truncatedNameWithSuffix = truncateAssetName(assetName, 'suffix');
+
+    expect(truncatedNameWithSuffix).toEqual(
+      'contracts-awesomechain-suffix.json'
+    );
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["tests"]
+}