notes.api/src/presentation/http/router/join.test.ts at a6c53a55f2d227a952b375e75d8eea5d3fd32081 · codex-team/notes.api · 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
import { describe, test, expect } from 'vitest';

describe('Join API', () => {
  describe('POST /join/:hash', () => {
    test('Returns 406 when user is already in the team', async () => {
      const invitationHash = 'Hzh2hy4igf';

      /**
       * Truncate all tables, which are needed
       * Restart autoincrement sequences for data to start with id 1
       *
       * TODO get rid of restarting database data in tests (move to beforeEach)
       */
      await global.db.truncateTables();

      /** create test user */
      const user = await global.db.insertUser();

      /** create test note for created user */
      const note = await global.db.insertNote({
        creatorId: user.id,
      });

      /** create test note-settings for created note */
      await global.db.insertNoteSetting({
        noteId: note.id,
        isPublic: true,
        invitationHash,
      });

      await global.db.insertNoteTeam({
        userId: user.id,
        noteId: note.id,
        role: 0,
      });

      const accessToken = global.auth(user.id);

      /** add same user to the same note team */
      const response = await global.api?.fakeRequest({
        method: 'POST',
        headers: {
          authorization: `Bearer ${accessToken}`,
        },
        body: { invitationHash },
        url: `/join/${invitationHash}`,
      });

      expect(response?.statusCode).toBe(406);

      expect(response?.json()).toStrictEqual({
        message: 'User already in team',
      });
    });
    test('Returns 406 when invitation hash is not valid', async () => {
      const hash = 'Jih23y4igf';
      const userId = 4;
      const accessToken = global.auth(userId);

      const response = await global.api?.fakeRequest({
        method: 'POST',
        headers: {
          authorization: `Bearer ${accessToken}`,
        },
        body: { hash },
        url: `/join/${hash}`,
      });

      expect(response?.statusCode).toBe(406);

      expect(response?.json()).toStrictEqual({
        message: `Wrong invitation`,
      });
    });

    test('Returns 200 when user is added to the team', async () => {
      const invitationHash = 'Hzh2hy4igf';

      /**
       * truncate all tables, which are needed
       * restart autoincrement sequences for data to start with id 1
       *
       * TODO get rid of restarting database data in tests (move to beforeEach)
       */
      await global.db.truncateTables();

      /** create test user */
      const creator = await global.db.insertUser();

      const randomGuy = await global.db.insertUser();


      /** create test note for created user */
      const note = await global.db.insertNote({
        creatorId: creator.id,
      });

      /** create test note-settings for created note */
      await global.db.insertNoteSetting({
        noteId: note.id,
        isPublic: true,
        invitationHash,
      });

      const accessToken = global.auth(randomGuy.id);

      const response = await global.api?.fakeRequest({
        method: 'POST',
        headers: {
          authorization: `Bearer ${accessToken}`,
        },
        body: { invitationHash },
        url: `/join/${invitationHash}`,
      });

      expect(response?.statusCode).toBe(200);

      expect(response?.json()).toMatchObject({
        result: {
          userId: randomGuy.id,
          noteId: note.id,
          role: 0,
        },
      });
    });
  });
});