Add CanCreateRelationshipUseCase and handling of expired Relationship…

…Templates (#212) * Fix: throw error when responding to Request of expired RelationshipTemplate * fix: throw error when try to create Relationship with expired RelationshipTemplate * test: add first version of test * feat: adjust auxiliary function for RelationshipTemplate * feat: adjust createTemplate testUtil function * fix: return error instead of throwing error * test: temporary changes for tests * fix: test by using auxiliary function * test: shortened test duration * chore: comment out code more consistently * chore: make default expirationDateTime recognizable * chore: add error for delay function * feat: LocalRequest is expired when source RelationshipTemplate is expired * test: add test for CreateRelationshipUseCase * chore: remove comments * test: add tests for updateStatusBasedOnTemplateExpiration function * chore: adjust isExpired function for reasons of consistency * fix: ensure to throw error only if no other is more relevant * chore: adjust test naming to be more appropriate * fix: ensure more precisely to throw error only if no other is more relevant * feat: throw error only for onNewRelationship * fix: prettier * chore: renaming variables and use $in operator * feat: implement canCreate route for Relationships * chore: use CanCreateRelationshipUseCase in other use cases * chore: use CanCreateRelationshipUseCase in more other use cases * chore: rename error message relationshipAlreadyExists * refactor: naming of response variable of CanCreateRelationshipUseCase * fix: do not use CanCreateRelationshipUseCase in other UseCases * feat: add noRequestToAccept error for CanCreateRelationshipUseCase * refactor: do not expose the term LocalRequest in error messages * feat: expose CanCreateRelationshipUseCase to facade * test: should not create Relationship with CreateRelationshipUseCase if RelationshipTemplateContent used * feat: use CreateRelationshipUseCase only for ArbitraryRelationshipTemplateContent * fix: missing imports * fix: unused import * chore: build schema of CanCreateRelationshipUseCase * refactor: choose more appropriate variable name * chore: reduce CanCreateRelationshipUseCase to split pull requests * chore: reduce CanCreateRelationshipUseCase to split pull requests * fix: error message of CreateRelationship use case * feat: update expiry of Requests also within CreateRelationshipUseCase * fix: error message used for contradicting cases * feat: only allow Request which expires after RelationshipTemplate for new Relationships * test: request for new Relationship cannot expire after RelationshipTemplate * fix: tests for expiration date of Requests * refactor: rename to error for Relationships instead of RelationshipTemplates * chore: remove unused Runtime error * refactor: throw only Runtime errors in use cases * refactor: add function for getting existing Relationships * refactor: reuse CreateRelationshipRequest for CanCreateUseCase * fix: incorrect use of recordNotFound error * feat: define canSendRelationship method in Controller * fix: failed Result for CanAcceptIncomingRequest and CanRejectIncomingRequest use cases * feat: add canCreateRelationship Backbone service * fix: value not used for sendRelationship method * fix: value not used for sendRelationship method * feat: use canCreate route of Backbone * fix: request type of canCreateRelationship Backbone route * fix: canCreateRelationship Backbone route * fix: return value of canCreateRelationship Backbone route * refactor: use variable for peerAddress * chore: do not use imprecise Backbone result * fix: return value of canSendRelationship method * feat: use canSendRelationship method in corresponding use case * chore: remove unneccessary type conversion * feat: incorporate RelationshipTemplate expiry in canSendRelationship method * refactor: CanCreateRelationshipUseCase * feat: taking rejected Requests into account * refactor: return code and message instead of error to avoid misunderstandings * refactor: take rejected Requests at a lower level into account * chore: simply code because cases handled at a lower level * feat: handle expired RelationshipTemplate error appropriately * test: does not change status of rejected Request when RelationshipTemplate expires * fix: tests * chore: update Backbone version * test: automatic update of Request of expired RelationshipTemplate * test: CanCreateRelationshipUseCase * fix: LocalRequest test * refactor: rename temporary error message * chore: remove todo comments * feat: apply Request expiry update in GetIncomingRequest(s)UseCase * test: update Request status to expired when querying Requests if RelationshipTemplate expired * chore: remove unused Runtime error relationshipCurrentlyExists * chore: use imported sleep function instead of own delay function * feat: add minimum of type validation for creationContent of CanCreateRelationshipUseCase * feat: integrate comments * fix: adjust test * feat: generate expiration date for Request in onNewRelationship property if none is set * refactor: use elvis operator * test: remove assertIsCanCreateRelationshipFailureResponse * feat: update expirationDate of Request if RelationshipTemplate expires * test: set expiresAt of Request if none provided * fix: clone template content in tests * feat: remove 10 second tolerance * refactor: move validation into controller * refactor: getExistingRelationship * feat: add min to CoreDate * refactor: remove updates from create rel and get request use cases * feat/refactor: update after received, update during get * refactor: adapt local request * refactor: rename incoming requests getter * refactor: remove now unnecessary validation * fix: remove debugging stuff from tests * fix: consumption * fix: runtime tests * test: reduce sleep duration after removing tolerance * test/fix: add tests and fix revealed errors * test: typos and status settings * chore: remove unused package * test: sleep longer * refactor/test: getOutgoingRequestWithUpdateExpiry and use it * refactor: try-catch in sendRelationship * fix: adapt the tests to the refactoring * fix: more adaptations * feat: canCreate never throws * feat: canCreate with error codes * refactor: use regex, debugging cleanup * fix: variable access * fix: unfound typescript-ioc module * fix: unused caught error * fix: unknown transportServices1 variable * fix: failing test of DeciderModule * fix: shady instanceOf check * refactor: add empty line * refactor: switch some lines in tests * test: proper variable naming * refactor: remove redundant test * refactor: rephrase of test name to give more context * fix: copy-paste error in tests * chore: bump backbone * refactor: remove unused code from request controller * test: emphazise tests expecting errors * refactor: re-simplify naming * fix: do not get the template for every incoming request query * refactor: de-dupe code * refactor: remove empty line again * refactor: distinguish success and failure response of CanCreateRelationshipUseCase * fix: use correct CanCreateRelationshipResonse type in tests * refactor: remove unused expiration code * refactor: simplify * fix: satisfy compiler --------- Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> Co-authored-by: Milena Czierlinski <[email protected]> Co-authored-by: mkuhn <[email protected]> Co-authored-by: Magnus Kuhn <[email protected]> Co-authored-by: Julian König <[email protected]>
nmshd · Oct 22, 2024 · 7b0bb79 · 7b0bb79
1 parent 9876cf3
commit 7b0bb79
Show file tree

Hide file tree

Showing 26 changed files with 741 additions and 118 deletions.
diff --git a/.dev/compose.backbone.env b/.dev/compose.backbone.env
@@ -1 +1 @@
-BACKBONE_VERSION=6.10.0
+BACKBONE_VERSION=6.13.2
diff --git a/packages/consumption/src/consumption/ConsumptionController.ts b/packages/consumption/src/consumption/ConsumptionController.ts
@@ -124,7 +124,8 @@ export class ConsumptionController {
             this,
             this.transport.eventBus,
             this.accountController.identity,
-            this.accountController.relationships
+            this.accountController.relationships,
+            this.accountController.relationshipTemplates
         ).init();
 
         const notificationItemProcessorRegistry = new NotificationItemProcessorRegistry(this, this.getDefaultNotificationItemProcessors());

diff --git a/packages/consumption/src/modules/requests/incoming/IncomingRequestsController.ts b/packages/consumption/src/modules/requests/incoming/IncomingRequestsController.ts
@@ -39,6 +39,10 @@ export class IncomingRequestsController extends ConsumptionBaseController {
         private readonly identity: { address: CoreAddress },
         private readonly relationshipResolver: {
             getRelationshipToIdentity(id: CoreAddress): Promise<Relationship | undefined>;
+            getExistingRelationshipToIdentity(id: CoreAddress): Promise<Relationship | undefined>;
+        },
+        private readonly relationshipTemplateResolver: {
+            getRelationshipTemplate(id: CoreId): Promise<RelationshipTemplate | undefined>;
         }
     ) {
         super(ConsumptionControllerName.RequestsController, parent);
@@ -60,6 +64,11 @@ export class IncomingRequestsController extends ConsumptionBaseController {
             statusLog: []
         });
 
+        if (!(await this.relationshipResolver.getExistingRelationshipToIdentity(CoreAddress.from(infoFromSource.peer))) && infoFromSource.expiresAt) {
+            request.content.expiresAt = CoreDate.min(infoFromSource.expiresAt, request.content.expiresAt);
+            request.updateStatusBasedOnExpiration();
+        }
+
         await this.localRequests.create(request);
 
         this.eventBus.publish(new IncomingRequestReceivedEvent(this.identity.address.toString(), request));
@@ -95,7 +104,8 @@ export class IncomingRequestsController extends ConsumptionBaseController {
             source: {
                 reference: template.id,
                 type: "RelationshipTemplate"
-            }
+            },
+            expiresAt: template.cache!.expiresAt
         };
     }
 
@@ -392,6 +402,7 @@ export class IncomingRequestsController extends ConsumptionBaseController {
         if (!requestDoc) return;
 
         const localRequest = LocalRequest.from(requestDoc);
+
         return await this.updateRequestExpiry(localRequest);
     }
 
@@ -434,4 +445,5 @@ export class IncomingRequestsController extends ConsumptionBaseController {
 interface InfoFromSource {
     peer: ICoreAddress;
     source: ILocalRequestSource;
+    expiresAt?: CoreDate;
 }
diff --git a/packages/consumption/src/modules/requests/local/LocalRequest.ts b/packages/consumption/src/modules/requests/local/LocalRequest.ts
@@ -117,7 +117,7 @@ export class LocalRequest extends CoreSynchronizable implements ILocalRequest {
     public isExpired(comparisonDate: CoreDate = CoreDate.utc()): boolean {
         if (!this.content.expiresAt) return false;
 
-        return comparisonDate.isAfter(this.content.expiresAt.add({ seconds: 10 }));
+        return comparisonDate.isAfter(this.content.expiresAt);
     }
 
     public updateStatusBasedOnExpiration(comparisonDate: CoreDate = CoreDate.utc()): boolean {
@@ -130,4 +130,17 @@ export class LocalRequest extends CoreSynchronizable implements ILocalRequest {
 
         return false;
     }
+
+    public updateExpirationDateBasedOnTemplateExpiration(templateExpiresAt: CoreDate): boolean {
+        if (this.source?.type !== "RelationshipTemplate") return false;
+
+        if (this.status === LocalRequestStatus.Completed || this.status === LocalRequestStatus.Expired) return false;
+
+        if (!this.isExpired()) {
+            this.content.expiresAt = CoreDate.min(templateExpiresAt, this.content.expiresAt);
+            return true;
+        }
+
+        return false;
+    }
 }
diff --git a/packages/consumption/test/modules/requests/IncomingRequestsController.test.ts b/packages/consumption/test/modules/requests/IncomingRequestsController.test.ts
@@ -1,7 +1,7 @@
 import { IDatabaseConnection } from "@js-soft/docdb-access-abstractions";
 import { IRequest, IRequestItemGroup, RejectResponseItem, Request, RequestItemGroup, ResponseItem, ResponseItemGroup, ResponseItemResult } from "@nmshd/content";
 import { CoreDate, CoreId } from "@nmshd/core-types";
-import { CoreIdHelper, TransportLoggerFactory } from "@nmshd/transport";
+import { CoreIdHelper, RelationshipTemplate, TransportLoggerFactory } from "@nmshd/transport";
 import {
     ConsumptionIds,
     DecideRequestItemGroupParametersJSON,
@@ -65,6 +65,34 @@ describe("IncomingRequestsController", function () {
             await Then.eventHasBeenPublished(IncomingRequestReceivedEvent);
         });
 
+        test("takes the expiration date from the Template if the Request has no expiration date", async function () {
+            const timestamp = CoreDate.utc();
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp);
+            await When.iCreateAnIncomingRequestWith({ requestSourceObject: incomingTemplate });
+            await Then.theRequestHasExpirationDate(timestamp);
+            await Then.theRequestIsInStatus(LocalRequestStatus.Expired);
+        });
+
+        test("takes the expiration date from the Template if the Request has a later expiration date", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp);
+            await When.iCreateAnIncomingRequestWith({
+                requestSourceObject: incomingTemplate,
+                receivedRequest: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp.add({ days: 1 }) })
+            });
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
+        test("takes the expiration date from the Request if the Template has a later expiration date", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp.add({ days: 1 }));
+            await When.iCreateAnIncomingRequestWith({
+                requestSourceObject: incomingTemplate,
+                receivedRequest: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp })
+            });
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
         test("uses the ID of the given Request if it exists", async function () {
             const request = TestObjectFactory.createRequestWithOneItem({ id: await CoreIdHelper.notPrefixed.generate() });
 
@@ -999,6 +1027,7 @@ describe("IncomingRequestsController", function () {
                 items: [TestRequestItem.from({ mustBeAccepted: false })]
             });
             const template = TestObjectFactory.createIncomingIRelationshipTemplate();
+            context.templateToReturnFromGetTemplate = RelationshipTemplate.from(template);
 
             let cnsRequest = await context.incomingRequestsController.received({
                 receivedRequest: request,

diff --git a/packages/consumption/test/modules/requests/RequestsIntegrationTest.ts b/packages/consumption/test/modules/requests/RequestsIntegrationTest.ts
@@ -14,7 +14,7 @@ import {
     ResponseItemResult,
     ResponseResult
 } from "@nmshd/content";
-import { CoreAddress, CoreId, ICoreId } from "@nmshd/core-types";
+import { CoreAddress, CoreDate, CoreId, ICoreId } from "@nmshd/core-types";
 import { CoreIdHelper, IConfigOverwrite, IMessage, IRelationshipTemplate, Message, Relationship, RelationshipTemplate, SynchronizedCollection, Transport } from "@nmshd/transport";
 import {
     ConsumptionController,
@@ -57,6 +57,8 @@ export class RequestsTestsContext {
     public currentIdentity: CoreAddress;
     public mockEventBus = new MockEventBus();
     public relationshipToReturnFromGetRelationshipToIdentity: Relationship | undefined;
+    public relationshipToReturnFromGetExistingRelationshipToIdentity: Relationship | undefined;
+    public templateToReturnFromGetTemplate: RelationshipTemplate | undefined;
     public consumptionController: ConsumptionController;
 
     private constructor() {
@@ -110,7 +112,11 @@ export class RequestsTestsContext {
                 address: account.accountController.identity.address
             },
             {
-                getRelationshipToIdentity: () => Promise.resolve(context.relationshipToReturnFromGetRelationshipToIdentity)
+                getRelationshipToIdentity: () => Promise.resolve(context.relationshipToReturnFromGetRelationshipToIdentity),
+                getExistingRelationshipToIdentity: () => Promise.resolve(context.relationshipToReturnFromGetExistingRelationshipToIdentity)
+            },
+            {
+                getRelationshipTemplate: () => Promise.resolve(context.templateToReturnFromGetTemplate)
             }
         );
 
@@ -132,6 +138,8 @@ export class RequestsTestsContext {
         this.validationResult = undefined;
         this.actionToTry = undefined;
         this.relationshipToReturnFromGetRelationshipToIdentity = undefined;
+        this.relationshipToReturnFromGetExistingRelationshipToIdentity = undefined;
+        this.templateToReturnFromGetTemplate = undefined;
 
         TestRequestItemProcessor.numberOfApplyIncomingResponseItemCalls = 0;
 
@@ -222,6 +230,12 @@ export class RequestsGiven {
             requestSourceObject: params.requestSource
         });
 
+        try {
+            this.context.templateToReturnFromGetTemplate = RelationshipTemplate.from(params.requestSource as any);
+        } catch (_) {
+            // the source is not a template
+        }
+
         await this.moveIncomingRequestToStatus(localRequest, params.status);
 
         this.context.givenLocalRequest = localRequest;
@@ -306,11 +320,13 @@ export class RequestsGiven {
     }
 
     private async moveOutgoingRequestToStatus(localRequest: LocalRequest, status: LocalRequestStatus) {
-        if (localRequest.status === status) return;
+        const updatedRequest = await this.context.outgoingRequestsController.getOutgoingRequest(localRequest.id);
+
+        if (updatedRequest!.status === status) return;
 
         if (isStatusAAfterStatusB(status, LocalRequestStatus.Draft)) {
             await this.context.outgoingRequestsController.sent({
-                requestId: localRequest.id,
+                requestId: updatedRequest!.id,
                 requestSourceObject: TestObjectFactory.createOutgoingIMessage(this.context.currentIdentity)
             });
         }
@@ -1039,6 +1055,12 @@ export class RequestsThen {
         return Promise.resolve();
     }
 
+    public theRequestHasExpirationDate(expiresAt: CoreDate): Promise<void> {
+        expect(this.context.localRequestAfterAction?.content.expiresAt).toStrictEqual(expiresAt);
+
+        return Promise.resolve();
+    }
+
     public theRequestHasCorrectItemCount(itemCount: number): Promise<void> {
         expect(this.context.localRequestAfterAction?.content.items).toHaveLength(itemCount);
 
@@ -1205,8 +1227,6 @@ function isStatusAAfterStatusB(a: LocalRequestStatus, b: LocalRequestStatus): bo
 
 function getIntegerValue(status: LocalRequestStatus): number {
     switch (status) {
-        case LocalRequestStatus.Expired:
-            return -1;
         case LocalRequestStatus.Draft:
             return 0;
         case LocalRequestStatus.Open:
@@ -1215,6 +1235,8 @@ function getIntegerValue(status: LocalRequestStatus): number {
             return 2;
         case LocalRequestStatus.ManualDecisionRequired:
             return 3;
+        case LocalRequestStatus.Expired:
+            return 4;
         case LocalRequestStatus.Decided:
             return 5;
         case LocalRequestStatus.Completed:

diff --git a/packages/consumption/test/modules/requests/local/LocalRequest.test.ts b/packages/consumption/test/modules/requests/local/LocalRequest.test.ts
@@ -35,7 +35,7 @@ describe("LocalRequest", function () {
         });
 
         test("adds a status log entry on status change", function () {
-            const request = TestObjectFactory.createLocalRequestWith({});
+            const request = TestObjectFactory.createLocalRequestWith({ status: LocalRequestStatus.Draft });
             request.changeStatus(LocalRequestStatus.Open);
 
             expect(request.statusLog).toHaveLength(1);
@@ -50,7 +50,7 @@ describe("LocalRequest", function () {
     });
 
     describe("updateStatusBasedOnExpiration", function () {
-        test("sets the status to expired when the request is expired", function () {
+        test("sets the status to expired when the Request is expired", function () {
             const request = TestObjectFactory.createLocalRequestWith({
                 contentProperties: {
                     expiresAt: CoreDate.utc().subtract({ days: 1 })
@@ -61,18 +61,84 @@ describe("LocalRequest", function () {
             expect(request.status).toStrictEqual(LocalRequestStatus.Expired);
         });
 
-        test("does not change the status when the request is expired but already completed", function () {
+        test("does not change the status when the Request is expired but already completed", function () {
             const request = TestObjectFactory.createLocalRequestWith({ status: LocalRequestStatus.Completed });
 
             request.updateStatusBasedOnExpiration();
             expect(request.status).toStrictEqual(LocalRequestStatus.Completed);
         });
 
-        test("does not change the status when the request is expired but already expired", function () {
+        test("does not change the status when the Request is expired but already expired", function () {
             const request = TestObjectFactory.createLocalRequestWith({ status: LocalRequestStatus.Expired });
 
             request.updateStatusBasedOnExpiration();
             expect(request.status).toStrictEqual(LocalRequestStatus.Expired);
         });
     });
+
+    describe("updateExpirationDateBasedOnTemplateExpiration", function () {
+        test("sets the expiration date if the Request doesn't have an expiration date", function () {
+            const request = TestObjectFactory.createUnansweredLocalRequestBasedOnTemplateWith({});
+            expect(request.content.expiresAt).toBeUndefined();
+            const timestamp = CoreDate.utc().subtract({ days: 1 });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp);
+            expect(request.content.expiresAt).toStrictEqual(timestamp);
+        });
+
+        test("sets the expiration date if the Request has already been rejected", function () {
+            const request = TestObjectFactory.createRejectedLocalRequestBasedOnTemplateWith({});
+
+            const timestamp = CoreDate.utc().subtract({ days: 1 });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp);
+            expect(request.content.expiresAt).toStrictEqual(timestamp);
+        });
+
+        test("does not change the expiration date when the Request expires before the Template", function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const request = TestObjectFactory.createUnansweredLocalRequestBasedOnTemplateWith({
+                contentProperties: {
+                    expiresAt: timestamp
+                }
+            });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp.add({ days: 1 }));
+            expect(request.content.expiresAt).toStrictEqual(timestamp);
+        });
+
+        test("does not change the expiration date when the Request is already completed", function () {
+            const request = TestObjectFactory.createRejectedLocalRequestBasedOnTemplateWith({
+                status: LocalRequestStatus.Completed
+            });
+
+            const timestamp = CoreDate.utc().subtract({ days: 1 });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp);
+            expect(request.content.expiresAt).toBeUndefined();
+        });
+
+        test("does not change the expiration date when the Request is already expired", function () {
+            const timestamp = CoreDate.utc().subtract({ days: 1 });
+
+            const request = TestObjectFactory.createUnansweredLocalRequestBasedOnTemplateWith({
+                status: LocalRequestStatus.Expired,
+                contentProperties: {
+                    expiresAt: timestamp
+                }
+            });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp.subtract({ days: 1 }));
+            expect(request.content.expiresAt).toStrictEqual(timestamp);
+        });
+
+        test("does not set the expiration date when Message instead of RelationshipTemplate is used", function () {
+            const request = TestObjectFactory.createLocalRequestWith({});
+
+            const timestamp = CoreDate.utc().subtract({ days: 1 });
+
+            request.updateExpirationDateBasedOnTemplateExpiration(timestamp);
+            expect(request.content.expiresAt).toBeUndefined();
+        });
+    });
 });