Added tests checks for expected version check

Author: oskardudycz

src/packages/emmett-tests/src/eventStore/features.ts

@@ -2,15 +2,24 @@ import {
   assertDeepEqual,
   assertEqual,
   assertOk,
+  assertThrowsAsync,
+  assertTrue,
+  CommandHandler,
+  ExpectedVersionConflictError,
+  isExpectedVersionConflictError,
   type EventStore,
 } from '@event-driven-io/emmett';
+import { randomUUID } from 'crypto';
 import { after, before, describe, it } from 'node:test';
 import { v4 as uuid } from 'uuid';
 import {
+  addProductItem,
   evolve,
   evolveWithMetadata,
   initialState,
+  type AddProductItem,
   type PricedProductItem,
+  type ShoppingCart,
   type ShoppingCartEvent,
 } from './shoppingCart.domain';
 
@@ -119,3 +128,66 @@ export async function testAggregateStream(
     }
   });
 }
+
+export async function testCommandHandling(
+  eventStoreFactory: EventStoreFactory,
+  options: TestOptions = {
+    getInitialIndex: () => 1n,
+  },
+) {
+  return describe('Command handling', async () => {
+    let eventStore: EventStore;
+
+    const handleCommand = CommandHandler<ShoppingCart, ShoppingCartEvent>({
+      evolve,
+      initialState,
+    });
+
+    before(async () => {
+      eventStore = await eventStoreFactory();
+    });
+
+    after(async () => {
+      const teardownHook = options.teardownHook;
+      if (teardownHook) await teardownHook();
+    });
+
+    await it('Correctly handles no retries on version conflict when retry is disabled', async () => {
+      const productItem: PricedProductItem = {
+        productId: '123',
+        quantity: 10,
+        price: 3,
+      };
+
+      const shoppingCartId = randomUUID();
+      const command: AddProductItem = {
+        type: 'AddProductItem',
+        data: { productItem },
+      };
+
+      // Create the stream
+      await handleCommand(
+        eventStore,
+        shoppingCartId,
+        (state) => addProductItem(command, state),
+        { expectedStreamVersion: 'STREAM_DOES_NOT_EXIST' },
+      );
+
+      let tried = 0;
+
+      const error = await assertThrowsAsync(
+        async () => {
+          await handleCommand(eventStore, shoppingCartId, () => {
+            tried++;
+            throw new ExpectedVersionConflictError(0, 1);
+          });
+        },
+        (error) => error instanceof ExpectedVersionConflictError,
+      );
+
+      assertTrue(isExpectedVersionConflictError(error));
+
+      assertEqual(1, tried);
+    });
+  });
+}

src/packages/emmett-tests/src/eventStore/postgresql/postgreSQLEventStore.e2e.spec.ts

@@ -17,7 +17,11 @@ import {
 } from '@testcontainers/postgresql';
 import { after, describe, it } from 'node:test';
 import { v4 as uuid } from 'uuid';
-import { testAggregateStream, type EventStoreFactory } from '../features';
+import {
+  testAggregateStream,
+  testCommandHandling,
+  type EventStoreFactory,
+} from '../features';
 import {
   type DiscountApplied,
   type PricedProductItem,
@@ -58,6 +62,10 @@ void describe('EventStoreDBEventStore', async () => {
     getInitialIndex: () => 1n,
   });
 
+  await testCommandHandling(eventStoreFactory, {
+    getInitialIndex: () => 1n,
+  });
+
   void it('should append events correctly using appendEvent function', async () => {
     const productItem: PricedProductItem = {
       productId: 'p123',

src/packages/emmett-tests/src/eventStore/shoppingCart.domain.ts

@@ -67,3 +67,17 @@ export const evolveWithMetadata = (
 export const initialState = (): ShoppingCart => {
   return { productItems: [], totalAmount: 0 };
 };
+export type AddProductItem = Event<
+  'AddProductItem',
+  { productItem: PricedProductItem }
+>;
+
+export const addProductItem = (
+  command: AddProductItem,
+  _state: ShoppingCart,
+): ShoppingCartEvent => {
+  return {
+    type: 'ProductItemAdded',
+    data: { productItem: command.data.productItem },
+  };
+};

src/packages/emmett/src/commandHandling/handleCommand.unit.spec.ts

@@ -3,6 +3,7 @@ import { describe, it } from 'node:test';
 import {
   ExpectedVersionConflictError,
   getInMemoryEventStore,
+  isExpectedVersionConflictError,
 } from '../eventStore';
 import {
   assertDeepEqual,
@@ -505,7 +506,7 @@ void describe('Command Handler', () => {
 
       let tried = 0;
 
-      await assertThrowsAsync(
+      const error = await assertThrowsAsync(
         async () => {
           await handleCommand(eventStore, shoppingCartId, () => {
             tried++;
@@ -515,6 +516,8 @@ void describe('Command Handler', () => {
         (error) => error instanceof ExpectedVersionConflictError,
       );
 
+      assertTrue(isExpectedVersionConflictError(error));
+
       assertEqual(1, tried);
     });
   });