Added idempotence check for Decider Specification

Now you can either pass an empty array or call `thenDoesNothing` to verify if business logic handled idempotency correctly

src/packages/emmett-postgresql/src/eventStore/projections/pongo/pongoProjectionSpec.ts

@@ -61,7 +61,7 @@ const assertDocumentsEqual = <
       expected._id,
       actual._id,
       // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      `Document ids are not matching! Expected: ${expected._id}, actual: ${actual._id}`,
+      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`,
     );
 
   return assertDeepEqual(

src/packages/emmett/src/testing/assertions.ts

@@ -45,7 +45,7 @@ export const assertThrowsAsync = async <TError extends Error>(
 
     assertTrue(
       errorCheck(typedError),
-      `Error doesn't match the expected condition: ${JSON.stringify(error)}`,
+      `Error doesn't match the expected condition: ${JSONParser.stringify(error)}`,
     );
 
     return typedError;
@@ -65,7 +65,7 @@ export const assertThrows = <TError extends Error>(
     if (errorCheck) {
       assertTrue(
         errorCheck(typedError),
-        `Error doesn't match the expected condition: ${JSON.stringify(error)}`,
+        `Error doesn't match the expected condition: ${JSONParser.stringify(error)}`,
       );
     } else if (typedError instanceof AssertionError) {
       assertFalse(
@@ -79,6 +79,29 @@ export const assertThrows = <TError extends Error>(
   throw new AssertionError("Function didn't throw expected error");
 };
 
+export const assertDoesNotThrow = <TError extends Error>(
+  fun: () => void,
+  errorCheck?: (error: Error) => boolean,
+): TError | null => {
+  try {
+    fun();
+    return null;
+  } catch (error) {
+    const typedError = error as TError;
+
+    if (errorCheck) {
+      assertFalse(
+        errorCheck(typedError),
+        `Error matching the expected condition was thrown!: ${JSONParser.stringify(error)}`,
+      );
+    } else {
+      assertFails(`Function threw an error: ${JSONParser.stringify(error)}`);
+    }
+
+    return typedError;
+  }
+};
+
 export const assertRejects = async <T, TError extends Error = Error>(
   promise: Promise<T>,
   errorCheck?: ((error: TError) => boolean) | TError,
@@ -166,7 +189,7 @@ export function assertEqual<T>(
 ): void {
   if (expected !== actual)
     throw new AssertionError(
-      `${message ?? 'Objects are not equal'}:\nExpected: ${JSONParser.stringify(expected)}\nActual:${JSONParser.stringify(actual)}`,
+      `${message ?? 'Objects are not equal'}:\nExpected: ${JSONParser.stringify(expected)}\nActual: ${JSONParser.stringify(actual)}`,
     );
 }
 
@@ -274,8 +297,13 @@ export function verifyThat(fn: MockedFunction) {
 
 export const assertThatArray = <T>(array: T[]) => {
   return {
-    isEmpty: () => assertEqual(array.length, 0),
-    isNotEmpty: () => assertNotEqual(array.length, 0),
+    isEmpty: () =>
+      assertEqual(
+        array.length,
+        0,
+        `Array is not empty ${JSONParser.stringify(array)}`,
+      ),
+    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
     hasSize: (length: number) => assertEqual(array.length, length),
     containsElements: (other: T[]) => {
       assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
@@ -284,7 +312,7 @@ export const assertThatArray = <T>(array: T[]) => {
       assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
     },
     containsOnlyElementsMatching: (other: T[]) => {
-      assertEqual(array.length, other.length);
+      assertEqual(array.length, other.length, `Arrays lengths don't match`);
       assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
     },
     containsExactlyInAnyOrder: (other: T[]) => {

src/packages/emmett/src/testing/deciderSpecification.ts

@@ -1,5 +1,5 @@
 import { isErrorConstructor, type ErrorConstructor } from '../errors';
-import { AssertionError, assertMatches, assertTrue } from './assertions';
+import { AssertionError, assertThatArray, assertTrue } from './assertions';
 
 type ErrorCheck<ErrorType> = (error: ErrorType) => boolean;
 
@@ -17,6 +17,7 @@ export type DeciderSpecfication<Command, Event> = (
 ) => {
   when: (command: Command) => {
     then: (expectedEvents: Event | Event[]) => void;
+    thenDoesNothing: () => void;
     thenThrows: <ErrorType extends Error = Error>(
       ...args: Parameters<ThenThrows<ErrorType>>
     ) => void;
@@ -58,7 +59,18 @@ export const DeciderSpecification = {
                   ? expectedEvents
                   : [expectedEvents];
 
-                assertMatches(resultEventsArray, expectedEventsArray);
+                assertThatArray(resultEventsArray).containsOnlyElementsMatching(
+                  expectedEventsArray,
+                );
+              },
+              thenDoesNothing: (): void => {
+                const resultEvents = handle();
+
+                const resultEventsArray = Array.isArray(resultEvents)
+                  ? resultEvents
+                  : [resultEvents];
+
+                assertThatArray(resultEventsArray).isEmpty();
               },
               thenThrows: <ErrorType extends Error>(
                 ...args: Parameters<ThenThrows<ErrorType>>

src/packages/emmett/src/testing/deciderSpecification.unit.spec.ts

@@ -11,10 +11,14 @@ type Entity = { something: string };
 const decide = (
   { data: { something } }: DoSomething,
   _entity: Entity,
-): SomethingHappened => {
+): SomethingHappened | [] | [SomethingHappened] => {
+  const event: SomethingHappened = { type: 'Did', data: { something } };
+
+  if (something === 'Ignore!') return [];
+  if (something === 'Array!') return [event];
   if (something !== 'Yes!') throw new IllegalStateError('Nope!');
 
-  return { type: 'Did', data: { something } };
+  return event;
 };
 
 const initialState = (): Entity => ({ something: 'Meh' });
@@ -30,6 +34,78 @@ const given = DeciderSpecification.for({
 });
 
 void describe('DeciderSpecification', () => {
+  void describe('then', () => {
+    void it('then fails if returns event, but assertion has an empty array', () => {
+      assertThrows(
+        () => {
+          given([])
+            .when({
+              type: 'Do',
+              data: {
+                something: 'Yes!',
+              },
+            })
+            .then([]);
+        },
+        (error) =>
+          error instanceof AssertionError &&
+          error.message ===
+            `Arrays lengths don't match:\nExpected: 1\nActual: 0`,
+      );
+    });
+  });
+
+  void describe('thenDoesNothing', () => {
+    void it('thenDoesNothing succeeds if returns empty array', () => {
+      given([])
+        .when({
+          type: 'Do',
+          data: {
+            something: 'Ignore!',
+          },
+        })
+        .thenDoesNothing();
+    });
+
+    void it('thenDoesNothing fails if returns event', () => {
+      assertThrows(
+        () => {
+          given([])
+            .when({
+              type: 'Do',
+              data: {
+                something: 'Yes!',
+              },
+            })
+            .thenDoesNothing();
+        },
+        (error) =>
+          error instanceof AssertionError &&
+          error.message ===
+            `Array is not empty [{"type":"Did","data":{"something":"Yes!"}}]:\nExpected: 1\nActual: 0`,
+      );
+    });
+
+    void it('thenDoesNothing fails if returns array of events', () => {
+      assertThrows(
+        () => {
+          given([])
+            .when({
+              type: 'Do',
+              data: {
+                something: 'Array!',
+              },
+            })
+            .thenDoesNothing();
+        },
+        (error) =>
+          error instanceof AssertionError &&
+          error.message ===
+            `Array is not empty [{"type":"Did","data":{"something":"Array!"}}]:\nExpected: 1\nActual: 0`,
+      );
+    });
+  });
+
   void describe('thenThrows', () => {
     void it('check error was thrown', () => {
       given([])