daily-bread-bot/handler.test.ts at master · efallancy/daily-bread-bot · 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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
describe('handler', () => {
  describe('updater', () => {
    let spy = undefined;

    beforeAll(() => {
      spy = jest.spyOn(console, 'error');
    });

    beforeEach(() => {
      jest.resetAllMocks();
    });

    afterAll(() => {
      spy.mockRestore();
    });

    it('should respond on successful update', async () => {
      const utils = await import('./utils');
      utils.getCurrentEpochTime = jest.fn().mockReturnValue(123);
      utils.scanCachedVerse = jest.fn().mockReturnValue(Promise.resolve({ Count: 0 }));
      utils.putCachedVerse = jest.fn().mockReturnValue(Promise.resolve());

      const _axios = await import('axios');
      const axios = _axios.default;
      const mockAxiosResult = {
        data: {
          contents: {
            foobar: 'abc123',
          },
        },
      };
      axios.get = jest.fn().mockReturnValue(Promise.resolve(mockAxiosResult));

      const { update } = await import('./handler');

      const mockCallback = jest.fn();
      await update({}, {}, mockCallback);

      expect(mockCallback).toHaveBeenCalledWith(null, { message: 'Verse cached' });
    });

    it('should respond on valid cache', async () => {
      const utils = await import('./utils');
      utils.getCurrentEpochTime = jest.fn().mockReturnValue(123);
      utils.scanCachedVerse = jest.fn().mockReturnValue(Promise.resolve({ Count: 1 }));

      const { update } = await import('./handler');

      const mockCallback = jest.fn();
      await update({}, {}, mockCallback);

      expect(mockCallback).toHaveBeenCalledWith(null, { message: 'Cache valid' });
    });

    it('should respond with error when failing to request resource', async () => {
      const utils = await import('./utils');
      utils.getCurrentEpochTime = jest.fn().mockReturnValue(123);
      utils.scanCachedVerse = jest.fn().mockReturnValue(Promise.resolve({ Count: 0 }));
      utils.putCachedVerse = jest.fn().mockReturnValue(Promise.resolve());

      const _axios = await import('axios');
      const axios = _axios.default;
      axios.get = jest.fn().mockReturnValue(Promise.reject(new Error('Fail request')));

      const { update } = await import('./handler');

      const mockCallback = jest.fn();
      await update({}, {}, mockCallback);

      expect(spy).toHaveBeenCalled();
      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error));
    });

    it('should respond with error when failing to persist cache', async () => {
      const utils = await import('./utils');
      utils.getCurrentEpochTime = jest.fn().mockReturnValue(123);
      utils.scanCachedVerse = jest.fn().mockReturnValue(Promise.resolve({ Count: 0 }));
      utils.putCachedVerse = jest.fn().mockReturnValue(Promise.reject(new Error('Fail persisting')));

      const _axios = await import('axios');
      const axios = _axios.default;
      const mockAxiosResult = {
        data: {
          contents: {
            foobar: 'abc123',
          },
        },
      };
      axios.get = jest.fn().mockReturnValue(Promise.resolve(mockAxiosResult));

      const { update } = await import('./handler');

      const mockCallback = jest.fn();
      await update({}, {}, mockCallback);

      expect(spy).toHaveBeenCalled();
      expect(mockCallback).toHaveBeenCalledWith(expect.any(Error));
    });
  });

  describe('webhook', () => {
    beforeEach(() => {
      jest.resetAllMocks();
    });

    it('should respond on success of processing event', async () => {
      const { webhook } = await import('./handler');

      const mockCallback = jest.fn();
      const event = {
        pathParameters: {
          key: 'dummywebhookkey',
        },
      };
      const expectedResponse = {
        statusCode: 400,
        body: JSON.stringify({ message: 'Invalid request made' }),
      };

      webhook(event, {}, mockCallback);

      expect(mockCallback).toHaveBeenCalledWith(null, expectedResponse);
    });

    it('should respond on unknown event', async () => {
      const { webhook } = await import('./handler');

      const mockCallback = jest.fn();
      const event = {
        pathParameters: {
          key: 'unknownkey',
        },
      };
      const expectedResponse = {
        statusCode: 400,
        body: JSON.stringify({ message: 'Invalid request made' }),
      };

      webhook(event, {}, mockCallback);

      expect(mockCallback).toHaveBeenCalledWith(null, expectedResponse);
    });
  });
});