resolved merge conflicts

Blocktrust.CredentialWorkflow.Core.Tests/Commands/IssueCredentialsTests/IssueW3cCredentialTests/SignW3cCredentialTests.cs

@@ -89,11 +89,7 @@ public async Task Handle_ValidCredential_ShouldMatchExpectedStructure()
 
         // Verify VC payload structure
         var vc = payload.GetProperty("vc");
-        vc.GetProperty("type").GetString()
-            .Should().Be("VerifiableCredential");
-        vc.GetProperty("@context").GetString()
-            .Should().Be("https://www.w3.org/2018/credentials/v1");
-
+
         // Verify achievement subject
         var subject = vc.GetProperty("credentialSubject");
         subject.GetProperty("id").GetString().Should().Be(SubjectDid);

Blocktrust.CredentialWorkflow.Core.Tests/DIDCommTests/DeletePeerDIDHandlerTests.cs

@@ -0,0 +1,76 @@
+namespace Blocktrust.CredentialWorkflow.Core.Tests.DIDCommTests
+{
+    using Blocktrust.CredentialWorkflow.Core;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.DeletePeerDID;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.SavePeerDID;
+    using Blocktrust.CredentialWorkflow.Core.Commands.Tenant.CreateTenant;
+    using Blocktrust.CredentialWorkflow.Core.Tests;
+    using FluentAssertions;
+    using Microsoft.EntityFrameworkCore;
+    using Xunit;
+
+    public class DeletePeerDIDHandlerTests : TestSetup
+    {
+        private readonly DataContext _dataContext;
+        private readonly DeletePeerDIDHandler _deletePeerDIDHandler;
+        private readonly CreateTenantHandler _createTenantHandler;
+        private readonly SavePeerDIDHandler _savePeerDIDHandler;
+
+        public DeletePeerDIDHandlerTests(TransactionalTestDatabaseFixture fixture) : base(fixture)
+        {
+            _dataContext = fixture.CreateContext();
+            _deletePeerDIDHandler = new DeletePeerDIDHandler(_dataContext);
+            _createTenantHandler = new CreateTenantHandler(_dataContext);
+            _savePeerDIDHandler = new SavePeerDIDHandler(_dataContext);
+        }
+
+        [Fact]
+        public async Task Handle_ExistingPeerDID_ShouldDeleteAndReturnSuccess()
+        {
+            // Arrange
+            // 1. Create a tenant.
+            var tenantResult = await _createTenantHandler.Handle(new CreateTenantRequest("TestTenant"), CancellationToken.None);
+            tenantResult.IsSuccess.Should().BeTrue();
+            var tenantId = tenantResult.Value;
+
+            // 2. Save a PeerDID for that tenant.
+            var saveRequest = new SavePeerDIDRequest(
+                tenantId,
+                "TestPeerDID",
+                "peerDidToDelete");
+            var peerDidResult = await _savePeerDIDHandler.Handle(saveRequest, CancellationToken.None);
+            peerDidResult.IsSuccess.Should().BeTrue();
+            var peerDIDEntityId = peerDidResult.Value.PeerDIDEntityId;
+
+            // Act
+            // 3. Delete the PeerDID.
+            var deleteRequest = new DeletePeerDIDRequest(peerDIDEntityId);
+            var deleteResult = await _deletePeerDIDHandler.Handle(deleteRequest, CancellationToken.None);
+
+            // Assert
+            deleteResult.IsSuccess.Should().BeTrue("the PeerDID exists and should be deleted without errors");
+
+            // Verify the entity has been removed from the database
+            var peerDIDEntity = await _dataContext.PeerDIDEntities
+                .FirstOrDefaultAsync(p => p.PeerDIDEntityId == peerDIDEntityId);
+            peerDIDEntity.Should().BeNull("the PeerDID should have been deleted from the database");
+        }
+
+        [Fact]
+        public async Task Handle_NonExistentPeerDID_ShouldReturnFailure()
+        {
+            // Arrange
+            // Use a random GUID that doesn't exist in the database
+            var invalidPeerDIDId = Guid.NewGuid();
+            var deleteRequest = new DeletePeerDIDRequest(invalidPeerDIDId);
+
+            // Act
+            var deleteResult = await _deletePeerDIDHandler.Handle(deleteRequest, CancellationToken.None);
+
+            // Assert
+            deleteResult.IsFailed.Should().BeTrue("no PeerDID with that ID exists in the database");
+            deleteResult.Errors.Should().ContainSingle()
+                .Which.Message.Should().Be("The PeerDID does not exist in the database. It cannot be deleted.");
+        }
+    }
+}

Blocktrust.CredentialWorkflow.Core.Tests/DIDCommTests/GetPeerDIDSecretsHandlerTests.cs

@@ -0,0 +1,106 @@
+using Blocktrust.Common.Models.DidDoc;
+using Blocktrust.Common.Models.Secrets;
+using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.GetPeerDIDSecrets;
+using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.SavePeerDIDSecrets;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using Xunit;
+
+namespace Blocktrust.CredentialWorkflow.Core.Tests.DIDCommTests
+{
+    public class GetPeerDIDSecretsHandlerTests : TestSetup
+    {
+        private readonly DataContext _dataContext;
+        private readonly GetPeerDIDSecretsHandler _getHandler;
+        private readonly SavePeerDIDSecretsHandler _saveHandler;
+
+        public GetPeerDIDSecretsHandlerTests(TransactionalTestDatabaseFixture fixture) : base(fixture)
+        {
+            _dataContext = fixture.CreateContext();
+            _getHandler = new GetPeerDIDSecretsHandler(_dataContext);
+            _saveHandler = new SavePeerDIDSecretsHandler(_dataContext);
+        }
+
+        [Fact]
+        public async Task Handle_MultipleKids_ShouldReturnAllExistingSecrets()
+        {
+            // Arrange: Create multiple secrets
+            var kid1 = "did:example:123#key1";
+            var kid2 = "did:example:123#key2";
+
+            await CreateSecret(kid1, "{\"kty\":\"EC\",\"crv\":\"secp256k1\",\"x\":\"abc\",\"y\":\"123\"}");
+            await CreateSecret(kid2, "{\"kty\":\"EC\",\"crv\":\"secp256k1\",\"x\":\"def\",\"y\":\"456\"}");
+
+            var request = new GetPeerDIDSecretsRequest(new List<string> { kid1, kid2 });
+
+            // Act
+            var result = await _getHandler.Handle(request, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().HaveCount(2, "both secrets exist in the database");
+
+            // Check presence of kid1 secret
+            var secretForKid1 = result.Value.SingleOrDefault(x => x.Kid == kid1);
+            secretForKid1.Should().NotBeNull();
+            secretForKid1!.VerificationMaterial.Value.Should().Contain("abc");
+
+            // Check presence of kid2 secret
+            var secretForKid2 = result.Value.SingleOrDefault(x => x.Kid == kid2);
+            secretForKid2.Should().NotBeNull();
+            secretForKid2!.VerificationMaterial.Value.Should().Contain("def");
+        }
+
+        [Fact]
+        public async Task Handle_NoMatchingKids_ShouldReturnEmptyList()
+        {
+            // Arrange: No secrets exist in the database for these KIDs
+            var request = new GetPeerDIDSecretsRequest(new List<string> { "invalidKid1", "invalidKid2" });
+
+            // Act
+            var result = await _getHandler.Handle(request, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().NotBeNull();
+            result.Value.Should().BeEmpty("no secrets exist for the provided KIDs");
+        }
+
+        [Fact]
+        public async Task Handle_EmptyKidList_ShouldReturnEmptyList()
+        {
+            // Arrange: Some logic might treat an empty request as a valid scenario 
+            // or potentially an invalid request in your domain. 
+            // Adjust as needed if you throw an error for an empty list.
+            var request = new GetPeerDIDSecretsRequest(new List<string>());
+
+            // Act
+            var result = await _getHandler.Handle(request, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().BeEmpty("no KIDs were requested, so no secrets should be returned");
+        }
+
+        /// <summary>
+        /// Helper method to create a secret in the database via the SavePeerDIDSecretsHandler.
+        /// </summary>
+        private async Task CreateSecret(string kid, string jsonValue)
+        {
+            var secret = new Secret
+            {
+                Type = VerificationMethodType.JsonWebKey2020,
+                VerificationMaterial = new VerificationMaterial
+                {
+                    Format = VerificationMaterialFormat.Jwk,
+                    Value = jsonValue
+                },
+                Kid = kid
+            };
+
+            var request = new SavePeerDIDSecretRequest(kid, secret);
+            var saveResult = await _saveHandler.Handle(request, CancellationToken.None);
+            saveResult.IsSuccess.Should().BeTrue("the secret creation should succeed");
+        }
+    }
+}

Blocktrust.CredentialWorkflow.Core.Tests/DIDCommTests/GetPeerDIDsHandlerTests.cs

@@ -0,0 +1,91 @@
+namespace Blocktrust.CredentialWorkflow.Core.Tests.DIDCommTests
+{
+    using Blocktrust.CredentialWorkflow.Core;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.GetPeerDIDs;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.SavePeerDID;
+    using Blocktrust.CredentialWorkflow.Core.Commands.Tenant.CreateTenant;
+    using Blocktrust.CredentialWorkflow.Core.Tests;
+    using FluentAssertions;
+    using Xunit;
+
+    public class GetPeerDIDsHandlerTests : TestSetup
+    {
+        private readonly DataContext _dataContext;
+        private readonly GetPeerDIDsHandler _getPeerDIDsHandler;
+        private readonly CreateTenantHandler _createTenantHandler;
+        private readonly SavePeerDIDHandler _savePeerDIDHandler;
+
+        public GetPeerDIDsHandlerTests(TransactionalTestDatabaseFixture fixture) : base(fixture)
+        {
+            _dataContext = fixture.CreateContext();
+            _getPeerDIDsHandler = new GetPeerDIDsHandler(_dataContext);
+            _createTenantHandler = new CreateTenantHandler(_dataContext);
+            _savePeerDIDHandler = new SavePeerDIDHandler(_dataContext);
+        }
+
+        [Fact]
+        public async Task Handle_TenantWithMultiplePeerDIDs_ReturnsList()
+        {
+            // Arrange
+            var tenantResult = await _createTenantHandler.Handle(new CreateTenantRequest("TestTenant"), CancellationToken.None);
+            tenantResult.IsSuccess.Should().BeTrue();
+            var tenantId = tenantResult.Value;
+
+            // Create multiple PeerDIDs for the tenant
+            await _savePeerDIDHandler.Handle(
+                new SavePeerDIDRequest(tenantId, "PeerDID1", "peerDid123"), 
+                CancellationToken.None);
+            await _savePeerDIDHandler.Handle(
+                new SavePeerDIDRequest(tenantId, "PeerDID2", "peerDid456"), 
+                CancellationToken.None);
+
+            var getRequest = new GetPeerDIDsRequest(tenantId);
+
+            // Act
+            var result = await _getPeerDIDsHandler.Handle(getRequest, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().HaveCount(2);
+            result.Value.Should().ContainSingle(d => d.Name == "PeerDID1" && d.PeerDID == "peerDid123");
+            result.Value.Should().ContainSingle(d => d.Name == "PeerDID2" && d.PeerDID == "peerDid456");
+        }
+
+        [Fact]
+        public async Task Handle_TenantWithNoPeerDIDs_ReturnsEmptyList()
+        {
+            // Arrange
+            var tenantResult = await _createTenantHandler.Handle(new CreateTenantRequest("EmptyTenant"), CancellationToken.None);
+            tenantResult.IsSuccess.Should().BeTrue();
+            var tenantId = tenantResult.Value;
+
+            // No PeerDIDs created for this tenant
+            var getRequest = new GetPeerDIDsRequest(tenantId);
+
+            // Act
+            var result = await _getPeerDIDsHandler.Handle(getRequest, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue();
+            result.Value.Should().NotBeNull();
+            result.Value.Should().BeEmpty("no PeerDIDs exist for this tenant");
+        }
+
+        [Fact]
+        public async Task Handle_NonExistentTenant_ReturnsEmptyList()
+        {
+            // Arrange
+            // Pass in a random GUID that doesn't match any tenant
+            var invalidTenantId = Guid.NewGuid();
+            var getRequest = new GetPeerDIDsRequest(invalidTenantId);
+
+            // Act
+            var result = await _getPeerDIDsHandler.Handle(getRequest, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue("the handler simply returns an empty list if no PeerDIDs are found");
+            result.Value.Should().NotBeNull();
+            result.Value.Should().BeEmpty();
+        }
+    }
+}

Blocktrust.CredentialWorkflow.Core.Tests/DIDCommTests/GetPeerDidByIdHandlerTests.cs

@@ -0,0 +1,73 @@
+namespace Blocktrust.CredentialWorkflow.Core.Tests.DIDCommTests
+{
+    using Blocktrust.CredentialWorkflow.Core;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.GetPeerDidById;
+    using Blocktrust.CredentialWorkflow.Core.Commands.DIDComm.SavePeerDID;
+    using Blocktrust.CredentialWorkflow.Core.Commands.Tenant.CreateTenant;
+    using Blocktrust.CredentialWorkflow.Core.Tests;
+    using FluentAssertions;
+    using Xunit;
+
+    public class GetPeerDidByIdHandlerTests : TestSetup
+    {
+        private readonly DataContext _dataContext;
+        private readonly GetPeerDidByIdHandler _getPeerDidByIdHandler;
+        private readonly CreateTenantHandler _createTenantHandler;
+        private readonly SavePeerDIDHandler _savePeerDIDHandler;
+
+        public GetPeerDidByIdHandlerTests(TransactionalTestDatabaseFixture fixture) : base(fixture)
+        {
+            _dataContext = fixture.CreateContext();
+            _getPeerDidByIdHandler = new GetPeerDidByIdHandler(_dataContext);
+            _createTenantHandler = new CreateTenantHandler(_dataContext);
+            _savePeerDIDHandler = new SavePeerDIDHandler(_dataContext);
+        }
+
+        [Fact]
+        public async Task Handle_ValidPeerDidEntityId_ShouldReturnPeerDid()
+        {
+            // Arrange
+            // First create a tenant
+            var tenantResult = await _createTenantHandler.Handle(new CreateTenantRequest("TestTenant"), CancellationToken.None);
+            tenantResult.IsSuccess.Should().BeTrue();
+            var tenantId = tenantResult.Value;
+
+            // Then save a PeerDID
+            var peerDidResult = await _savePeerDIDHandler.Handle(
+                new SavePeerDIDRequest(tenantId, "TestPeerDID", "peerDidTest123"),
+                CancellationToken.None);
+
+            peerDidResult.IsSuccess.Should().BeTrue();
+            var savedPeerDid = peerDidResult.Value;
+
+            // Prepare the get request
+            var getRequest = new GetPeerDidByIdRequest(savedPeerDid.PeerDIDEntityId);
+
+            // Act
+            var result = await _getPeerDidByIdHandler.Handle(getRequest, CancellationToken.None);
+
+            // Assert
+            result.IsSuccess.Should().BeTrue("we expect to find an existing PeerDID by the valid ID");
+            result.Value.Should().NotBeNull();
+            result.Value.PeerDIDEntityId.Should().Be(savedPeerDid.PeerDIDEntityId);
+            result.Value.Name.Should().Be("TestPeerDID");
+            result.Value.PeerDID.Should().Be("peerDidTest123");
+        }
+
+        [Fact]
+        public async Task Handle_InvalidPeerDidEntityId_ShouldReturnFailure()
+        {
+            // Arrange
+            var invalidPeerDidId = Guid.NewGuid();
+            var getRequest = new GetPeerDidByIdRequest(invalidPeerDidId);
+
+            // Act
+            var result = await _getPeerDidByIdHandler.Handle(getRequest, CancellationToken.None);
+
+            // Assert
+            result.IsFailed.Should().BeTrue();
+            result.Errors.Should().ContainSingle()
+                .Which.Message.Should().Be($"PeerDID with ID '{invalidPeerDidId}' not found.");
+        }
+    }
+}