feat: support toHaveReceivedAnyCommand matcher

README.md

@@ -512,6 +512,9 @@ import 'aws-sdk-client-mock-jest';
 // a PublishCommand was sent to SNS
 expect(snsMock).toHaveReceivedCommand(PublishCommand);
 
+// Any command was sent to SNS
+expect(snsMock).toHaveReceivedAnyCommand();
+
 // two PublishCommands were sent to SNS
 expect(snsMock).toHaveReceivedCommandTimes(PublishCommand, 2);
 

packages/aws-sdk-client-mock-jest/src/jestMatchers.ts

@@ -69,6 +69,11 @@ interface AwsSdkJestMockBaseMatchers<R> extends Record<string, Function> {
         command: new (input: TCmdInput) => AwsCommand<TCmdInput, TCmdOutput>,
         input: Partial<TCmdInput>,
     ): R;
+
+    /**
+     * Asserts {@link AwsStub Aws Client Mock} received any command
+     */
+    toHaveReceivedAnyCommand(): R;
 }
 
 interface AwsSdkJestMockAliasMatchers<R> extends Record<string, Function> {
@@ -138,6 +143,11 @@ interface AwsSdkJestMockAliasMatchers<R> extends Record<string, Function> {
         command: new (input: TCmdInput) => AwsCommand<TCmdInput, TCmdOutput>,
         input: Partial<TCmdInput>,
     ): R;
+
+    /**
+     * Asserts {@link AwsStub Aws Client Mock} received any command
+     */
+    toReceiveAnyCommand(): R;
 }
 
 /**
@@ -191,6 +201,7 @@ type MessageFunctionParams<CheckData> = {
     cmd: string;
     client: string;
     commandCalls: AnySpyCall[];
+    calls: AnySpyCall[];
     data: CheckData;
     notPrefix: string;
 };
@@ -214,15 +225,15 @@ const printCalls = (ctx: MatcherContext, calls: AnySpyCall[]): string[] =>
 const processMatch = <CheckData = undefined>({ctx, mockClient, command, check, message}: {
     ctx: MatcherContext;
     mockClient: unknown;
-    command: new () => AnyCommand;
+    command?: new () => AnyCommand;
     check: (params: { calls: AnySpyCall[]; commandCalls: AnySpyCall[] }) => {
         pass: boolean;
         data: CheckData;
     };
     message: (params: MessageFunctionParams<CheckData>) => string[];
 }): ExpectationResult => {
     assert(mockClient instanceof AwsStub, 'The actual must be a client mock instance');
-    assert(
+    command && assert(
         command &&
         typeof command === 'function' &&
         typeof command.name === 'string' &&
@@ -231,19 +242,20 @@ const processMatch = <CheckData = undefined>({ctx, mockClient, command, check, m
     );
 
     const calls = mockClient.calls();
-    const commandCalls = mockClient.commandCalls(command);
+    const commandCalls = command ? mockClient.commandCalls(command) : [];
 
     const {pass, data} = check({calls, commandCalls});
 
     const msg = (): string => {
-        const cmd = ctx.utils.printExpected(command.name);
+        const cmd = ctx.utils.printExpected(command?.name || 'Any Command');
         const client = mockClient.clientName();
 
         return [
             ...message({
                 client,
                 cmd,
                 data,
+                calls,
                 commandCalls,
                 notPrefix: ctx.isNot ? 'not ' : '',
             }),
@@ -462,6 +474,25 @@ const baseMatchers: { [P in keyof AwsSdkJestMockBaseMatchers<unknown>]: MatcherF
             ],
         });
     },
+    /**
+     * implementation of {@link AwsSdkJestMockMatchers.toHaveReceivedAnyCommand} matcher
+     */
+    toHaveReceivedAnyCommand(
+        this: MatcherContext,
+        mockClient: unknown,
+        ...other: unknown[]
+    ) {
+        ensureNoOtherArgs(other);
+        return processMatch({
+            ctx: this,
+            mockClient,
+            check: ({calls}) => ({pass: calls.length > 0, data: undefined}),
+            message: ({client, notPrefix, calls}) => [
+                `Expected ${client} to ${notPrefix}receive any command`,
+                `${client} received any command ${this.utils.printReceived(calls.length)} times`,
+            ],
+        });
+    },
 };
 
 /* typing ensures keys matching */
@@ -471,6 +502,7 @@ const aliasMatchers: { [P in keyof AwsSdkJestMockAliasMatchers<unknown>]: Matche
     toReceiveCommandWith: baseMatchers.toHaveReceivedCommandWith,
     toReceiveNthCommandWith: baseMatchers.toHaveReceivedNthCommandWith,
     toReceiveNthSpecificCommandWith: baseMatchers.toHaveReceivedNthSpecificCommandWith,
+    toReceiveAnyCommand: baseMatchers.toHaveReceivedAnyCommand,
 };
 
 // Skip registration if jest expect does not exist

packages/aws-sdk-client-mock-jest/test-d/types.ts

@@ -9,6 +9,8 @@ expect(1).toHaveReceivedCommand(PublishCommand);
 expect(mockClient(SNSClient)).toHaveReceivedCommand(PublishCommand);
 expectError(expect(mockClient(SNSClient)).toHaveReceivedCommand(String));
 
+expect(mockClient(SNSClient)).toHaveReceivedAnyCommand();
+
 expect(mockClient(SNSClient)).toHaveReceivedCommandTimes(PublishCommand, 1);
 expectError(expect(mockClient(SNSClient)).toHaveReceivedCommandTimes(PublishCommand));
 

packages/aws-sdk-client-mock-jest/test/jestMatchers.test.ts

@@ -1,4 +1,4 @@
-import {AwsClientStub, mockClient} from 'aws-sdk-client-mock';
+import {AwsClientStub, AwsCommand, mockClient} from 'aws-sdk-client-mock';
 import {PublishCommand, SNSClient} from '@aws-sdk/client-sns';
 import {publishCmd1, publishCmd2, subscribeCmd1} from 'aws-sdk-client-mock/test/fixtures';
 import '../src';
@@ -273,3 +273,23 @@ Calls:
 `);
     });
 });
+
+describe('toHaveReceivedAnyCommand', () => {
+    it.each`
+    command
+    ${publishCmd1}
+    ${subscribeCmd1}
+    `('passes on receiving any command', async ({ command }: { command: AwsCommand<any, any> }) => {
+        const sns = new SNSClient({});
+        await sns.send(command); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+
+        expect(() => expect(snsMock).toHaveReceivedAnyCommand()).not.toThrow();
+    });
+
+    it('fails on not receiving any command', () => {
+        expect(() => expect(snsMock).toHaveReceivedAnyCommand()).toThrowErrorMatchingInlineSnapshot(`
+"Expected SNSClient to receive any command
+SNSClient received any command <red>0</color> times"
+`);
+    });
+});