add unit tests

src/iden3comm/handlers/discovery-protocol.ts

@@ -5,20 +5,86 @@ import { BasicMessage, IPackageManager } from '../types';
 import * as uuid from 'uuid';
 import {
   DiscoverFeatureDiscloseMessage,
+  DiscoverFeatureDisclosure,
   DiscoverFeatureQueriesMessage,
   DiscoveryProtocolFeatureType
 } from '../types/protocol/discovery-protocol';
 import { AbstractMessageHandler, IProtocolMessageHandler } from './message-handler';
 
 /**
- * RefreshHandlerOptions contains options for RefreshHandler
+ * DiscoveryProtocolOptions contains options for DiscoveryProtocolHandler
  * @public
- * @interface   RefreshHandlerOptions
+ * @interface   DiscoveryProtocolOptions
  */
 export interface DiscoveryProtocolOptions {
   packageManager: IPackageManager;
 }
 
+/**
+ * @beta
+ * createDiscoveryFeatureQueryMessage is a function to create didcomm protocol discovery-feature query message
+ * @param opts - discovery-feature query options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+export function createDiscoveryFeatureQueryMessage(opts?: {
+  featureTypes?: (DiscoveryProtocolFeatureType | string)[];
+  from?: string;
+  to?: string;
+  created_time?: number;
+  expires_time?: number;
+}): DiscoverFeatureQueriesMessage {
+  const uuidv4 = uuid.v4();
+  return {
+    id: uuidv4,
+    thid: uuidv4,
+    type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE,
+    body: {
+      queries: opts?.featureTypes?.length
+        ? opts.featureTypes.map((featureType) => ({ 'feature-type': featureType }))
+        : [
+            {
+              'feature-type': DiscoveryProtocolFeatureType.Accept
+            }
+          ]
+    },
+    from: opts?.from,
+    to: opts?.to,
+    created_time: opts?.created_time,
+    expires_time: opts?.expires_time
+  };
+}
+
+/**
+ * @beta
+ * createDiscoveryFeatureDiscloseMessage is a function to create didcomm protocol discovery-feature disclose message
+ * @param {DiscoverFeatureDisclosure[]} disclosures - array of disclosures
+ * @param opts - basic message options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+export function createDiscoveryFeatureDiscloseMessage(
+  disclosures: DiscoverFeatureDisclosure[],
+  opts?: {
+    from?: string;
+    to?: string;
+    created_time?: number;
+    expires_time?: number;
+  }
+): DiscoverFeatureDiscloseMessage {
+  const uuidv4 = uuid.v4();
+  return {
+    id: uuidv4,
+    thid: uuidv4,
+    type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE,
+    body: {
+      disclosures
+    },
+    from: opts?.from,
+    to: opts?.to,
+    created_time: opts?.created_time,
+    expires_time: opts?.expires_time
+  };
+}
+
 /**
  * Interface to work with discovery protocol handler
  *
@@ -87,19 +153,15 @@ export class DiscoveryProtocolHandler
       throw new Error('Invalid feature-type. Only "accept" is supported');
     }
 
-    const accept = this._options.packageManager.getSupportedProfiles();
-
-    return Promise.resolve({
-      id: uuid.v4(),
-      type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE,
-      body: {
-        disclosures: [
-          {
-            'feature-type': DiscoveryProtocolFeatureType.Accept,
-            accept
-          }
-        ]
+    const disclosures = [
+      {
+        'feature-type': DiscoveryProtocolFeatureType.Accept,
+        accept: this._options.packageManager.getSupportedProfiles()
       }
-    });
+    ];
+
+    return Promise.resolve(
+      createDiscoveryFeatureDiscloseMessage(disclosures, { to: message.from, from: message.to })
+    );
   }
 }

src/iden3comm/handlers/index.ts

@@ -7,3 +7,4 @@ export * from './common';
 export * from './credential-proposal';
 export * from './message-handler';
 export * from './payment';
+export * from './discovery-protocol';

src/iden3comm/types/protocol/discovery-protocol.ts

@@ -27,8 +27,11 @@ export type DiscoverFeatureDiscloseMessage = BasicMessage & {
 
 /** @beta DiscoverFeatureDiscloseBody is struct the represents discover feature disclose body */
 export type DiscoverFeatureDiscloseBody = {
-  disclosures: {
-    'feature-type': DiscoveryProtocolFeatureType | string;
-    accept: Array<string>;
-  }[];
+  disclosures: DiscoverFeatureDisclosure[];
+};
+
+/** @beta DiscoverFeatureDisclosure is struct the represents discover feature disclosure */
+export type DiscoverFeatureDisclosure = {
+  'feature-type': DiscoveryProtocolFeatureType | string;
+  accept: Array<string>;
 };

tests/handlers/discover-protocol.test.ts

@@ -0,0 +1,112 @@
+import { expect } from 'chai';
+import {
+  DiscoverFeatureQueriesMessage,
+  IPackageManager,
+  JWSPacker,
+  KMS,
+  PackageManager,
+  PlainPacker,
+  ZKPPacker
+} from '../../src';
+import {
+  DiscoveryProtocolHandler,
+  createDiscoveryFeatureQueryMessage
+} from '../../src/iden3comm/handlers/discovery-protocol';
+import { DIDResolutionResult } from 'did-resolver';
+
+describe('discovery-protocol', () => {
+  let discoveryFeatureQueryMessage: DiscoverFeatureQueriesMessage;
+  let jwsPacker: JWSPacker;
+  let zkpPacker: ZKPPacker;
+  let plainPacker: PlainPacker;
+
+  beforeEach(async () => {
+    jwsPacker = new JWSPacker(new KMS(), {
+      resolve: () => Promise.resolve({ didDocument: {} } as DIDResolutionResult)
+    });
+
+    zkpPacker = new ZKPPacker(new Map(), new Map());
+    plainPacker = new PlainPacker();
+    discoveryFeatureQueryMessage = createDiscoveryFeatureQueryMessage();
+  });
+
+  it('plain message accept disclosures', async () => {
+    const packageManager: IPackageManager = new PackageManager();
+    packageManager.registerPackers([plainPacker]);
+    const discoveryProtocolHandler = new DiscoveryProtocolHandler({
+      packageManager
+    });
+
+    const {
+      body: { disclosures }
+    } = await discoveryProtocolHandler.handleDiscoveryQuery(discoveryFeatureQueryMessage);
+    expect(disclosures.length).to.be.eq(1);
+    expect(disclosures[0]['feature-type']).to.be.eq('accept');
+    expect(disclosures[0].accept.length).to.be.eq(1);
+    expect(disclosures[0].accept[0]).to.be.eq('env=application/iden3comm-plain-json');
+  });
+
+  it('jws and plain message accept disclosures', async () => {
+    const packageManager: IPackageManager = new PackageManager();
+    packageManager.registerPackers([new PlainPacker(), plainPacker, jwsPacker]);
+
+    const discoveryProtocolHandler = new DiscoveryProtocolHandler({
+      packageManager
+    });
+
+    const {
+      body: { disclosures }
+    } = await discoveryProtocolHandler.handleDiscoveryQuery(discoveryFeatureQueryMessage);
+    expect(disclosures.length).to.be.eq(1);
+
+    expect(disclosures[0].accept.length).to.be.eq(2);
+    expect(disclosures[0]['feature-type']).to.be.eq('accept');
+    expect(disclosures[0].accept).to.include('env=application/iden3comm-plain-json');
+    expect(disclosures[0].accept).to.include(
+      'env=application/iden3comm-signed-json&alg=ES256K,ES256K-R'
+    );
+  });
+
+  it('zkp and plain message accept disclosures', async () => {
+    const packageManager: IPackageManager = new PackageManager();
+    packageManager.registerPackers([new PlainPacker(), plainPacker, zkpPacker]);
+    const discoveryProtocolHandler = new DiscoveryProtocolHandler({
+      packageManager
+    });
+
+    const {
+      body: { disclosures }
+    } = await discoveryProtocolHandler.handleDiscoveryQuery(discoveryFeatureQueryMessage);
+    expect(disclosures.length).to.be.eq(1);
+
+    expect(disclosures[0].accept.length).to.be.eq(2);
+    expect(disclosures[0]['feature-type']).to.be.eq('accept');
+    expect(disclosures[0].accept).to.include('env=application/iden3comm-plain-json');
+    expect(disclosures[0].accept).to.include(
+      'env=application/iden3-zkp-json&alg=groth16&circuitIds=authV2'
+    );
+  });
+
+  it('zkp, jws and plain message accept disclosures', async () => {
+    const packageManager: IPackageManager = new PackageManager();
+    packageManager.registerPackers([new PlainPacker(), plainPacker, zkpPacker, jwsPacker]);
+    const discoveryProtocolHandler = new DiscoveryProtocolHandler({
+      packageManager
+    });
+
+    const {
+      body: { disclosures }
+    } = await discoveryProtocolHandler.handleDiscoveryQuery(discoveryFeatureQueryMessage);
+    expect(disclosures.length).to.be.eq(1);
+
+    expect(disclosures[0].accept.length).to.be.eq(3);
+    expect(disclosures[0]['feature-type']).to.be.eq('accept');
+    expect(disclosures[0].accept).to.include('env=application/iden3comm-plain-json');
+    expect(disclosures[0].accept).to.include(
+      'env=application/iden3-zkp-json&alg=groth16&circuitIds=authV2'
+    );
+    expect(disclosures[0].accept).to.include(
+      'env=application/iden3comm-signed-json&alg=ES256K,ES256K-R'
+    );
+  });
+});