universo-platform-3d

1
import { INestApplication } from '@nestjs/common'
2
import { Test, TestingModule } from '@nestjs/testing'
3
import request from 'supertest'
4
import { beforeAll, describe, it, vi } from 'vitest'
5
import {
6
  AuthGuardFirebase,
7
  FirebaseTokenAuthGuard
8
} from '../src/auth/auth.guard'
9
import { FirebaseAuthenticationService } from '../src/firebase/firebase-authentication.service'
10
import { ScriptEntityController } from '../src/script-entity/script-entity.controller'
11
import {
12
  ScriptEntity,
13
  ScriptEntityDocument
14
} from '../src/script-entity/script-entity.schema'
15
import { ScriptEntityService } from '../src/script-entity/script-entity.service'
16
import { FileUploadService } from '../src/util/file-upload/file-upload.service'
17
import { LoggerModule } from '../src/util/logger/logger.module'
18
import {
19
  MockScriptEntityService,
20
  getMockClassesForProvidersArray
21
} from './mocks/service.mocks'
22

23
describe('Script-Entity Controller With Guard (Integration)', () => {
24
  let app: INestApplication
25
  let service: ScriptEntityService
26
  const id = 'some-id'
27

28
  beforeAll(async () => {
29
    const moduleFixture: TestingModule = await Test.createTestingModule({
30
      imports: [LoggerModule],
31
      controllers: [ScriptEntityController],
32
      providers: [
33
        ...getMockClassesForProvidersArray([
34
          FirebaseAuthenticationService,
35
          ScriptEntityService,
36
          FileUploadService
37
        ])
38
      ]
39
    })
40
      // Note: guard is NOT overridden here
41
      .compile()
42

43
    app = moduleFixture.createNestApplication()
44
    await app.init()
45

46
    service = moduleFixture.get(ScriptEntityService)
47
  })
48

49
  describe('Auth required endpoints', () => {
50
    it('should fail findOne without firebase auth', () => {
51
      return request(app.getHttpServer())
52
        .get(`/script-entity/${id}`)
53
        .expect(403)
54
    })
55
    it('should fail create without firebase auth', () => {
56
      return request(app.getHttpServer()).post('/script-entity').expect(403)
57
    })
58
    it('should fail update without firebase auth', () => {
59
      return request(app.getHttpServer())
60
        .patch(`/script-entity/${id}`)
61
        .expect(403)
62
    })
63
    it('should fail delete without firebase auth', () => {
64
      return request(app.getHttpServer())
65
        .delete(`/script-entity/${id}`)
66
        .expect(403)
67
    })
68
  })
69
})
70

71
describe('Script-Entity Controller WITHOUT Guard (Integration)', () => {
72
  let app: INestApplication
73
  let service: ScriptEntityService
74
  // Modify mockEntity as needed for the test
75
  const id = 'some-id'
76
  const mockEntity: ScriptEntity = {
77
    blocks: [{ foo: 'bar' }],
78
    _id: id
79
  }
80

81
  beforeAll(async () => {
82
    const moduleFixture: TestingModule = await Test.createTestingModule({
83
      controllers: [ScriptEntityController],
84
      providers: [
85
        {
86
          provide: ScriptEntityService,
87
          useClass: MockScriptEntityService
88
        },
89
        ...getMockClassesForProvidersArray([
90
          FirebaseAuthenticationService,
91
          FileUploadService
92
        ])
93
      ]
94
    })
95
      .overrideGuard(AuthGuardFirebase)
96
      .useValue({
97
        canActivate: () => true
98
      })
99
      .overrideGuard(FirebaseTokenAuthGuard)
100
      .useValue({
101
        canActivate: () => true
102
      })
103
      .compile()
104

105
    app = moduleFixture.createNestApplication()
106
    await app.init()
107

108
    service = moduleFixture.get(ScriptEntityService)
109
  })
110

111
  it('find one by ID', async () => {
112
    // Arrange
113
    vi.spyOn(service, 'findOne').mockResolvedValue(
114
      mockEntity as ScriptEntityDocument
115
    )
116

117
    // Act
118
    await request(app.getHttpServer())
119
      .get(`/script-entity/${id}`)
120

121
      // Assert
122
      .expect(200)
123
      .expect(await service.findOne('some-id'))
124
  })
125

126
  it('create one', async () => {
127
    // Arrange
128
    vi.spyOn(service, 'create').mockResolvedValue(
129
      mockEntity as ScriptEntityDocument
130
    )
131

132
    // Act
133
    await request(app.getHttpServer())
134
      .post('/script-entity')
135
      .send(mockEntity)
136

137
      // Assert
138
      .expect(201)
139
      .expect(await service.create(mockEntity))
140
  })
141

142
  it('should update one with an id', async () => {
143
    // Arrange
144
    vi.spyOn(service, 'update').mockResolvedValue(
145
      mockEntity as ScriptEntityDocument
146
    )
147

148
    // Act
149
    await request(app.getHttpServer())
150
      .patch(`/script-entity/${id}`)
151
      .send(mockEntity)
152

153
      // Assert
154
      .expect(200)
155
      .expect(await service.update(id, mockEntity))
156
  })
157

158
  it('should delete one by id', async () => {
159
    // Arrange
160
    vi.spyOn(service, 'delete').mockResolvedValue(
161
      mockEntity as ScriptEntityDocument
162
    )
163

164
    // Act
165
    await request(app.getHttpServer())
166
      .delete(`/script-entity/${id}`)
167

168
      // Assert
169
      .expect(200)
170
      .expect(await service.delete(id))
171
  })
172
})
173