attempt to add didkit tests

.github/workflows/did_kit.yaml

@@ -0,0 +1,14 @@
+name: did_kit
+
+on: [pull_request, push]
+
+jobs:
+  build:
+    uses: TalaoDAO/AltMe/.github/workflows/flutter_package.yaml@main
+    with:
+      flutter_channel: stable
+      flutter_version: 3.19.6
+      min_coverage: 30
+      working_directory: packages/did_kit
+      dart_sdk: 3.3.4
+      build_runner: false

packages/did_kit/lib/src/did_kit_provider.dart

@@ -1,71 +1,77 @@
-import 'package:didkit/didkit.dart';
+import 'package:did_kit/src/didkit_interface.dart';
+import 'package:did_kit/src/didkit_wrapper.dart';
 
 class DIDKitProvider {
+  DIDKitProvider({DIDKitInterface? didKit})
+      : didKit = didKit ?? DIDKitWrapper();
+
+  final DIDKitInterface didKit;
+
   String getVersion() {
-    return DIDKit.getVersion();
+    return didKit.getVersion();
   }
 
   String generateEd25519Key() {
-    return DIDKit.generateEd25519Key();
+    return didKit.generateEd25519Key();
   }
 
   String keyToDID(String methodName, String key) {
-    return DIDKit.keyToDID(methodName, key);
+    return didKit.keyToDID(methodName, key);
   }
 
   Future<String> keyToVerificationMethod(String methodName, String key) async {
-    return DIDKit.keyToVerificationMethod(methodName, key);
+    return didKit.keyToVerificationMethod(methodName, key);
   }
 
   Future<String> issueCredential(
     String credential,
     String options,
     String key,
   ) async {
-    return DIDKit.issueCredential(credential, options, key);
+    return didKit.issueCredential(credential, options, key);
   }
 
   Future<String> verifyCredential(
     String credential,
     String options,
   ) async {
-    return DIDKit.verifyCredential(credential, options);
+    return didKit.verifyCredential(credential, options);
   }
 
   Future<String> issuePresentation(
     String presentation,
     String options,
     String key,
   ) async {
-    return DIDKit.issuePresentation(presentation, options, key);
+    return didKit.issuePresentation(presentation, options, key);
   }
 
   Future<String> verifyPresentation(
     String presentation,
     String options,
   ) async {
-    return DIDKit.verifyPresentation(presentation, options);
+    return didKit.verifyPresentation(presentation, options);
   }
 
   Future<String> resolveDID(
     String did,
     String inputMetadata,
   ) async {
-    return DIDKit.resolveDID(did, inputMetadata);
+    return didKit.resolveDID(did, inputMetadata);
   }
 
   Future<String> dereferenceDIDURL(
     String didUrl,
     String inputMetadata,
   ) async {
-    return DIDKit.dereferenceDIDURL(didUrl, inputMetadata);
+    return didKit.dereferenceDIDURL(didUrl, inputMetadata);
   }
 
   Future<String> didAuth(
     String did,
     String options,
     String key,
   ) async {
-    return DIDKit.DIDAuth(did, options, key);
+    return didKit.didAuth(did, options, key);
   }
 }

packages/did_kit/lib/src/didkit_interface.dart

@@ -0,0 +1,14 @@
+abstract class DIDKitInterface {
+  String getVersion();
+  String generateEd25519Key();
+  String keyToDID(String methodName, String key);
+  Future<String> keyToVerificationMethod(String methodName, String key);
+  Future<String> issueCredential(String credential, String options, String key);
+  Future<String> verifyCredential(String credential, String options);
+  Future<String> issuePresentation(
+      String presentation, String options, String key);
+  Future<String> verifyPresentation(String presentation, String options);
+  Future<String> resolveDID(String did, String inputMetadata);
+  Future<String> dereferenceDIDURL(String didUrl, String inputMetadata);
+  Future<String> didAuth(String did, String options, String key);
+}

packages/did_kit/lib/src/didkit_wrapper.dart

@@ -0,0 +1,83 @@
+import 'package:did_kit/src/didkit_interface.dart';
+import 'package:didkit/didkit.dart';
+
+class DIDKitWrapper implements DIDKitInterface {
+  @override
+  String getVersion() {
+    return DIDKit.getVersion();
+  }
+
+  @override
+  String generateEd25519Key() {
+    return DIDKit.generateEd25519Key();
+  }
+
+  @override
+  String keyToDID(String methodName, String key) {
+    return DIDKit.keyToDID(methodName, key);
+  }
+
+  @override
+  Future<String> keyToVerificationMethod(String methodName, String key) async {
+    return DIDKit.keyToVerificationMethod(methodName, key);
+  }
+
+  @override
+  Future<String> issueCredential(
+    String credential,
+    String options,
+    String key,
+  ) async {
+    return DIDKit.issueCredential(credential, options, key);
+  }
+
+  @override
+  Future<String> verifyCredential(
+    String credential,
+    String options,
+  ) async {
+    return DIDKit.verifyCredential(credential, options);
+  }
+
+  @override
+  Future<String> issuePresentation(
+    String presentation,
+    String options,
+    String key,
+  ) async {
+    return DIDKit.issuePresentation(presentation, options, key);
+  }
+
+  @override
+  Future<String> verifyPresentation(
+    String presentation,
+    String options,
+  ) async {
+    return DIDKit.verifyPresentation(presentation, options);
+  }
+
+  @override
+  Future<String> resolveDID(
+    String did,
+    String inputMetadata,
+  ) async {
+    return DIDKit.resolveDID(did, inputMetadata);
+  }
+
+  @override
+  Future<String> dereferenceDIDURL(
+    String didUrl,
+    String inputMetadata,
+  ) async {
+    return DIDKit.dereferenceDIDURL(didUrl, inputMetadata);
+  }
+
+  @override
+  Future<String> didAuth(
+    String did,
+    String options,
+    String key,
+  ) async {
+    return DIDKit.DIDAuth(did, options, key);
+  }
+}

packages/did_kit/test/src/did_kit_test.dart → packages/did_kit/test/src/did_kit_provider_test.dart

@@ -2,8 +2,11 @@ import 'dart:convert';
 
 import 'package:did_kit/did_kit.dart';
 import 'package:did_kit/src/did_kit_provider.dart';
-import 'package:didkit/didkit.dart';
+import 'package:did_kit/src/didkit_interface.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+
+class MockDIDKitInterface extends Mock implements DIDKitInterface {}
 
 void main() {
   const didKitVersion = '0.3.0';
@@ -55,55 +58,53 @@ void main() {
     'challenge': 'Uuid().v4()',
   });
 
+  late DIDKitInterface mockDIDKit;
   late DIDKitProvider didKitProvider;
 
-  setUpAll(() {
-    didKitProvider = DIDKitProvider();
+  setUp(() {
+    mockDIDKit = MockDIDKitInterface();
+    didKitProvider = DIDKitProvider(didKit: mockDIDKit);
   });
 
   group('DidKitProvider', () {
     test('verify did kit version is $didKitVersion', () {
+      when(() => mockDIDKit.getVersion()).thenReturn(didKitVersion);
       expect(didKitProvider.getVersion(), didKitVersion);
+      verify(() => mockDIDKit.getVersion()).called(1);
     });
 
-    test('exceptions with empty inputs', () async {
-      expect(
-        () => didKitProvider.issueCredential('', '', ''),
-        throwsA(isInstanceOf<DIDKitException>()),
-      );
-      expect(
-        () => didKitProvider.issuePresentation('', '', ''),
-        throwsA(isInstanceOf<DIDKitException>()),
-      );
-      expect(
-        () => didKitProvider.verifyCredential('', ''),
-        throwsA(isInstanceOf<DIDKitException>()),
-      );
-      expect(
-        () => didKitProvider.verifyPresentation('', ''),
-        throwsA(isInstanceOf<DIDKitException>()),
-      );
-    });
-
-    test('generateEd25519Key method mocked', () {
+    test('generateEd25519Key returns correct key', () {
+      when(() => mockDIDKit.generateEd25519Key()).thenReturn(ed25519Key);
       expect(didKitProvider.generateEd25519Key(), equals(ed25519Key));
+      verify(() => mockDIDKit.generateEd25519Key()).called(1);
     });
 
-    test('keyToDID method mocked', () async {
+    test('keyToDID returns correct DID', () {
+      when(() => mockDIDKit.keyToDID(any(), any())).thenReturn(did);
+
       expect(
         didKitProvider.keyToDID(key, ed25519Key),
         equals(did),
       );
+      verify(() => mockDIDKit.keyToDID(key, ed25519Key)).called(1);
     });
 
-    test('keyToVerificationMethod method mocked', () async {
+    test('keyToVerificationMethod returns correct verification method',
+        () async {
+      when(() => mockDIDKit.keyToVerificationMethod(any(), any()))
+          .thenAnswer((_) async => vm);
+
       expect(
         await didKitProvider.keyToVerificationMethod(key, ed25519Key),
         equals(vm),
       );
+      verify(() => mockDIDKit.keyToVerificationMethod(key, ed25519Key))
+          .called(1);
     });
 
-    test('issueCredential method mocked', () async {
+    test('issueCredential returns correct vc', () async {
+      when(() => mockDIDKit.issueCredential(any(), any(), any()))
+          .thenAnswer((_) async => vc);
       expect(
         await didKitProvider.issueCredential(
           jsonEncode(credential),
@@ -112,16 +113,30 @@ void main() {
         ),
         equals(vc),
       );
+      verify(
+        () => mockDIDKit.issueCredential(
+          jsonEncode(credential),
+          jsonEncode(options),
+          key,
+        ),
+      ).called(1);
     });
 
-    test('verifyCredential method mocked', () async {
+    test('verifyCredential returns correct verifyResult', () async {
+      when(() => mockDIDKit.verifyCredential(any(), any()))
+          .thenAnswer((_) async => verifyResult);
       expect(
         await didKitProvider.verifyCredential(vc, jsonEncode(verifyOptions)),
         equals(verifyResult),
       );
+      verify(
+        () => mockDIDKit.verifyCredential(vc, jsonEncode(verifyOptions)),
+      ).called(1);
     });
 
-    test('issuePresentation method mocked', () async {
+    test('issuePresentation returns correct vc', () async {
+      when(() => mockDIDKit.issuePresentation(any(), any(), any()))
+          .thenAnswer((_) async => vc);
       expect(
         await didKitProvider.issuePresentation(
           jsonEncode(presentation),
@@ -130,37 +145,67 @@ void main() {
         ),
         equals(vc),
       );
+      verify(
+        () => mockDIDKit.issuePresentation(
+          jsonEncode(presentation),
+          jsonEncode(options),
+          key,
+        ),
+      ).called(1);
     });
 
-    test('verifyPresentation method mocked', () async {
+    test('verifyPresentation returns correct verifyResult', () async {
+      when(() => mockDIDKit.verifyPresentation(any(), any()))
+          .thenAnswer((_) async => verifyResult);
       expect(
         await didKitProvider.verifyPresentation(
           vc,
           jsonEncode(verifyOptions),
         ),
         equals(verifyResult),
       );
+      verify(
+        () => mockDIDKit.verifyPresentation(
+          vc,
+          jsonEncode(verifyOptions),
+        ),
+      ).called(1);
     });
 
     test('resolveDID method mocked', () async {
+      when(() => mockDIDKit.resolveDID(any(), any()))
+          .thenAnswer((_) async => '');
       expect(
         await didKitProvider.resolveDID(did, '{}'),
         isInstanceOf<String>(),
       );
+      verify(
+        () => mockDIDKit.resolveDID(did, '{}'),
+      ).called(1);
     });
 
     test('dereferenceDIDURL method mocked', () async {
+      when(() => mockDIDKit.dereferenceDIDURL(any(), any()))
+          .thenAnswer((_) async => '');
       expect(
         await didKitProvider.dereferenceDIDURL(vm, '{}'),
         isInstanceOf<String>(),
       );
+      verify(
+        () => mockDIDKit.dereferenceDIDURL(vm, '{}'),
+      ).called(1);
     });
 
     test('didAuth method mocked', () async {
+      when(() => mockDIDKit.didAuth(any(), any(), any()))
+          .thenAnswer((_) async => '');
       expect(
         await didKitProvider.didAuth(did, proofOptions, key),
         isInstanceOf<String>(),
       );
+      verify(
+        () => mockDIDKit.didAuth(did, proofOptions, key),
+      ).called(1);
     });
   });
 }