serverless-spy/test/cdk/test/eventBridgeToLambda.test.ts at main · ServerlessLife/serverless-spy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import * as fs from 'fs';
import * as path from 'path';
import {
  EventBridgeClient,
  PutEventsCommand,
} from '@aws-sdk/client-eventbridge';
import { EventBridgeEvent } from 'aws-lambda';
import { v4 as uuidv4 } from 'uuid';
import { TestData } from './TestData';
import { createServerlessSpyListener } from '../../../listener/createServerlessSpyListener';
import { ServerlessSpyListener } from '../../../listener/ServerlessSpyListener';
import { ServerlessSpyEvents } from '../serverlessSpyEvents/ServerlessSpyEventsEventBridgeToLambda';

jest.setTimeout(30000);

describe('EventBridge to Lambda', () => {
  const exportLocation = path.join(__dirname, '../cdkOutput.json');
  let serverlessSpyListener: ServerlessSpyListener<ServerlessSpyEvents>;

  if (!fs.existsSync(exportLocation)) {
    throw new Error(`File ${exportLocation} does not exists.`);
  }
  const output = JSON.parse(fs.readFileSync(exportLocation).toString())[
    'ServerlessSpyEventBridgeToLambda'
  ];

  beforeEach(async () => {
    serverlessSpyListener =
      await createServerlessSpyListener<ServerlessSpyEvents>({
        serverlessSpyWsUrl: output.ServerlessSpyWsUrl,
      });
  });

  afterEach(async () => {
    serverlessSpyListener.stop();
  });

  test('Basic test', async () => {
    const id = uuidv4();
    const data = <TestData>{
      id,
      message: 'Hello',
    };

    const command = new PutEventsCommand({
      Entries: [
        {
          EventBusName: output.EventBusNameMyEventBus,
          Detail: JSON.stringify(data),
          DetailType: 'test',
          Source: 'test-source',
        },
      ],
    });

    const eventBridgeClient = new EventBridgeClient({});
    await eventBridgeClient.send(command);

    (
      await serverlessSpyListener.waitForEventBridgeMyEventBus<TestData>({
        condition: (d) => d.detail.id === id,
      })
    ).toMatchObject({
      detail: data,
      detailType: 'test',
      source: 'test-source',
    });

    (
      await serverlessSpyListener.waitForEventBridgeRuleMyEventBusMyRule<TestData>(
        {
          condition: (d) => d.detail.id === id,
        }
      )
    ).toMatchObject({
      detail: data,
      detailType: 'test',
      source: 'test-source',
    });

    (
      await (
        await serverlessSpyListener.waitForFunctionMyLambdaRequest<
          EventBridgeEvent<'test', TestData>
        >({
          condition: (d) => d.request.detail.id === id,
        })
      )
        .toMatchObject({
          request: {
            detail: data,
            source: 'test-source',
          },
        })
        .followedByResponse<EventBridgeEvent<'test', TestData>>({})
    ).toMatchObject({
      request: {
        detail: data,
        source: 'test-source',
      },
    });
    (
      await (
        await serverlessSpyListener.waitForFunctionMyPythonLambdaRequest<
          EventBridgeEvent<'test', TestData>
        >({
          condition: (d) => d.request.detail.id === id,
        })
      )
        .toMatchObject({
          request: {
            detail: data,
            source: 'test-source',
          },
        })
        .followedByResponse<EventBridgeEvent<'test', TestData>>({})
    ).toMatchObject({
      request: {
        detail: data,
        source: 'test-source',
      },
    });
  });
});