@rosen-bridge/utils 0.1.0 → 0.2.0

package/tests/utils/github.spec.ts

@@ -4,27 +4,35 @@ import {
   hasAssetForChainType,
   findLastRelease,
   isStableReleaseForChainType,
+  isStableReleaseForRegexTagType,
   findLatestStableRelease,
   getReleaseByTag,
+  hasMatchedTagPrefix,
+  findLatestStableReleaseByPrefixTag,
+  findLatestReleaseByPrefixTag,
 } from '../../lib/utils/github';
 
 import {
   mainNetPrereleaseRelease,
   mainNetStableRelease,
-  releases,
+  contractReleases,
   testNetPrereleaseRelease,
   testNetStableRelease,
+  tssTag2,
+  tssTag3PreRelease,
+  tssTag1,
+  tssReleases,
 } from '../data/octokit.data';
 
 import { mockOctokit, mockOctokitGetReleaseByTag } from '../mocks/octokit.mock';
 
 describe('fetchReleasesPage', () => {
   /**
-   * @target `fetchReleasesPage` should generate releases correctly
+   * @target `fetchReleasesPage` should generate contractReleases correctly
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - create an iterator by calling `fetchReleasesPage` generator function
    * - get results by consuming iterator
    * @expected
@@ -34,9 +42,9 @@ describe('fetchReleasesPage', () => {
    * - third result done property should be true
    */
   it('should generate releases correctly', async () => {
-    mockOctokit();
+    mockOctokit(contractReleases);
 
-    const iterator = fetchReleasesPage();
+    const iterator = fetchReleasesPage('contract');
 
     expect((await iterator.next()).value).toHaveLength(5);
     expect((await iterator.next()).value).toHaveLength(4);
@@ -47,7 +55,7 @@ describe('fetchReleasesPage', () => {
 
 describe('findLastRelease', () => {
   beforeEach(() => {
-    mockOctokit();
+    mockOctokit(contractReleases);
   });
 
   /**
@@ -55,13 +63,14 @@ describe('findLastRelease', () => {
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - 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 () => {
+  it('should find last release correctly when a predicate is provided', async () => {
     const foundRelease = await findLastRelease(
+      'contract',
       (release) => release.id === mainNetStableRelease.id
     );
 
@@ -74,15 +83,15 @@ describe('findLastRelease', () => {
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - 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();
+    const foundRelease = await findLastRelease('contract');
 
-    expect(foundRelease?.id).toEqual(releases[0].id);
+    expect(foundRelease?.id).toEqual(contractReleases[0].id);
   });
 
   /**
@@ -91,14 +100,17 @@ describe('findLastRelease', () => {
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - 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);
+    const foundRelease = await findLastRelease(
+      'contract',
+      (release) => release.id === 100
+    );
 
     expect(foundRelease).toEqual(null);
   });
@@ -115,9 +127,9 @@ describe('getReleaseByTag', () => {
    * - the release should be the expected one
    */
   it('should get release by tag', async () => {
-    mockOctokitGetReleaseByTag();
+    mockOctokitGetReleaseByTag(contractReleases);
 
-    const release = await getReleaseByTag('3');
+    const release = await getReleaseByTag('contract', '3');
 
     expect(release.id).toEqual(3);
   });
@@ -214,6 +226,98 @@ describe('isStableReleaseForChainType', () => {
   });
 });
 
+describe('hasMatchedTagPrefix', () => {
+  /**
+   * @target `hasMatchedTagPrefix` should return `true` if a release
+   * has asset using a prefix tag
+   * @dependencies
+   * @scenario
+   * - get a result by calling `hasMatchedTagPrefix('tss-api-')` with a
+   *   tss-api prerelease release
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if a release has asset using a prefix tag', () => {
+    const isMatchingRelease = hasMatchedTagPrefix('tss-api-')(
+      tssTag3PreRelease as any
+    );
+
+    expect(isMatchingRelease).toEqual(true);
+  });
+
+  /**
+   * @target `hasMatchedTagPrefix` should return `false`,
+   *  if doesn't exist matched tag prefix
+   * @dependencies
+   * @scenario
+   * - get result by calling `hasMatchedTagPrefix('no-tag')` with a
+   *   tss-api stable release
+   * @expected
+   * - result should be false
+   */
+  it("should return `false` if doesn't exist matched tag prefix", () => {
+    const isMatchingRelease = hasMatchedTagPrefix('no-tag')(tssTag1 as any);
+
+    expect(isMatchingRelease).toEqual(false);
+  });
+});
+
+describe('isStableReleaseForRegexTagType', () => {
+  /**
+   * @target `isStableReleaseForRegexTagType` should return `true` if a release
+   * is stable and has asset using a prefix tag
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForRegexTagType('tss-api-')` with a
+   *   tss-api stable release
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if a release is stable and has asset using a prefix tag', () => {
+    const isMatchingRelease = isStableReleaseForRegexTagType('tss-api-')(
+      tssTag2 as any
+    );
+
+    expect(isMatchingRelease).toEqual(true);
+  });
+
+  /**
+   * @target `isStableReleaseForRegexTagType` should return `false` if a release
+   * has asset for a prefix tag but is prerelease
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForRegexTagType('tss-api')` with a
+   *   tss-api prerelease release
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a release has asset for a prefix tag but is prerelease', () => {
+    const isMatchingRelease = isStableReleaseForRegexTagType('tss-api')(
+      tssTag3PreRelease as any
+    );
+
+    expect(isMatchingRelease).toEqual(false);
+  });
+
+  /**
+   * @target `isStableReleaseForRegexTagType` should return `false` if a release is
+   * stable but does not have a release with prefix tag
+   * @dependencies
+   * @scenario
+   * - get result by calling `isStableReleaseForRegexTagType('no-tag')` with a
+   *   tss stable release tag
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if a release is stable but does not have prefix tag', () => {
+    const isMatchingRelease = isStableReleaseForRegexTagType('no-tag')(
+      tssTag1 as any
+    );
+
+    expect(isMatchingRelease).toEqual(false);
+  });
+});
+
 describe('findLatestRelease', () => {
   /**
    * @target `findLatestRelease` should find latest release for a chain type
@@ -221,15 +325,15 @@ describe('findLatestRelease', () => {
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - 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();
+    mockOctokit(contractReleases);
 
-    const latestMainNet = await findLatestRelease('mainnet');
+    const latestMainNet = await findLatestRelease('contract', 'mainnet');
 
     expect(latestMainNet?.id).toEqual(mainNetPrereleaseRelease.id);
   });
@@ -242,16 +346,64 @@ describe('findLatestStableRelease', () => {
    * @dependencies
    * - mocked Octokit
    * @scenario
-   * - mock Octokit `listReleases` to return 9 releases
+   * - mock Octokit `listReleases` to return 9 contractReleases
    * - 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();
+    mockOctokit(contractReleases);
 
-    const latestMainNet = await findLatestStableRelease('mainnet');
+    const latestMainNet = await findLatestStableRelease('contract', 'mainnet');
 
     expect(latestMainNet?.id).toEqual(mainNetStableRelease.id);
   });
 });
+
+describe('findLatestReleaseByPrefixTag', () => {
+  /**
+   * @target `findLatestReleaseByPrefixTag` should find latest release with
+   * a prefix tag correctly
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return tssReleases
+   * - get result by calling `findLatestReleaseByPrefixTag` with tss-api prefix tag
+   * @expected
+   * - result id should equal tssTag3PreRelease release id
+   */
+  it('should find latest release for tss-api prefix tag correctly', async () => {
+    mockOctokit(tssReleases);
+
+    const latestTss = await findLatestReleaseByPrefixTag(
+      'sign-protocols',
+      'tss-api'
+    );
+
+    expect(latestTss?.id).toEqual(tssTag3PreRelease.id);
+  });
+});
+
+describe('findLatestStableReleaseByPrefixTag', () => {
+  /**
+   * @target `findLatestStableReleaseByPrefixTag` should find latest stable (that is,
+   * non-prerelease) release with a prefix tag
+   * @dependencies
+   * - mocked Octokit
+   * @scenario
+   * - mock Octokit `listReleases` to return tssReleases
+   * - get result by calling `findLatestStableReleaseByPrefixTag` with tss-api prefix tag
+   * @expected
+   * - result id should equal tssTag2 stable release id
+   */
+  it('should find latest stable (that is, non-prerelease) release for tss-api prefix tag correctly', async () => {
+    mockOctokit(tssReleases);
+
+    const latestTss = await findLatestStableReleaseByPrefixTag(
+      'sign-protocols',
+      'tss-api'
+    );
+
+    expect(latestTss?.id).toEqual(tssTag2.id);
+  });
+});

package/tests/utils/rosen.spec.ts

@@ -1,4 +1,8 @@
-import { isValidAssetName, truncateAssetName } from '../../lib/utils/rosen';
+import {
+  isValidAssetName,
+  isValidOS,
+  truncateAssetName,
+} from '../../lib/utils/rosen';
 
 describe('isValidAssetName', () => {
   /**
@@ -143,3 +147,37 @@ describe('truncateAssetName', () => {
     );
   });
 });
+
+describe('isValidOS', () => {
+  /**
+   * @target
+   * `isValidOS` should return `true` if an asset file name matches an OS name
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidOS('linux')` with a linux tss-api file name
+   * @expected
+   * - result should be true
+   */
+  it('should return `true` if an os name matches a tss-api asset file', () => {
+    const matchOSName = 'rosenTss-linux-4.0.0.zip';
+    const isMatchingAssetName = isValidOS('linux')(matchOSName);
+
+    expect(isMatchingAssetName).toEqual(true);
+  });
+
+  /**
+   * @target
+   * `isValidOS` should return `false` if an asset file name does not match an OS name
+   * @dependencies
+   * @scenario
+   * - get result by calling `isValidOS('linux')` with a linux tss-api file name
+   * @expected
+   * - result should be false
+   */
+  it('should return `false` if an os name does not match a tss-api asset file', () => {
+    const notMatchOSName = 'rosenTss-pi-4.0.0.zip';
+    const isMatchingAssetName = isValidOS('linux')(notMatchOSName);
+
+    expect(isMatchingAssetName).toEqual(false);
+  });
+});