wip: adding parsing tests for the network claims

Author: tegefaulkes

src/claims/payloads/claimNetworkAccess.ts

@@ -9,7 +9,7 @@ import * as validationErrors from '../../validation/errors.js';
 import * as utils from '../../utils/index.js';
 
 /**
- * Asserts that a node is apart of a network
+ * Asserts that a node is a part of a network
  */
 interface ClaimNetworkAccess extends Claim {
   typ: 'ClaimNetworkAccess';

src/claims/payloads/claimNetworkAuthority.ts

@@ -7,8 +7,10 @@ import * as validationErrors from '../../validation/errors.js';
 import * as utils from '../../utils/index.js';
 
 /**
- * Asserts that a node is apart of a network
+ * Asserts that a node has the authority of a network.
+ * The issuing nodeId has to be the root keypair for the whole network.
  */
+
 interface ClaimNetworkAuthority extends Claim {
   typ: 'ClaimNetworkAuthority';
   iss: NodeIdEncoded;

tests/claims/payloads/claimNetworkAccess.test.ts

@@ -0,0 +1,56 @@
+import { test, fc } from '@fast-check/jest';
+import * as testsClaimsPayloadsUtils from './utils.js';
+import * as claimsPayloadsClaimNetworkAccess from '#claims/payloads/claimNetworkAccess.js';
+
+describe('claims/payloads/claimNetworkAccess', () => {
+  test.prop([
+    testsClaimsPayloadsUtils.claimNetworkAccessEncodedArb(),
+    fc.noShrink(fc.string()),
+  ])(
+    'parse claim network access',
+    (
+      claimNetworkAccessEncodedCorrect,
+      signedClaimNetworkAccessEncodedIncorrect,
+    ) => {
+      expect(() => {
+        claimsPayloadsClaimNetworkAccess.parseClaimNetworkAccess(
+          claimNetworkAccessEncodedCorrect,
+        );
+      }).not.toThrow();
+      expect(() => {
+        claimsPayloadsClaimNetworkAccess.parseClaimNetworkAccess(
+          signedClaimNetworkAccessEncodedIncorrect,
+        );
+      });
+    },
+  );
+  test.prop([
+    testsClaimsPayloadsUtils.signedClaimEncodedArb(
+      testsClaimsPayloadsUtils.claimNetworkAccessArb(),
+    ),
+    fc.record(
+      {
+        payload: fc.string(),
+        signatures: fc.array(fc.string()),
+      },
+      { noNullPrototype: true },
+    ),
+  ])(
+    'parse signed claim network access',
+    (
+      signedClaimLinkIdentityEncodedCorrect,
+      signedClaimLinkIdentityEncodedIncorrect,
+    ) => {
+      expect(() => {
+        claimsPayloadsClaimNetworkAccess.parseSignedClaimNetworkAccess(
+          signedClaimLinkIdentityEncodedCorrect,
+        );
+      }).not.toThrow();
+      expect(() => {
+        claimsPayloadsClaimNetworkAccess.parseSignedClaimNetworkAccess(
+          signedClaimLinkIdentityEncodedIncorrect,
+        );
+      }).toThrow();
+    },
+  );
+});

tests/claims/payloads/claimNetworkAuthority.test.ts

@@ -0,0 +1,56 @@
+import { test, fc } from '@fast-check/jest';
+import * as testsClaimsPayloadsUtils from './utils.js';
+import * as claimsPayloadsClaimNetworkAuthority from '#claims/payloads/claimNetworkAuthority.js';
+
+describe('claims/payloads/claimNetworkAccess', () => {
+  test.prop([
+    testsClaimsPayloadsUtils.claimNetworkAuthorityEncodedArb(),
+    fc.noShrink(fc.string()),
+  ])(
+    'parse claim network access',
+    (
+      claimNetworkAccessEncodedCorrect,
+      signedClaimNetworkAccessEncodedIncorrect,
+    ) => {
+      expect(() => {
+        claimsPayloadsClaimNetworkAuthority.parseClaimNetworkAuthority(
+          claimNetworkAccessEncodedCorrect,
+        );
+      }).not.toThrow();
+      expect(() => {
+        claimsPayloadsClaimNetworkAuthority.parseClaimNetworkAuthority(
+          signedClaimNetworkAccessEncodedIncorrect,
+        );
+      });
+    },
+  );
+  test.prop([
+    testsClaimsPayloadsUtils.signedClaimEncodedArb(
+      testsClaimsPayloadsUtils.claimNetworkAuthorityArb(),
+    ),
+    fc.record(
+      {
+        payload: fc.string(),
+        signatures: fc.array(fc.string()),
+      },
+      { noNullPrototype: true },
+    ),
+  ])(
+    'parse signed claim network access',
+    (
+      signedClaimLinkIdentityEncodedCorrect,
+      signedClaimLinkIdentityEncodedIncorrect,
+    ) => {
+      expect(() => {
+        claimsPayloadsClaimNetworkAuthority.parseSignedClaimNetworkAuthority(
+          signedClaimLinkIdentityEncodedCorrect,
+        );
+      }).not.toThrow();
+      expect(() => {
+        claimsPayloadsClaimNetworkAuthority.parseSignedClaimNetworkAuthority(
+          signedClaimLinkIdentityEncodedIncorrect,
+        );
+      }).toThrow();
+    },
+  );
+});

tests/claims/payloads/utils.ts

@@ -2,12 +2,17 @@ import type { Claim, SignedClaim } from '#claims/types.js';
 import type {
   ClaimLinkNode,
   ClaimLinkIdentity,
+  ClaimNetworkAccess,
 } from '#claims/payloads/index.js';
+import type { SignedTokenEncoded } from '#tokens/types.js';
+import type { ClaimNetworkAuthority } from '#claims/payloads/claimNetworkAuthority.js';
+import type { NodeIdEncoded } from '#ids/index.js';
 import fc from 'fast-check';
 import * as testsClaimsUtils from '../utils.js';
 import * as testsTokensUtils from '../../tokens/utils.js';
 import * as testsIdsUtils from '../../ids/utils.js';
 import * as claimsUtils from '#claims/utils.js';
+import { NodeId } from '#ids/index.js';
 
 const claimLinkIdentityArb = testsClaimsUtils.claimArb.chain((claim) => {
   return fc
@@ -66,11 +71,83 @@ const signedClaimArb = <P extends Claim>(
 const signedClaimEncodedArb = (payloadArb: fc.Arbitrary<Claim>) =>
   signedClaimArb(payloadArb).map(claimsUtils.generateSignedClaim);
 
+const claimNetworkAuthorityArb = (
+  iss: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  sub: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+) =>
+  fc.noShrink(
+    testsClaimsUtils.claimArb.chain((claim) => {
+      return fc
+        .record(
+          {
+            iss: testsIdsUtils.nodeIdEncodedArb,
+            sub: testsIdsUtils.nodeIdEncodedArb,
+          },
+          { noNullPrototype: true },
+        )
+        .chain((value) => {
+          return fc.constant({
+            typ: 'ClaimNetworkAuthority',
+            ...claim,
+            ...value,
+          });
+        });
+    }) as fc.Arbitrary<ClaimNetworkAuthority>,
+  );
+
+const claimNetworkAuthorityEncodedArb = (
+  iss: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  sub: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+) => claimNetworkAuthorityArb(iss, sub).map(claimsUtils.generateClaim);
+
+const claimNetworkAccessArb = (
+  iss: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  sub: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  network: fc.Arbitrary<string> = fc.string(),
+  signedClaimNetworkAuthorityEncoded: fc.Arbitrary<SignedTokenEncoded> = signedClaimEncodedArb(
+    claimNetworkAuthorityArb(
+      testsIdsUtils.nodeIdEncodedArb,
+      testsIdsUtils.nodeIdEncodedArb,
+    ),
+  ),
+) =>
+  fc.noShrink(
+    testsClaimsUtils.claimArb.chain((claim) => {
+      return fc
+        .record(
+          {
+            iss,
+            sub,
+            network,
+            signedClaimNetworkAuthorityEncoded,
+          },
+          { noNullPrototype: true },
+        )
+        .chain((value) => {
+          return fc.constant({
+            typ: 'ClaimNetworkAccess',
+            ...claim,
+            ...value,
+          });
+        });
+    }) as fc.Arbitrary<ClaimNetworkAccess>,
+  );
+
+const claimNetworkAccessEncodedArb = (
+  iss: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  sub: fc.Arbitrary<NodeIdEncoded> = testsIdsUtils.nodeIdEncodedArb,
+  network: fc.Arbitrary<string> = fc.string(),
+) => claimNetworkAccessArb(iss, sub, network).map(claimsUtils.generateClaim);
+
 export {
   claimLinkIdentityArb,
   claimLinkIdentityEncodedArb,
   claimLinkNodeArb,
   claimLinkNodeEncodedArb,
   signedClaimArb,
   signedClaimEncodedArb,
+  claimNetworkAccessArb,
+  claimNetworkAccessEncodedArb,
+  claimNetworkAuthorityArb,
+  claimNetworkAuthorityEncodedArb,
 };