Consumer Api: Decompose Relationships during Identity Deletion (#940)

* feat: Add relationship audit log reason for decomposition due to identity deletion

* feat: Make relationship participants writable internally and write skeleton decomposition method

* chore: Rename DeleteRelationshipsOfIdentityCommand to DecomposeRelationshipsOfIdentityCommand

* feat: Make CreatedBy property in Relationship Audit Log nullable

* chore: Clear cache when deleting Relationships and Relationship Templates

* fix: Include every properties when querying for relationships

* feat: Add method to decompose relationship due to identity deletion

* feat: Add methods and command for anonymizing a relationship

* feat: Use the decomposition and anonymization commands

* chore: Rename tests, methods and variables, resolve pr comments

* chore: Merge Decomposition and Anonymization into one command

* chore: Remove cache clearing from repositories

* chore: Write unit tests for Relationship Decomposition due to Identity Deletion and Anonymization

* chore: Include Anonymization method in the Decomposition, remove unnecessary tests

* chore: Add unit test for anonymization#

* fix: Fix formatting

---------

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Author: MH321Productions

Modules/Relationships/src/Relationships.Application/Identities/IdentityDeleter.Tests.cs

@@ -1,5 +1,5 @@
 using Backbone.BuildingBlocks.Application.Identities;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.DeleteRelationshipsOfIdentity;
+using Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.AnonymizeRelationshipTemplateAllocationsAllocatedByIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.DeleteRelationshipTemplatesOfIdentity;
 using FakeItEasy;
@@ -23,7 +23,7 @@ public async Task Deleter_calls_correct_command()
 
         // Assert
         A.CallTo(() => mockMediator.Send(
-            A<DeleteRelationshipsOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),
+            A<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),
             A<CancellationToken>._)).MustHaveHappenedOnceExactly();
         A.CallTo(() => mockMediator.Send(
             A<DeleteRelationshipTemplatesOfIdentityCommand>.That.Matches(i => i.IdentityAddress == identityAddress),

Modules/Relationships/src/Relationships.Application/Identities/IdentityDeleter.cs

@@ -1,6 +1,6 @@
 using Backbone.BuildingBlocks.Application.Identities;
 using Backbone.DevelopmentKit.Identity.ValueObjects;
-using Backbone.Modules.Relationships.Application.Relationships.Commands.DeleteRelationshipsOfIdentity;
+using Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.AnonymizeRelationshipTemplateAllocationsAllocatedByIdentity;
 using Backbone.Modules.Relationships.Application.RelationshipTemplates.Commands.DeleteRelationshipTemplatesOfIdentity;
 using MediatR;
@@ -20,7 +20,7 @@ public IdentityDeleter(IMediator mediator, IDeletionProcessLogger deletionProces
 
     public async Task Delete(IdentityAddress identityAddress)
     {
-        await _mediator.Send(new DeleteRelationshipsOfIdentityCommand(identityAddress));
+        await _mediator.Send(new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "Relationships");
         await _mediator.Send(new DeleteRelationshipTemplatesOfIdentityCommand(identityAddress));
         await _deletionProcessLogger.LogDeletion(identityAddress, "RelationshipTemplates");

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/DecomposeAndAnonymizeRelationshipsOfIdentityCommand.cs

@@ -0,0 +1,13 @@
+using MediatR;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class DecomposeAndAnonymizeRelationshipsOfIdentityCommand : IRequest
+{
+    public DecomposeAndAnonymizeRelationshipsOfIdentityCommand(string identityAddress)
+    {
+        IdentityAddress = identityAddress;
+    }
+
+    public string IdentityAddress { get; set; }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Handler.Tests.cs

@@ -0,0 +1,26 @@
+using Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
+using Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+using FakeItEasy;
+using Microsoft.Extensions.Options;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class HandlerTests : AbstractTestsBase
+{
+    [Fact]
+    public async Task Command_calls_update_on_repository()
+    {
+        // Arrange
+        var mockRelationshipTemplatesRepository = A.Fake<IRelationshipsRepository>();
+        var mockOptions = A.Dummy<IOptions<ApplicationOptions>>();
+
+        var handler = new Handler(mockRelationshipTemplatesRepository, mockOptions);
+        var request = new DecomposeAndAnonymizeRelationshipsOfIdentityCommand(CreateRandomIdentityAddress());
+
+        // Act
+        await handler.Handle(request, CancellationToken.None);
+
+        // Assert
+        A.CallTo(() => mockRelationshipTemplatesRepository.Update(A<IEnumerable<Relationship>>._)).MustHaveHappened();
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Handler.cs

@@ -0,0 +1,28 @@
+using Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
+using Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+using MediatR;
+using Microsoft.Extensions.Options;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class Handler : IRequestHandler<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>
+{
+    private readonly IRelationshipsRepository _relationshipsRepository;
+    private readonly ApplicationOptions _applicationOptions;
+
+    public Handler(IRelationshipsRepository relationshipsRepository, IOptions<ApplicationOptions> applicationOptions)
+    {
+        _relationshipsRepository = relationshipsRepository;
+        _applicationOptions = applicationOptions.Value;
+    }
+
+    public async Task Handle(DecomposeAndAnonymizeRelationshipsOfIdentityCommand request, CancellationToken cancellationToken)
+    {
+        var relationships = (await _relationshipsRepository.FindRelationships(Relationship.HasParticipant(request.IdentityAddress), cancellationToken)).ToList();
+
+        foreach (var relationship in relationships)
+            relationship.DecomposeDueToIdentityDeletion(request.IdentityAddress, _applicationOptions.DidDomainName);
+
+        await _relationshipsRepository.Update(relationships);
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DecomposeAndAnonymizeRelationshipsOfIdentity/Validator.cs

@@ -0,0 +1,13 @@
+using Backbone.BuildingBlocks.Application.Extensions;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
+using FluentValidation;
+
+namespace Backbone.Modules.Relationships.Application.Relationships.Commands.DecomposeAndAnonymizeRelationshipsOfIdentity;
+
+public class Validator : AbstractValidator<DecomposeAndAnonymizeRelationshipsOfIdentityCommand>
+{
+    public Validator()
+    {
+        RuleFor(x => x.IdentityAddress).ValidId<DecomposeAndAnonymizeRelationshipsOfIdentityCommand, IdentityAddress>();
+    }
+}

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DeleteRelationshipsOfIdentity/DeleteRelationshipsOfIdentityCommand.cs

@@ -8,15 +8,15 @@ public RelationshipAuditLogEntryDTO(RelationshipAuditLogEntry entry)
     {
         CreatedAt = entry.CreatedAt;
         CreatedBy = entry.CreatedBy;
-        CreatedByDevice = entry.CreatedByDevice;
+        CreatedByDevice = entry.CreatedByDevice?.Value;
         Reason = entry.Reason.ToString();
         OldStatus = entry.OldStatus.ToDtoString();
         NewStatus = entry.NewStatus.ToDtoString();
     }
 
     public DateTime CreatedAt { get; set; }
     public string CreatedBy { get; set; }
-    public string CreatedByDevice { get; set; }
+    public string? CreatedByDevice { get; set; }
     public string Reason { get; set; }
 
     public string? OldStatus { get; set; }

Modules/Relationships/src/Relationships.Application/Relationships/Commands/DeleteRelationshipsOfIdentity/Handler.Tests.cs

@@ -0,0 +1,104 @@
+using Backbone.BuildingBlocks.Domain.Exceptions;
+using Backbone.DevelopmentKit.Identity.ValueObjects;
+using Backbone.UnitTestTools.Extensions;
+using static Backbone.Modules.Relationships.Domain.TestHelpers.TestData;
+
+namespace Backbone.Modules.Relationships.Domain.Aggregates.Relationships;
+
+public class RelationshipDecomposeDueToIdentityDeletionTests : AbstractTestsBase
+{
+    private const string DID_DOMAIN_NAME = "localhost";
+
+    [Theory]
+    [InlineData(RelationshipStatus.Pending)]
+    [InlineData(RelationshipStatus.Active)]
+    [InlineData(RelationshipStatus.Rejected)]
+    [InlineData(RelationshipStatus.Revoked)]
+    [InlineData(RelationshipStatus.Terminated)]
+    public void Decomposition_can_be_performed_from_multiple_statuses(RelationshipStatus status)
+    {
+        // Arrange
+        var relationship = CreateRelationshipInStatus(status, IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.Status.Should().Be(RelationshipStatus.DeletionProposed);
+        relationship.FromHasDecomposed.Should().BeTrue();
+        relationship.ToHasDecomposed.Should().BeFalse();
+    }
+
+    [Fact]
+    public void Decomposition_can_not_be_called_by_the_same_identity_twice()
+    {
+        // Arrange
+        var relationship = CreateRelationshipDecomposedByFrom(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.relationshipAlreadyDecomposed");
+    }
+
+    [Fact]
+    public void Decomposition_can_not_be_performed_by_other_identities()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(CreateRandomIdentityAddress(), DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().Throw<DomainException>().WithError("error.platform.validation.relationship.requestingIdentityDoesNotBelongToRelationship");
+    }
+
+    [Fact]
+    public void Decomposition_by_both_identities_transitions_relationship_to_status_ReadyForDeletion()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Act
+        var acting = () => relationship.DecomposeDueToIdentityDeletion(IDENTITY_2, DID_DOMAIN_NAME);
+
+        // Assert
+        acting.Should().NotThrow();
+        relationship.Status.Should().Be(RelationshipStatus.ReadyForDeletion);
+    }
+
+    [Fact]
+    public void Anonymizes_the_deleted_identity()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        var anonymousIdentity = IdentityAddress.GetAnonymized(DID_DOMAIN_NAME);
+
+        // Act
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        relationship.From.Should().Be(anonymousIdentity);
+        relationship.FromHasDecomposed.Should().BeTrue();
+    }
+
+    [Fact]
+    public void Anonymizes_the_audit_logs()
+    {
+        // Arrange
+        var relationship = CreateActiveRelationship(IDENTITY_1, IDENTITY_2);
+        var anonymousIdentity = IdentityAddress.GetAnonymized(DID_DOMAIN_NAME);
+
+        // Act
+        relationship.DecomposeDueToIdentityDeletion(IDENTITY_1, DID_DOMAIN_NAME);
+
+        // Assert
+        relationship.AuditLog.Should().HaveCount(3);
+        relationship.AuditLog[0].CreatedBy.Should().Be(anonymousIdentity);
+        relationship.AuditLog[2].CreatedBy.Should().Be(anonymousIdentity);
+    }
+}