]>
Commit | Line | Data |
---|---|---|
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ | |
2 | ||
3 | import 'mocha' | |
4 | import * as chai from 'chai' | |
5 | import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes' | |
6 | import { | |
7 | acceptChangeOwnership, | |
8 | changeVideoOwnership, | |
9 | cleanupTests, | |
10 | createLive, | |
11 | createUser, | |
12 | doubleFollow, | |
13 | flushAndRunMultipleServers, | |
14 | flushAndRunServer, | |
15 | getMyUserInformation, | |
16 | getVideo, | |
17 | getVideoChangeOwnershipList, | |
18 | getVideosList, | |
19 | refuseChangeOwnership, | |
20 | ServerInfo, | |
21 | setAccessTokensToServers, | |
22 | setDefaultVideoChannel, | |
23 | updateCustomSubConfig, | |
24 | uploadVideo, | |
25 | userLogin | |
26 | } from '../../../../shared/extra-utils' | |
27 | import { waitJobs } from '../../../../shared/extra-utils/server/jobs' | |
28 | import { User } from '../../../../shared/models/users' | |
29 | import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos' | |
30 | ||
31 | const expect = chai.expect | |
32 | ||
33 | describe('Test video change ownership - nominal', function () { | |
34 | let servers: ServerInfo[] = [] | |
35 | const firstUser = { | |
36 | username: 'first', | |
37 | password: 'My great password' | |
38 | } | |
39 | const secondUser = { | |
40 | username: 'second', | |
41 | password: 'My other password' | |
42 | } | |
43 | ||
44 | let firstUserAccessToken = '' | |
45 | let firstUserChannelId: number | |
46 | ||
47 | let secondUserAccessToken = '' | |
48 | let secondUserChannelId: number | |
49 | ||
50 | let lastRequestChangeOwnershipId = '' | |
51 | ||
52 | let liveId: number | |
53 | ||
54 | before(async function () { | |
55 | this.timeout(50000) | |
56 | ||
57 | servers = await flushAndRunMultipleServers(2) | |
58 | await setAccessTokensToServers(servers) | |
59 | await setDefaultVideoChannel(servers) | |
60 | ||
61 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, { | |
62 | transcoding: { | |
63 | enabled: false | |
64 | }, | |
65 | live: { | |
66 | enabled: true | |
67 | } | |
68 | }) | |
69 | ||
70 | const videoQuota = 42000000 | |
71 | await createUser({ | |
72 | url: servers[0].url, | |
73 | accessToken: servers[0].accessToken, | |
74 | username: firstUser.username, | |
75 | password: firstUser.password, | |
76 | videoQuota: videoQuota | |
77 | }) | |
78 | await createUser({ | |
79 | url: servers[0].url, | |
80 | accessToken: servers[0].accessToken, | |
81 | username: secondUser.username, | |
82 | password: secondUser.password, | |
83 | videoQuota: videoQuota | |
84 | }) | |
85 | ||
86 | firstUserAccessToken = await userLogin(servers[0], firstUser) | |
87 | secondUserAccessToken = await userLogin(servers[0], secondUser) | |
88 | ||
89 | { | |
90 | const res = await getMyUserInformation(servers[0].url, firstUserAccessToken) | |
91 | const firstUserInformation: User = res.body | |
92 | firstUserChannelId = firstUserInformation.videoChannels[0].id | |
93 | } | |
94 | ||
95 | { | |
96 | const res = await getMyUserInformation(servers[0].url, secondUserAccessToken) | |
97 | const secondUserInformation: User = res.body | |
98 | secondUserChannelId = secondUserInformation.videoChannels[0].id | |
99 | } | |
100 | ||
101 | { | |
102 | const videoAttributes = { | |
103 | name: 'my super name', | |
104 | description: 'my super description' | |
105 | } | |
106 | const res = await uploadVideo(servers[0].url, firstUserAccessToken, videoAttributes) | |
107 | ||
108 | const resVideo = await getVideo(servers[0].url, res.body.video.id) | |
109 | servers[0].video = resVideo.body | |
110 | } | |
111 | ||
112 | { | |
113 | const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC } | |
114 | const res = await createLive(servers[0].url, firstUserAccessToken, attributes) | |
115 | ||
116 | liveId = res.body.video.id | |
117 | } | |
118 | ||
119 | await doubleFollow(servers[0], servers[1]) | |
120 | }) | |
121 | ||
122 | it('Should not have video change ownership', async function () { | |
123 | const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken) | |
124 | ||
125 | expect(resFirstUser.body.total).to.equal(0) | |
126 | expect(resFirstUser.body.data).to.be.an('array') | |
127 | expect(resFirstUser.body.data.length).to.equal(0) | |
128 | ||
129 | const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken) | |
130 | ||
131 | expect(resSecondUser.body.total).to.equal(0) | |
132 | expect(resSecondUser.body.data).to.be.an('array') | |
133 | expect(resSecondUser.body.data.length).to.equal(0) | |
134 | }) | |
135 | ||
136 | it('Should send a request to change ownership of a video', async function () { | |
137 | this.timeout(15000) | |
138 | ||
139 | await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username) | |
140 | }) | |
141 | ||
142 | it('Should only return a request to change ownership for the second user', async function () { | |
143 | const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken) | |
144 | ||
145 | expect(resFirstUser.body.total).to.equal(0) | |
146 | expect(resFirstUser.body.data).to.be.an('array') | |
147 | expect(resFirstUser.body.data.length).to.equal(0) | |
148 | ||
149 | const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken) | |
150 | ||
151 | expect(resSecondUser.body.total).to.equal(1) | |
152 | expect(resSecondUser.body.data).to.be.an('array') | |
153 | expect(resSecondUser.body.data.length).to.equal(1) | |
154 | ||
155 | lastRequestChangeOwnershipId = resSecondUser.body.data[0].id | |
156 | }) | |
157 | ||
158 | it('Should accept the same change ownership request without crashing', async function () { | |
159 | this.timeout(10000) | |
160 | ||
161 | await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username) | |
162 | }) | |
163 | ||
164 | it('Should not create multiple change ownership requests while one is waiting', async function () { | |
165 | this.timeout(10000) | |
166 | ||
167 | const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken) | |
168 | ||
169 | expect(resSecondUser.body.total).to.equal(1) | |
170 | expect(resSecondUser.body.data).to.be.an('array') | |
171 | expect(resSecondUser.body.data.length).to.equal(1) | |
172 | }) | |
173 | ||
174 | it('Should not be possible to refuse the change of ownership from first user', async function () { | |
175 | this.timeout(10000) | |
176 | ||
177 | await refuseChangeOwnership(servers[0].url, firstUserAccessToken, lastRequestChangeOwnershipId, HttpStatusCode.FORBIDDEN_403) | |
178 | }) | |
179 | ||
180 | it('Should be possible to refuse the change of ownership from second user', async function () { | |
181 | this.timeout(10000) | |
182 | ||
183 | await refuseChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId) | |
184 | }) | |
185 | ||
186 | it('Should send a new request to change ownership of a video', async function () { | |
187 | this.timeout(15000) | |
188 | ||
189 | await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username) | |
190 | }) | |
191 | ||
192 | it('Should return two requests to change ownership for the second user', async function () { | |
193 | const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken) | |
194 | ||
195 | expect(resFirstUser.body.total).to.equal(0) | |
196 | expect(resFirstUser.body.data).to.be.an('array') | |
197 | expect(resFirstUser.body.data.length).to.equal(0) | |
198 | ||
199 | const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken) | |
200 | ||
201 | expect(resSecondUser.body.total).to.equal(2) | |
202 | expect(resSecondUser.body.data).to.be.an('array') | |
203 | expect(resSecondUser.body.data.length).to.equal(2) | |
204 | ||
205 | lastRequestChangeOwnershipId = resSecondUser.body.data[0].id | |
206 | }) | |
207 | ||
208 | it('Should not be possible to accept the change of ownership from first user', async function () { | |
209 | this.timeout(10000) | |
210 | ||
211 | await acceptChangeOwnership( | |
212 | servers[0].url, | |
213 | firstUserAccessToken, | |
214 | lastRequestChangeOwnershipId, | |
215 | secondUserChannelId, | |
216 | HttpStatusCode.FORBIDDEN_403 | |
217 | ) | |
218 | }) | |
219 | ||
220 | it('Should be possible to accept the change of ownership from second user', async function () { | |
221 | this.timeout(10000) | |
222 | ||
223 | await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId) | |
224 | ||
225 | await waitJobs(servers) | |
226 | }) | |
227 | ||
228 | it('Should have the channel of the video updated', async function () { | |
229 | for (const server of servers) { | |
230 | const res = await getVideo(server.url, servers[0].video.uuid) | |
231 | ||
232 | const video: VideoDetails = res.body | |
233 | ||
234 | expect(video.name).to.equal('my super name') | |
235 | expect(video.channel.displayName).to.equal('Main second channel') | |
236 | expect(video.channel.name).to.equal('second_channel') | |
237 | } | |
238 | }) | |
239 | ||
240 | it('Should send a request to change ownership of a live', async function () { | |
241 | this.timeout(15000) | |
242 | ||
243 | await changeVideoOwnership(servers[0].url, firstUserAccessToken, liveId, secondUser.username) | |
244 | ||
245 | const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken) | |
246 | ||
247 | expect(resSecondUser.body.total).to.equal(3) | |
248 | expect(resSecondUser.body.data.length).to.equal(3) | |
249 | ||
250 | lastRequestChangeOwnershipId = resSecondUser.body.data[0].id | |
251 | }) | |
252 | ||
253 | it('Should accept a live ownership change', async function () { | |
254 | this.timeout(20000) | |
255 | ||
256 | await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId) | |
257 | ||
258 | await waitJobs(servers) | |
259 | ||
260 | for (const server of servers) { | |
261 | const res = await getVideo(server.url, servers[0].video.uuid) | |
262 | ||
263 | const video: VideoDetails = res.body | |
264 | ||
265 | expect(video.name).to.equal('my super name') | |
266 | expect(video.channel.displayName).to.equal('Main second channel') | |
267 | expect(video.channel.name).to.equal('second_channel') | |
268 | } | |
269 | }) | |
270 | ||
271 | after(async function () { | |
272 | await cleanupTests(servers) | |
273 | }) | |
274 | }) | |
275 | ||
276 | describe('Test video change ownership - quota too small', function () { | |
277 | let server: ServerInfo | |
278 | const firstUser = { | |
279 | username: 'first', | |
280 | password: 'My great password' | |
281 | } | |
282 | const secondUser = { | |
283 | username: 'second', | |
284 | password: 'My other password' | |
285 | } | |
286 | let firstUserAccessToken = '' | |
287 | let secondUserAccessToken = '' | |
288 | let lastRequestChangeOwnershipId = '' | |
289 | ||
290 | before(async function () { | |
291 | this.timeout(50000) | |
292 | ||
293 | // Run one server | |
294 | server = await flushAndRunServer(1) | |
295 | await setAccessTokensToServers([ server ]) | |
296 | ||
297 | const videoQuota = 42000000 | |
298 | const limitedVideoQuota = 10 | |
299 | await createUser({ | |
300 | url: server.url, | |
301 | accessToken: server.accessToken, | |
302 | username: firstUser.username, | |
303 | password: firstUser.password, | |
304 | videoQuota: videoQuota | |
305 | }) | |
306 | await createUser({ | |
307 | url: server.url, | |
308 | accessToken: server.accessToken, | |
309 | username: secondUser.username, | |
310 | password: secondUser.password, | |
311 | videoQuota: limitedVideoQuota | |
312 | }) | |
313 | ||
314 | firstUserAccessToken = await userLogin(server, firstUser) | |
315 | secondUserAccessToken = await userLogin(server, secondUser) | |
316 | ||
317 | // Upload some videos on the server | |
318 | const video1Attributes = { | |
319 | name: 'my super name', | |
320 | description: 'my super description' | |
321 | } | |
322 | await uploadVideo(server.url, firstUserAccessToken, video1Attributes) | |
323 | ||
324 | await waitJobs(server) | |
325 | ||
326 | const res = await getVideosList(server.url) | |
327 | const videos = res.body.data | |
328 | ||
329 | expect(videos.length).to.equal(1) | |
330 | ||
331 | server.video = videos.find(video => video.name === 'my super name') | |
332 | }) | |
333 | ||
334 | it('Should send a request to change ownership of a video', async function () { | |
335 | this.timeout(15000) | |
336 | ||
337 | await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username) | |
338 | }) | |
339 | ||
340 | it('Should only return a request to change ownership for the second user', async function () { | |
341 | const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken) | |
342 | ||
343 | expect(resFirstUser.body.total).to.equal(0) | |
344 | expect(resFirstUser.body.data).to.be.an('array') | |
345 | expect(resFirstUser.body.data.length).to.equal(0) | |
346 | ||
347 | const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken) | |
348 | ||
349 | expect(resSecondUser.body.total).to.equal(1) | |
350 | expect(resSecondUser.body.data).to.be.an('array') | |
351 | expect(resSecondUser.body.data.length).to.equal(1) | |
352 | ||
353 | lastRequestChangeOwnershipId = resSecondUser.body.data[0].id | |
354 | }) | |
355 | ||
356 | it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () { | |
357 | this.timeout(10000) | |
358 | ||
359 | const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken) | |
360 | const secondUserInformation: User = secondUserInformationResponse.body | |
361 | const channelId = secondUserInformation.videoChannels[0].id | |
362 | ||
363 | await acceptChangeOwnership( | |
364 | server.url, | |
365 | secondUserAccessToken, | |
366 | lastRequestChangeOwnershipId, | |
367 | channelId, | |
368 | HttpStatusCode.PAYLOAD_TOO_LARGE_413 | |
369 | ) | |
370 | }) | |
371 | ||
372 | after(async function () { | |
373 | await cleanupTests([ server ]) | |
374 | }) | |
375 | }) |