Added e2e test and fixed bugs in handling

Author: oskardudycz

samples/optimisticConcurrency/src/core/http/responses/index.ts

@@ -1,5 +1,12 @@
 import { Response } from 'express';
-export function sendCreated(response: Response, createdId: string): void {
-  response.setHeader('Location', `/cash-registers/${createdId}`);
+export function sendCreated(
+  response: Response,
+  createdId: string,
+  urlPrefix?: string
+): void {
+  response.setHeader(
+    'Location',
+    `${urlPrefix ?? response.req.url}/${createdId}`
+  );
   response.status(201).json({ id: createdId });
 }

samples/optimisticConcurrency/src/shoppingCarts/addingProductItem/route.ts

@@ -65,7 +65,7 @@ function mapRequestToCommand(
     return 'MISSING_SHOPPING_CARD_ID';
   }
 
-  if (!isNotEmptyString(request.params.productId)) {
+  if (!isNotEmptyString(request.body.productId)) {
     return 'MISSING_PRODUCT_ID';
   }
 

samples/optimisticConcurrency/src/shoppingCarts/e2e/fullFlow.e2e.test.ts

@@ -0,0 +1,114 @@
+import request from 'supertest';
+import { v4 as uuid } from 'uuid';
+import { config } from '#config';
+import { Subscription } from '#core/eventStore/subscribing';
+import {
+  EventStoreDBContainer,
+  StartedEventStoreDBContainer,
+} from '#testing/eventStoreDB/eventStoreDBContainer';
+import {
+  MongoDBContainer,
+  StartedMongoDBContainer,
+} from '#testing/mongoDB/mongoDBContainer';
+import { retry } from '#testing/retries';
+import app from '../../app';
+import { getSubscription } from '../../getSubscription';
+
+describe('Full flow', () => {
+  let esdbContainer: StartedEventStoreDBContainer;
+  let mongodbContainer: StartedMongoDBContainer;
+  let subscription: Subscription;
+  const clientId = uuid();
+
+  beforeAll(async () => {
+    esdbContainer = await new EventStoreDBContainer().startContainer();
+    config.eventStoreDB.connectionString = esdbContainer.getConnectionString();
+
+    mongodbContainer = await new MongoDBContainer().startContainer();
+    config.mongoDB.connectionString = mongodbContainer.getConnectionString();
+    console.log(config.mongoDB.connectionString);
+
+    const subscriptionResult = getSubscription();
+
+    if (subscriptionResult.isError) {
+      console.error(subscriptionResult.error);
+      return;
+    }
+
+    subscription = subscriptionResult.value;
+    subscription.subscribe();
+  });
+
+  afterAll(async () => {
+    try {
+      await subscription.unsubscribe();
+    } catch (err) {
+      console.warn(`Failed to unsubscribe: ${err}`);
+    }
+    await esdbContainer.stop();
+    await mongodbContainer.stop();
+  });
+
+  describe('Shopping Cart', () => {
+    let shoppingCartId: string;
+    let currentRevision: string;
+    let firstProductId: string = uuid();
+
+    it("should open when it wasn't open yet", async () => {
+      await request(app)
+        .post(`/clients/${clientId}/shopping-carts`)
+        .expect(201)
+        .expect('Content-Type', /json/)
+        .then(async (response) => {
+          expect(response.body).toHaveProperty('id');
+          expect(response.headers['etag']).toBeDefined();
+          expect(response.headers['etag']).toMatch(/W\/"\d+.*"/);
+
+          expect(response.headers['location']).toBeDefined();
+          expect(response.headers['location']).toBe(
+            `/clients/${clientId}/shopping-carts/${response.body.id}`
+          );
+
+          currentRevision = response.headers['etag'];
+          shoppingCartId = response.body.id;
+        });
+
+      await request(app)
+        .post(
+          `/clients/${clientId}/shopping-carts/${shoppingCartId}/product-items`
+        )
+        .set('If-Match', currentRevision)
+        .send({ productId: firstProductId, quantity: 10 })
+        .expect(200)
+        .expect('Content-Type', /plain/)
+        .then(async (response) => {
+          expect(response.headers['etag']).toBeDefined();
+          expect(response.headers['etag']).toMatch(/W\/"\d+.*"/);
+
+          currentRevision = response.headers['etag'];
+        });
+
+      await request(app)
+        .delete(
+          `/clients/${clientId}/shopping-carts/${shoppingCartId}/product-items`
+        )
+        .set('If-Match', currentRevision)
+        .send({ productId: firstProductId, quantity: 5 })
+        .expect(200)
+        .expect('Content-Type', /plain/)
+        .then(async (response) => {
+          expect(response.headers['etag']).toBeDefined();
+          expect(response.headers['etag']).toMatch(/W\/"\d+.*"/);
+
+          currentRevision = response.headers['etag'];
+        });
+
+      await retry(() =>
+        request(app)
+          .get(`/clients/${clientId}/shopping-carts/${shoppingCartId}`)
+          .expect(200)
+          .expect('Content-Type', /json/)
+      );
+    });
+  });
+});

samples/optimisticConcurrency/src/shoppingCarts/index.ts

@@ -1,7 +1,15 @@
 import { Router } from 'express';
-import { route as routeConfirmShoppingCart } from './opening';
+import { route as routeOpenShoppingCart } from './opening';
+import { route as routeAddProductItem } from './addingProductItem';
+import { route as routeRemoveProductItem } from './removingProductItem';
+import { route as routeConfirmShoppingCart } from './confirming';
+import { route as routeGetShoppingCartById } from './gettingById';
 
 export const shoppingCartRouter = Router();
 
+routeOpenShoppingCart(shoppingCartRouter);
+routeAddProductItem(shoppingCartRouter);
+routeRemoveProductItem(shoppingCartRouter);
 routeConfirmShoppingCart(shoppingCartRouter);
+routeGetShoppingCartById(shoppingCartRouter);
 export * from './shoppingCart';

samples/optimisticConcurrency/src/shoppingCarts/opening/route.ts

@@ -1,4 +1,5 @@
 import { NextFunction, Request, Response, Router } from 'express';
+import { v4 as uuid } from 'uuid';
 import { isCommand } from '#core/commands';
 import { openShoppingCart, OpenShoppingCart } from './handler';
 import { getShoppingCartStreamName } from '../shoppingCart';
@@ -10,7 +11,7 @@ import { sendCreated } from '#core/http/responses';
 
 export const route = (router: Router) =>
   router.post(
-    '/clients/:clientId/shopping-carts/:shoppingCartId',
+    '/clients/:clientId/shopping-carts/',
     async function (request: Request, response: Response, next: NextFunction) {
       try {
         const command = mapRequestToCommand(request);
@@ -48,15 +49,12 @@ function mapRequestToCommand(
   if (!isNotEmptyString(request.params.clientId)) {
     return 'MISSING_CLIENT_ID';
   }
-  if (!isNotEmptyString(request.params.shoppingCartId)) {
-    return 'MISSING_SHOPPING_CARD_ID';
-  }
 
   return {
     type: 'open-shopping-cart',
     data: {
       clientId: request.body.clientId,
-      shoppingCartId: request.body.shoppingCartId,
+      shoppingCartId: uuid(),
     },
   };
 }

samples/optimisticConcurrency/src/shoppingCarts/removingProductItem/route.ts

@@ -66,7 +66,7 @@ function mapRequestToCommand(
     return 'MISSING_SHOPPING_CARD_ID';
   }
 
-  if (!isNotEmptyString(request.params.productId)) {
+  if (!isNotEmptyString(request.body.productId)) {
     return 'MISSING_PRODUCT_ID';
   }
 
@@ -83,9 +83,9 @@ function mapRequestToCommand(
   return {
     type: 'remove-product-item-from-shopping-cart',
     data: {
-      shoppingCartId: request.body.shoppingCartId,
+      shoppingCartId: request.params.shoppingCartId,
       productItem: {
-        productId: request.params.productId,
+        productId: request.body.productId,
         quantity: request.body.quantity,
       },
     },

samples/optimisticConcurrency/src/testing/eventStoreDB/eventStoreDBContainer.ts

@@ -54,13 +54,18 @@ export class EventStoreDBContainer extends GenericContainer {
 export class StartedEventStoreDBContainer {
   constructor(private container: StartedTestContainer) {}
 
-  stop(
+  async stop(
     options?: Partial<{
       timeout: number;
       removeVolumes: boolean;
     }>
-  ): Promise<StoppedTestContainer> {
-    return this.container.stop(options);
+  ): Promise<StoppedTestContainer | undefined> {
+    try {
+      return await this.container.stop(options);
+    } catch (err) {
+      console.warn(`Failed to stop EventStoreDB container: ${err}`);
+      return undefined;
+    }
   }
 
   getConnectionString(): string {

samples/optimisticConcurrency/src/testing/mongoDB/mongoDBContainer.ts

@@ -32,13 +32,18 @@ export class MongoDBContainer extends GenericContainer {
 export class StartedMongoDBContainer {
   constructor(private container: StartedTestContainer) {}
 
-  stop(
+  async stop(
     options?: Partial<{
       timeout: number;
       removeVolumes: boolean;
     }>
-  ): Promise<StoppedTestContainer> {
-    return this.container.stop(options);
+  ): Promise<StoppedTestContainer | undefined> {
+    try {
+      return await this.container.stop(options);
+    } catch (err) {
+      console.warn(`Failed to stop MongoDB container: ${err}`);
+      return undefined;
+    }
   }
 
   getConnectionString(): string {