aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/tests
diff options
context:
space:
mode:
authorChocobozzz <me@florianbigard.com>2020-06-16 15:52:05 +0200
committerChocobozzz <me@florianbigard.com>2020-06-16 15:55:42 +0200
commit8eb07b01306429abe5c538ff7aa0a16e44fff26f (patch)
treeaa6461099e0652a54c9f49ecd5652f3ddfcc0fc1 /server/tests
parent1ba471c55fdbf05ef2c10152b3e4b0c5d8da3213 (diff)
downloadPeerTube-8eb07b01306429abe5c538ff7aa0a16e44fff26f.tar.gz
PeerTube-8eb07b01306429abe5c538ff7aa0a16e44fff26f.tar.zst
PeerTube-8eb07b01306429abe5c538ff7aa0a16e44fff26f.zip
Split notification tests
Diffstat (limited to 'server/tests')
-rw-r--r--server/tests/api/notifications/comments-notifications.ts309
-rw-r--r--server/tests/api/notifications/index.ts3
-rw-r--r--server/tests/api/notifications/moderation-notifications.ts439
-rw-r--r--server/tests/api/notifications/notifications-api.ts205
-rw-r--r--server/tests/api/notifications/user-notifications.ts989
-rw-r--r--server/tests/api/videos/video-channels.ts4
6 files changed, 996 insertions, 953 deletions
diff --git a/server/tests/api/notifications/comments-notifications.ts b/server/tests/api/notifications/comments-notifications.ts
new file mode 100644
index 000000000..cd3ed2f70
--- /dev/null
+++ b/server/tests/api/notifications/comments-notifications.ts
@@ -0,0 +1,309 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import 'mocha'
4import * as chai from 'chai'
5import { cleanupTests, getVideoCommentThreads, getVideoThreadComments, updateMyUser, wait } from '../../../../shared/extra-utils'
6import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
7import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
8import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
9import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/extra-utils/users/blocklist'
10import {
11 checkCommentMention,
12 CheckerBaseParams,
13 checkNewCommentOnMyVideo,
14 prepareNotificationsTest
15} from '../../../../shared/extra-utils/users/user-notifications'
16import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
17import { UserNotification } from '../../../../shared/models/users'
18import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
19
20const expect = chai.expect
21
22describe('Test comments notifications', function () {
23 let servers: ServerInfo[] = []
24 let userAccessToken: string
25 let userNotifications: UserNotification[] = []
26 let emails: object[] = []
27
28 before(async function () {
29 this.timeout(120000)
30
31 const res = await prepareNotificationsTest(2)
32 emails = res.emails
33 userAccessToken = res.userAccessToken
34 servers = res.servers
35 userNotifications = res.userNotifications
36 })
37
38 describe('Comment on my video notifications', function () {
39 let baseParams: CheckerBaseParams
40
41 before(() => {
42 baseParams = {
43 server: servers[0],
44 emails,
45 socketNotifications: userNotifications,
46 token: userAccessToken
47 }
48 })
49
50 it('Should not send a new comment notification after a comment on another video', async function () {
51 this.timeout(10000)
52
53 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
54 const uuid = resVideo.body.video.uuid
55
56 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
57 const commentId = resComment.body.comment.id
58
59 await wait(500)
60 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
61 })
62
63 it('Should not send a new comment notification if I comment my own video', async function () {
64 this.timeout(10000)
65
66 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
67 const uuid = resVideo.body.video.uuid
68
69 const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment')
70 const commentId = resComment.body.comment.id
71
72 await wait(500)
73 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
74 })
75
76 it('Should not send a new comment notification if the account is muted', async function () {
77 this.timeout(10000)
78
79 await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
80
81 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
82 const uuid = resVideo.body.video.uuid
83
84 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
85 const commentId = resComment.body.comment.id
86
87 await wait(500)
88 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
89
90 await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
91 })
92
93 it('Should send a new comment notification after a local comment on my video', async function () {
94 this.timeout(10000)
95
96 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
97 const uuid = resVideo.body.video.uuid
98
99 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
100 const commentId = resComment.body.comment.id
101
102 await wait(500)
103 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
104 })
105
106 it('Should send a new comment notification after a remote comment on my video', async function () {
107 this.timeout(10000)
108
109 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
110 const uuid = resVideo.body.video.uuid
111
112 await waitJobs(servers)
113
114 await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
115
116 await waitJobs(servers)
117
118 const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
119 expect(resComment.body.data).to.have.lengthOf(1)
120 const commentId = resComment.body.data[0].id
121
122 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
123 })
124
125 it('Should send a new comment notification after a local reply on my video', async function () {
126 this.timeout(10000)
127
128 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
129 const uuid = resVideo.body.video.uuid
130
131 const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
132 const threadId = resThread.body.comment.id
133
134 const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply')
135 const commentId = resComment.body.comment.id
136
137 await wait(500)
138 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
139 })
140
141 it('Should send a new comment notification after a remote reply on my video', async function () {
142 this.timeout(10000)
143
144 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
145 const uuid = resVideo.body.video.uuid
146 await waitJobs(servers)
147
148 {
149 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
150 const threadId = resThread.body.comment.id
151 await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply')
152 }
153
154 await waitJobs(servers)
155
156 const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
157 expect(resThread.body.data).to.have.lengthOf(1)
158 const threadId = resThread.body.data[0].id
159
160 const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId)
161 const tree = resComments.body as VideoCommentThreadTree
162
163 expect(tree.children).to.have.lengthOf(1)
164 const commentId = tree.children[0].comment.id
165
166 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
167 })
168 })
169
170 describe('Mention notifications', function () {
171 let baseParams: CheckerBaseParams
172
173 before(async () => {
174 baseParams = {
175 server: servers[0],
176 emails,
177 socketNotifications: userNotifications,
178 token: userAccessToken
179 }
180
181 await updateMyUser({
182 url: servers[0].url,
183 accessToken: servers[0].accessToken,
184 displayName: 'super root name'
185 })
186
187 await updateMyUser({
188 url: servers[1].url,
189 accessToken: servers[1].accessToken,
190 displayName: 'super root 2 name'
191 })
192 })
193
194 it('Should not send a new mention comment notification if I mention the video owner', async function () {
195 this.timeout(10000)
196
197 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
198 const uuid = resVideo.body.video.uuid
199
200 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
201 const commentId = resComment.body.comment.id
202
203 await wait(500)
204 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
205 })
206
207 it('Should not send a new mention comment notification if I mention myself', async function () {
208 this.timeout(10000)
209
210 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
211 const uuid = resVideo.body.video.uuid
212
213 const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello')
214 const commentId = resComment.body.comment.id
215
216 await wait(500)
217 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
218 })
219
220 it('Should not send a new mention notification if the account is muted', async function () {
221 this.timeout(10000)
222
223 await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
224
225 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
226 const uuid = resVideo.body.video.uuid
227
228 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
229 const commentId = resComment.body.comment.id
230
231 await wait(500)
232 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
233
234 await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
235 })
236
237 it('Should not send a new mention notification if the remote account mention a local account', async function () {
238 this.timeout(20000)
239
240 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
241 const uuid = resVideo.body.video.uuid
242
243 await waitJobs(servers)
244 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello')
245 const threadId = resThread.body.comment.id
246
247 await waitJobs(servers)
248 await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence')
249 })
250
251 it('Should send a new mention notification after local comments', async function () {
252 this.timeout(10000)
253
254 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
255 const uuid = resVideo.body.video.uuid
256
257 const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
258 const threadId = resThread.body.comment.id
259
260 await wait(500)
261 await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence')
262
263 const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1')
264 const commentId = resComment.body.comment.id
265
266 await wait(500)
267 await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence')
268 })
269
270 it('Should send a new mention notification after remote comments', async function () {
271 this.timeout(20000)
272
273 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
274 const uuid = resVideo.body.video.uuid
275
276 await waitJobs(servers)
277
278 const text1 = `hello @user_1@localhost:${servers[0].port} 1`
279 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, text1)
280 const server2ThreadId = resThread.body.comment.id
281
282 await waitJobs(servers)
283
284 const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
285 expect(resThread2.body.data).to.have.lengthOf(1)
286 const server1ThreadId = resThread2.body.data[0].id
287 await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence')
288
289 const text2 = `@user_1@localhost:${servers[0].port} hello 2 @root@localhost:${servers[0].port}`
290 await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text2)
291
292 await waitJobs(servers)
293
294 const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId)
295 const tree = resComments.body as VideoCommentThreadTree
296
297 expect(tree.children).to.have.lengthOf(1)
298 const commentId = tree.children[0].comment.id
299
300 await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence')
301 })
302 })
303
304 after(async function () {
305 MockSmtpServer.Instance.kill()
306
307 await cleanupTests(servers)
308 })
309})
diff --git a/server/tests/api/notifications/index.ts b/server/tests/api/notifications/index.ts
index b573f850e..bd07a339e 100644
--- a/server/tests/api/notifications/index.ts
+++ b/server/tests/api/notifications/index.ts
@@ -1 +1,4 @@
1import './comments-notifications'
2import './moderation-notifications'
3import './notifications-api'
1import './user-notifications' 4import './user-notifications'
diff --git a/server/tests/api/notifications/moderation-notifications.ts b/server/tests/api/notifications/moderation-notifications.ts
new file mode 100644
index 000000000..b90732a7a
--- /dev/null
+++ b/server/tests/api/notifications/moderation-notifications.ts
@@ -0,0 +1,439 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import 'mocha'
4import { v4 as uuidv4 } from 'uuid'
5import {
6 addVideoToBlacklist,
7 cleanupTests,
8 follow,
9 getCustomConfig,
10 immutableAssign,
11 MockInstancesIndex,
12 registerUser,
13 removeVideoFromBlacklist,
14 reportVideoAbuse,
15 unfollow,
16 updateCustomConfig,
17 updateCustomSubConfig,
18 wait
19} from '../../../../shared/extra-utils'
20import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
21import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
22import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
23import {
24 checkAutoInstanceFollowing,
25 CheckerBaseParams,
26 checkNewBlacklistOnMyVideo,
27 checkNewInstanceFollower,
28 checkNewVideoAbuseForModerators,
29 checkNewVideoFromSubscription,
30 checkUserRegistered,
31 checkVideoAutoBlacklistForModerators,
32 checkVideoIsPublished,
33 prepareNotificationsTest
34} from '../../../../shared/extra-utils/users/user-notifications'
35import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions'
36import { CustomConfig } from '../../../../shared/models/server'
37import { UserNotification } from '../../../../shared/models/users'
38import { VideoPrivacy } from '../../../../shared/models/videos'
39
40describe('Test moderation notifications', function () {
41 let servers: ServerInfo[] = []
42 let userAccessToken: string
43 let userNotifications: UserNotification[] = []
44 let adminNotifications: UserNotification[] = []
45 let adminNotificationsServer2: UserNotification[] = []
46 let emails: object[] = []
47
48 before(async function () {
49 this.timeout(120000)
50
51 const res = await prepareNotificationsTest(3)
52 emails = res.emails
53 userAccessToken = res.userAccessToken
54 servers = res.servers
55 userNotifications = res.userNotifications
56 adminNotifications = res.adminNotifications
57 adminNotificationsServer2 = res.adminNotificationsServer2
58 })
59
60 describe('Video abuse for moderators notification', function () {
61 let baseParams: CheckerBaseParams
62
63 before(() => {
64 baseParams = {
65 server: servers[0],
66 emails,
67 socketNotifications: adminNotifications,
68 token: servers[0].accessToken
69 }
70 })
71
72 it('Should send a notification to moderators on local video abuse', async function () {
73 this.timeout(10000)
74
75 const name = 'video for abuse ' + uuidv4()
76 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
77 const uuid = resVideo.body.video.uuid
78
79 await reportVideoAbuse(servers[0].url, servers[0].accessToken, uuid, 'super reason')
80
81 await waitJobs(servers)
82 await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
83 })
84
85 it('Should send a notification to moderators on remote video abuse', async function () {
86 this.timeout(10000)
87
88 const name = 'video for abuse ' + uuidv4()
89 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
90 const uuid = resVideo.body.video.uuid
91
92 await waitJobs(servers)
93
94 await reportVideoAbuse(servers[1].url, servers[1].accessToken, uuid, 'super reason')
95
96 await waitJobs(servers)
97 await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
98 })
99 })
100
101 describe('Video blacklist on my video', function () {
102 let baseParams: CheckerBaseParams
103
104 before(() => {
105 baseParams = {
106 server: servers[0],
107 emails,
108 socketNotifications: userNotifications,
109 token: userAccessToken
110 }
111 })
112
113 it('Should send a notification to video owner on blacklist', async function () {
114 this.timeout(10000)
115
116 const name = 'video for abuse ' + uuidv4()
117 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
118 const uuid = resVideo.body.video.uuid
119
120 await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
121
122 await waitJobs(servers)
123 await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist')
124 })
125
126 it('Should send a notification to video owner on unblacklist', async function () {
127 this.timeout(10000)
128
129 const name = 'video for abuse ' + uuidv4()
130 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
131 const uuid = resVideo.body.video.uuid
132
133 await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
134
135 await waitJobs(servers)
136 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
137 await waitJobs(servers)
138
139 await wait(500)
140 await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist')
141 })
142 })
143
144 describe('New registration', function () {
145 let baseParams: CheckerBaseParams
146
147 before(() => {
148 baseParams = {
149 server: servers[0],
150 emails,
151 socketNotifications: adminNotifications,
152 token: servers[0].accessToken
153 }
154 })
155
156 it('Should send a notification only to moderators when a user registers on the instance', async function () {
157 this.timeout(10000)
158
159 await registerUser(servers[0].url, 'user_45', 'password')
160
161 await waitJobs(servers)
162
163 await checkUserRegistered(baseParams, 'user_45', 'presence')
164
165 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
166 await checkUserRegistered(immutableAssign(baseParams, userOverride), 'user_45', 'absence')
167 })
168 })
169
170 describe('New instance follows', function () {
171 const instanceIndexServer = new MockInstancesIndex()
172 const config = {
173 followings: {
174 instance: {
175 autoFollowIndex: {
176 indexUrl: 'http://localhost:42101/api/v1/instances/hosts',
177 enabled: true
178 }
179 }
180 }
181 }
182 let baseParams: CheckerBaseParams
183
184 before(async () => {
185 baseParams = {
186 server: servers[0],
187 emails,
188 socketNotifications: adminNotifications,
189 token: servers[0].accessToken
190 }
191
192 await instanceIndexServer.initialize()
193 instanceIndexServer.addInstance(servers[1].host)
194 })
195
196 it('Should send a notification only to admin when there is a new instance follower', async function () {
197 this.timeout(20000)
198
199 await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
200
201 await waitJobs(servers)
202
203 await checkNewInstanceFollower(baseParams, 'localhost:' + servers[2].port, 'presence')
204
205 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
206 await checkNewInstanceFollower(immutableAssign(baseParams, userOverride), 'localhost:' + servers[2].port, 'absence')
207 })
208
209 it('Should send a notification on auto follow back', async function () {
210 this.timeout(40000)
211
212 await unfollow(servers[2].url, servers[2].accessToken, servers[0])
213 await waitJobs(servers)
214
215 const config = {
216 followings: {
217 instance: {
218 autoFollowBack: { enabled: true }
219 }
220 }
221 }
222 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
223
224 await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
225
226 await waitJobs(servers)
227
228 const followerHost = servers[0].host
229 const followingHost = servers[2].host
230 await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
231
232 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
233 await checkAutoInstanceFollowing(immutableAssign(baseParams, userOverride), followerHost, followingHost, 'absence')
234
235 config.followings.instance.autoFollowBack.enabled = false
236 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
237 await unfollow(servers[0].url, servers[0].accessToken, servers[2])
238 await unfollow(servers[2].url, servers[2].accessToken, servers[0])
239 })
240
241 it('Should send a notification on auto instances index follow', async function () {
242 this.timeout(30000)
243 await unfollow(servers[0].url, servers[0].accessToken, servers[1])
244
245 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
246
247 await wait(5000)
248 await waitJobs(servers)
249
250 const followerHost = servers[0].host
251 const followingHost = servers[1].host
252 await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
253
254 config.followings.instance.autoFollowIndex.enabled = false
255 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
256 await unfollow(servers[0].url, servers[0].accessToken, servers[1])
257 })
258 })
259
260 describe('Video-related notifications when video auto-blacklist is enabled', function () {
261 let userBaseParams: CheckerBaseParams
262 let adminBaseParamsServer1: CheckerBaseParams
263 let adminBaseParamsServer2: CheckerBaseParams
264 let videoUUID: string
265 let videoName: string
266 let currentCustomConfig: CustomConfig
267
268 before(async () => {
269
270 adminBaseParamsServer1 = {
271 server: servers[0],
272 emails,
273 socketNotifications: adminNotifications,
274 token: servers[0].accessToken
275 }
276
277 adminBaseParamsServer2 = {
278 server: servers[1],
279 emails,
280 socketNotifications: adminNotificationsServer2,
281 token: servers[1].accessToken
282 }
283
284 userBaseParams = {
285 server: servers[0],
286 emails,
287 socketNotifications: userNotifications,
288 token: userAccessToken
289 }
290
291 const resCustomConfig = await getCustomConfig(servers[0].url, servers[0].accessToken)
292 currentCustomConfig = resCustomConfig.body
293 const autoBlacklistTestsCustomConfig = immutableAssign(currentCustomConfig, {
294 autoBlacklist: {
295 videos: {
296 ofUsers: {
297 enabled: true
298 }
299 }
300 }
301 })
302 // enable transcoding otherwise own publish notification after transcoding not expected
303 autoBlacklistTestsCustomConfig.transcoding.enabled = true
304 await updateCustomConfig(servers[0].url, servers[0].accessToken, autoBlacklistTestsCustomConfig)
305
306 await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
307 await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
308
309 })
310
311 it('Should send notification to moderators on new video with auto-blacklist', async function () {
312 this.timeout(20000)
313
314 videoName = 'video with auto-blacklist ' + uuidv4()
315 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
316 videoUUID = resVideo.body.video.uuid
317
318 await waitJobs(servers)
319 await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, videoUUID, videoName, 'presence')
320 })
321
322 it('Should not send video publish notification if auto-blacklisted', async function () {
323 await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'absence')
324 })
325
326 it('Should not send a local user subscription notification if auto-blacklisted', async function () {
327 await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'absence')
328 })
329
330 it('Should not send a remote user subscription notification if auto-blacklisted', async function () {
331 await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'absence')
332 })
333
334 it('Should send video published and unblacklist after video unblacklisted', async function () {
335 this.timeout(20000)
336
337 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoUUID)
338
339 await waitJobs(servers)
340
341 // FIXME: Can't test as two notifications sent to same user and util only checks last one
342 // One notification might be better anyways
343 // await checkNewBlacklistOnMyVideo(userBaseParams, videoUUID, videoName, 'unblacklist')
344 // await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'presence')
345 })
346
347 it('Should send a local user subscription notification after removed from blacklist', async function () {
348 await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'presence')
349 })
350
351 it('Should send a remote user subscription notification after removed from blacklist', async function () {
352 await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'presence')
353 })
354
355 it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () {
356 this.timeout(20000)
357
358 const updateAt = new Date(new Date().getTime() + 1000000)
359
360 const name = 'video with auto-blacklist and future schedule ' + uuidv4()
361
362 const data = {
363 name,
364 privacy: VideoPrivacy.PRIVATE,
365 scheduleUpdate: {
366 updateAt: updateAt.toISOString(),
367 privacy: VideoPrivacy.PUBLIC
368 }
369 }
370
371 const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
372 const uuid = resVideo.body.video.uuid
373
374 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
375
376 await waitJobs(servers)
377 await checkNewBlacklistOnMyVideo(userBaseParams, uuid, name, 'unblacklist')
378
379 // FIXME: Can't test absence as two notifications sent to same user and util only checks last one
380 // One notification might be better anyways
381 // await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
382
383 await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
384 await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
385 })
386
387 it('Should not send publish/subscription notifications after scheduled update if video still auto-blacklisted', async function () {
388 this.timeout(20000)
389
390 // In 2 seconds
391 const updateAt = new Date(new Date().getTime() + 2000)
392
393 const name = 'video with schedule done and still auto-blacklisted ' + uuidv4()
394
395 const data = {
396 name,
397 privacy: VideoPrivacy.PRIVATE,
398 scheduleUpdate: {
399 updateAt: updateAt.toISOString(),
400 privacy: VideoPrivacy.PUBLIC
401 }
402 }
403
404 const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
405 const uuid = resVideo.body.video.uuid
406
407 await wait(6000)
408 await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
409 await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
410 await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
411 })
412
413 it('Should not send a notification to moderators on new video without auto-blacklist', async function () {
414 this.timeout(20000)
415
416 const name = 'video without auto-blacklist ' + uuidv4()
417
418 // admin with blacklist right will not be auto-blacklisted
419 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name })
420 const uuid = resVideo.body.video.uuid
421
422 await waitJobs(servers)
423 await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, uuid, name, 'absence')
424 })
425
426 after(async () => {
427 await updateCustomConfig(servers[0].url, servers[0].accessToken, currentCustomConfig)
428
429 await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
430 await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
431 })
432 })
433
434 after(async function () {
435 MockSmtpServer.Instance.kill()
436
437 await cleanupTests(servers)
438 })
439})
diff --git a/server/tests/api/notifications/notifications-api.ts b/server/tests/api/notifications/notifications-api.ts
new file mode 100644
index 000000000..b81995449
--- /dev/null
+++ b/server/tests/api/notifications/notifications-api.ts
@@ -0,0 +1,205 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import 'mocha'
4import * as chai from 'chai'
5import { addUserSubscription } from '@shared/extra-utils/users/user-subscriptions'
6import { cleanupTests, getMyUserInformation, immutableAssign, uploadRandomVideo, waitJobs } from '../../../../shared/extra-utils'
7import { ServerInfo } from '../../../../shared/extra-utils/index'
8import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
9import {
10 CheckerBaseParams,
11 checkNewVideoFromSubscription,
12 getAllNotificationsSettings,
13 getUserNotifications,
14 markAsReadAllNotifications,
15 markAsReadNotifications,
16 prepareNotificationsTest,
17 updateMyNotificationSettings
18} from '../../../../shared/extra-utils/users/user-notifications'
19import { User, UserNotification, UserNotificationSettingValue } from '../../../../shared/models/users'
20
21const expect = chai.expect
22
23describe('Test notifications API', function () {
24 let server: ServerInfo
25 let userNotifications: UserNotification[] = []
26 let userAccessToken: string
27 let emails: object[] = []
28
29 before(async function () {
30 this.timeout(120000)
31
32 const res = await prepareNotificationsTest(1)
33 emails = res.emails
34 userAccessToken = res.userAccessToken
35 userNotifications = res.userNotifications
36 server = res.servers[0]
37
38 await addUserSubscription(server.url, userAccessToken, 'root_channel@localhost:' + server.port)
39
40 for (let i = 0; i < 10; i++) {
41 await uploadRandomVideo(server, false)
42 }
43
44 await waitJobs([ server ])
45 })
46
47 describe('Mark as read', function () {
48
49 it('Should mark as read some notifications', async function () {
50 const res = await getUserNotifications(server.url, userAccessToken, 2, 3)
51 const ids = res.body.data.map(n => n.id)
52
53 await markAsReadNotifications(server.url, userAccessToken, ids)
54 })
55
56 it('Should have the notifications marked as read', async function () {
57 const res = await getUserNotifications(server.url, userAccessToken, 0, 10)
58
59 const notifications = res.body.data as UserNotification[]
60 expect(notifications[0].read).to.be.false
61 expect(notifications[1].read).to.be.false
62 expect(notifications[2].read).to.be.true
63 expect(notifications[3].read).to.be.true
64 expect(notifications[4].read).to.be.true
65 expect(notifications[5].read).to.be.false
66 })
67
68 it('Should only list read notifications', async function () {
69 const res = await getUserNotifications(server.url, userAccessToken, 0, 10, false)
70
71 const notifications = res.body.data as UserNotification[]
72 for (const notification of notifications) {
73 expect(notification.read).to.be.true
74 }
75 })
76
77 it('Should only list unread notifications', async function () {
78 const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
79
80 const notifications = res.body.data as UserNotification[]
81 for (const notification of notifications) {
82 expect(notification.read).to.be.false
83 }
84 })
85
86 it('Should mark as read all notifications', async function () {
87 await markAsReadAllNotifications(server.url, userAccessToken)
88
89 const res = await getUserNotifications(server.url, userAccessToken, 0, 10, true)
90
91 expect(res.body.total).to.equal(0)
92 expect(res.body.data).to.have.lengthOf(0)
93 })
94 })
95
96 describe('Notification settings', function () {
97 let baseParams: CheckerBaseParams
98
99 before(() => {
100 baseParams = {
101 server: server,
102 emails,
103 socketNotifications: userNotifications,
104 token: userAccessToken
105 }
106 })
107
108 it('Should not have notifications', async function () {
109 this.timeout(20000)
110
111 await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
112 newVideoFromSubscription: UserNotificationSettingValue.NONE
113 }))
114
115 {
116 const res = await getMyUserInformation(server.url, userAccessToken)
117 const info = res.body as User
118 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
119 }
120
121 const { name, uuid } = await uploadRandomVideo(server)
122
123 const check = { web: true, mail: true }
124 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
125 })
126
127 it('Should only have web notifications', async function () {
128 this.timeout(20000)
129
130 await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
131 newVideoFromSubscription: UserNotificationSettingValue.WEB
132 }))
133
134 {
135 const res = await getMyUserInformation(server.url, userAccessToken)
136 const info = res.body as User
137 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
138 }
139
140 const { name, uuid } = await uploadRandomVideo(server)
141
142 {
143 const check = { mail: true, web: false }
144 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
145 }
146
147 {
148 const check = { mail: false, web: true }
149 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
150 }
151 })
152
153 it('Should only have mail notifications', async function () {
154 this.timeout(20000)
155
156 await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
157 newVideoFromSubscription: UserNotificationSettingValue.EMAIL
158 }))
159
160 {
161 const res = await getMyUserInformation(server.url, userAccessToken)
162 const info = res.body as User
163 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
164 }
165
166 const { name, uuid } = await uploadRandomVideo(server)
167
168 {
169 const check = { mail: false, web: true }
170 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
171 }
172
173 {
174 const check = { mail: true, web: false }
175 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
176 }
177 })
178
179 it('Should have email and web notifications', async function () {
180 this.timeout(20000)
181
182 await updateMyNotificationSettings(server.url, userAccessToken, immutableAssign(getAllNotificationsSettings(), {
183 newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
184 }))
185
186 {
187 const res = await getMyUserInformation(server.url, userAccessToken)
188 const info = res.body as User
189 expect(info.notificationSettings.newVideoFromSubscription).to.equal(
190 UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
191 )
192 }
193
194 const { name, uuid } = await uploadRandomVideo(server)
195
196 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
197 })
198 })
199
200 after(async function () {
201 MockSmtpServer.Instance.kill()
202
203 await cleanupTests([ server ])
204 })
205})
diff --git a/server/tests/api/notifications/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index 04abc6738..e5f6aa864 100644
--- a/server/tests/api/notifications/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -1,176 +1,55 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ 1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2 2
3import * as chai from 'chai'
4import 'mocha' 3import 'mocha'
4import * as chai from 'chai'
5import { v4 as uuidv4 } from 'uuid'
5import { 6import {
6 addVideoToBlacklist,
7 cleanupTests, 7 cleanupTests,
8 createUser,
9 doubleFollow,
10 flushAndRunMultipleServers,
11 follow,
12 getCustomConfig,
13 getMyUserInformation,
14 getVideoCommentThreads,
15 getVideoThreadComments,
16 immutableAssign,
17 MockInstancesIndex,
18 registerUser,
19 removeVideoFromBlacklist,
20 reportVideoAbuse,
21 unfollow,
22 updateCustomConfig,
23 updateCustomSubConfig,
24 updateMyUser, 8 updateMyUser,
25 updateVideo, 9 updateVideo,
26 updateVideoChannel, 10 updateVideoChannel,
27 userLogin, 11 uploadRandomVideoOnServers,
28 wait 12 wait
29} from '../../../../shared/extra-utils' 13} from '../../../../shared/extra-utils'
30import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index' 14import { ServerInfo } from '../../../../shared/extra-utils/index'
31import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login' 15import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
32import { waitJobs } from '../../../../shared/extra-utils/server/jobs' 16import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
33import { getUserNotificationSocket } from '../../../../shared/extra-utils/socket/socket-io'
34import { 17import {
35 checkAutoInstanceFollowing,
36 checkCommentMention,
37 CheckerBaseParams, 18 CheckerBaseParams,
38 checkMyVideoImportIsFinished, 19 checkMyVideoImportIsFinished,
39 checkNewActorFollow, 20 checkNewActorFollow,
40 checkNewBlacklistOnMyVideo,
41 checkNewCommentOnMyVideo,
42 checkNewInstanceFollower,
43 checkNewVideoAbuseForModerators,
44 checkNewVideoFromSubscription, 21 checkNewVideoFromSubscription,
45 checkUserRegistered,
46 checkVideoAutoBlacklistForModerators,
47 checkVideoIsPublished, 22 checkVideoIsPublished,
48 getLastNotification, 23 getLastNotification,
49 getUserNotifications, 24 prepareNotificationsTest
50 markAsReadAllNotifications,
51 markAsReadNotifications,
52 updateMyNotificationSettings
53} from '../../../../shared/extra-utils/users/user-notifications' 25} from '../../../../shared/extra-utils/users/user-notifications'
54import {
55 User,
56 UserNotification,
57 UserNotificationSetting,
58 UserNotificationSettingValue,
59 UserNotificationType
60} from '../../../../shared/models/users'
61import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
62import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions' 26import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions'
63import { VideoPrivacy } from '../../../../shared/models/videos'
64import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports' 27import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
65import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments' 28import { UserNotification, UserNotificationType } from '../../../../shared/models/users'
66import { v4 as uuidv4 } from 'uuid' 29import { VideoPrivacy } from '../../../../shared/models/videos'
67import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/extra-utils/users/blocklist'
68import { CustomConfig } from '../../../../shared/models/server'
69import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
70 30
71const expect = chai.expect 31const expect = chai.expect
72 32
73async function uploadVideoByRemoteAccount (servers: ServerInfo[], additionalParams: any = {}) { 33describe('Test user notifications', function () {
74 const name = 'remote video ' + uuidv4()
75
76 const data = Object.assign({ name }, additionalParams)
77 const res = await uploadVideo(servers[1].url, servers[1].accessToken, data)
78
79 await waitJobs(servers)
80
81 return { uuid: res.body.video.uuid, name }
82}
83
84async function uploadVideoByLocalAccount (servers: ServerInfo[], additionalParams: any = {}) {
85 const name = 'local video ' + uuidv4()
86
87 const data = Object.assign({ name }, additionalParams)
88 const res = await uploadVideo(servers[0].url, servers[0].accessToken, data)
89
90 await waitJobs(servers)
91
92 return { uuid: res.body.video.uuid, name }
93}
94
95describe('Test users notifications', function () {
96 let servers: ServerInfo[] = [] 34 let servers: ServerInfo[] = []
97 let userAccessToken: string 35 let userAccessToken: string
98 const userNotifications: UserNotification[] = [] 36 let userNotifications: UserNotification[] = []
99 const adminNotifications: UserNotification[] = [] 37 let adminNotifications: UserNotification[] = []
100 const adminNotificationsServer2: UserNotification[] = [] 38 let adminNotificationsServer2: UserNotification[] = []
101 const emails: object[] = [] 39 let emails: object[] = []
102 let channelId: number 40 let channelId: number
103 41
104 const allNotificationSettings: UserNotificationSetting = {
105 newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
106 newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
107 videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
108 videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
109 blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
110 myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
111 myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
112 commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
113 newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
114 newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
115 newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
116 autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
117 }
118
119 before(async function () { 42 before(async function () {
120 this.timeout(120000) 43 this.timeout(120000)
121 44
122 const port = await MockSmtpServer.Instance.collectEmails(emails) 45 const res = await prepareNotificationsTest(3)
123 46 emails = res.emails
124 const overrideConfig = { 47 userAccessToken = res.userAccessToken
125 smtp: { 48 servers = res.servers
126 hostname: 'localhost', 49 userNotifications = res.userNotifications
127 port 50 adminNotifications = res.adminNotifications
128 } 51 adminNotificationsServer2 = res.adminNotificationsServer2
129 } 52 channelId = res.channelId
130 servers = await flushAndRunMultipleServers(3, overrideConfig)
131
132 // Get the access tokens
133 await setAccessTokensToServers(servers)
134
135 // Server 1 and server 2 follow each other
136 await doubleFollow(servers[0], servers[1])
137
138 await waitJobs(servers)
139
140 const user = {
141 username: 'user_1',
142 password: 'super password'
143 }
144 await createUser({
145 url: servers[0].url,
146 accessToken: servers[0].accessToken,
147 username: user.username,
148 password: user.password,
149 videoQuota: 10 * 1000 * 1000
150 })
151 userAccessToken = await userLogin(servers[0], user)
152
153 await updateMyNotificationSettings(servers[0].url, userAccessToken, allNotificationSettings)
154 await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, allNotificationSettings)
155 await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, allNotificationSettings)
156
157 {
158 const socket = getUserNotificationSocket(servers[0].url, userAccessToken)
159 socket.on('new-notification', n => userNotifications.push(n))
160 }
161 {
162 const socket = getUserNotificationSocket(servers[0].url, servers[0].accessToken)
163 socket.on('new-notification', n => adminNotifications.push(n))
164 }
165 {
166 const socket = getUserNotificationSocket(servers[1].url, servers[1].accessToken)
167 socket.on('new-notification', n => adminNotificationsServer2.push(n))
168 }
169
170 {
171 const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
172 channelId = resChannel.body.videoChannels[0].id
173 }
174 }) 53 })
175 54
176 describe('New video from my subscription notification', function () { 55 describe('New video from my subscription notification', function () {
@@ -188,7 +67,7 @@ describe('Test users notifications', function () {
188 it('Should not send notifications if the user does not follow the video publisher', async function () { 67 it('Should not send notifications if the user does not follow the video publisher', async function () {
189 this.timeout(10000) 68 this.timeout(10000)
190 69
191 await uploadVideoByLocalAccount(servers) 70 await uploadRandomVideoOnServers(servers, 1)
192 71
193 const notification = await getLastNotification(servers[0].url, userAccessToken) 72 const notification = await getLastNotification(servers[0].url, userAccessToken)
194 expect(notification).to.be.undefined 73 expect(notification).to.be.undefined
@@ -203,7 +82,7 @@ describe('Test users notifications', function () {
203 await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[0].port) 82 await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[0].port)
204 await waitJobs(servers) 83 await waitJobs(servers)
205 84
206 const { name, uuid } = await uploadVideoByLocalAccount(servers) 85 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1)
207 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') 86 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
208 }) 87 })
209 88
@@ -213,7 +92,7 @@ describe('Test users notifications', function () {
213 await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[1].port) 92 await addUserSubscription(servers[0].url, userAccessToken, 'root_channel@localhost:' + servers[1].port)
214 await waitJobs(servers) 93 await waitJobs(servers)
215 94
216 const { name, uuid } = await uploadVideoByRemoteAccount(servers) 95 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2)
217 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') 96 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
218 }) 97 })
219 98
@@ -230,7 +109,7 @@ describe('Test users notifications', function () {
230 privacy: VideoPrivacy.PUBLIC 109 privacy: VideoPrivacy.PUBLIC
231 } 110 }
232 } 111 }
233 const { name, uuid } = await uploadVideoByLocalAccount(servers, data) 112 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
234 113
235 await wait(6000) 114 await wait(6000)
236 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence') 115 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
@@ -249,7 +128,7 @@ describe('Test users notifications', function () {
249 privacy: VideoPrivacy.PUBLIC 128 privacy: VideoPrivacy.PUBLIC
250 } 129 }
251 } 130 }
252 const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) 131 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
253 await waitJobs(servers) 132 await waitJobs(servers)
254 133
255 await wait(6000) 134 await wait(6000)
@@ -268,7 +147,7 @@ describe('Test users notifications', function () {
268 privacy: VideoPrivacy.PUBLIC 147 privacy: VideoPrivacy.PUBLIC
269 } 148 }
270 } 149 }
271 const { name, uuid } = await uploadVideoByLocalAccount(servers, data) 150 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
272 151
273 await wait(6000) 152 await wait(6000)
274 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') 153 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
@@ -278,7 +157,7 @@ describe('Test users notifications', function () {
278 this.timeout(10000) 157 this.timeout(10000)
279 158
280 const data = { privacy: VideoPrivacy.PRIVATE } 159 const data = { privacy: VideoPrivacy.PRIVATE }
281 const { name, uuid } = await uploadVideoByLocalAccount(servers, data) 160 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
282 161
283 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') 162 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
284 163
@@ -292,7 +171,7 @@ describe('Test users notifications', function () {
292 this.timeout(20000) 171 this.timeout(20000)
293 172
294 const data = { privacy: VideoPrivacy.PRIVATE } 173 const data = { privacy: VideoPrivacy.PRIVATE }
295 const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) 174 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
296 175
297 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence') 176 await checkNewVideoFromSubscription(baseParams, name, uuid, 'absence')
298 177
@@ -306,7 +185,7 @@ describe('Test users notifications', function () {
306 this.timeout(20000) 185 this.timeout(20000)
307 186
308 const data = { privacy: VideoPrivacy.PRIVATE } 187 const data = { privacy: VideoPrivacy.PRIVATE }
309 const { name, uuid } = await uploadVideoByLocalAccount(servers, data) 188 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1, data)
310 189
311 await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) 190 await updateVideo(servers[0].url, servers[0].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
312 191
@@ -317,7 +196,7 @@ describe('Test users notifications', function () {
317 this.timeout(20000) 196 this.timeout(20000)
318 197
319 const data = { privacy: VideoPrivacy.PRIVATE } 198 const data = { privacy: VideoPrivacy.PRIVATE }
320 const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) 199 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
321 200
322 await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED }) 201 await updateVideo(servers[1].url, servers[1].accessToken, uuid, { privacy: VideoPrivacy.UNLISTED })
323 202
@@ -345,356 +224,6 @@ describe('Test users notifications', function () {
345 }) 224 })
346 }) 225 })
347 226
348 describe('Comment on my video notifications', function () {
349 let baseParams: CheckerBaseParams
350
351 before(() => {
352 baseParams = {
353 server: servers[0],
354 emails,
355 socketNotifications: userNotifications,
356 token: userAccessToken
357 }
358 })
359
360 it('Should not send a new comment notification after a comment on another video', async function () {
361 this.timeout(10000)
362
363 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
364 const uuid = resVideo.body.video.uuid
365
366 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
367 const commentId = resComment.body.comment.id
368
369 await wait(500)
370 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
371 })
372
373 it('Should not send a new comment notification if I comment my own video', async function () {
374 this.timeout(10000)
375
376 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
377 const uuid = resVideo.body.video.uuid
378
379 const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment')
380 const commentId = resComment.body.comment.id
381
382 await wait(500)
383 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
384 })
385
386 it('Should not send a new comment notification if the account is muted', async function () {
387 this.timeout(10000)
388
389 await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
390
391 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
392 const uuid = resVideo.body.video.uuid
393
394 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
395 const commentId = resComment.body.comment.id
396
397 await wait(500)
398 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
399
400 await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
401 })
402
403 it('Should send a new comment notification after a local comment on my video', async function () {
404 this.timeout(10000)
405
406 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
407 const uuid = resVideo.body.video.uuid
408
409 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
410 const commentId = resComment.body.comment.id
411
412 await wait(500)
413 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
414 })
415
416 it('Should send a new comment notification after a remote comment on my video', async function () {
417 this.timeout(10000)
418
419 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
420 const uuid = resVideo.body.video.uuid
421
422 await waitJobs(servers)
423
424 await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
425
426 await waitJobs(servers)
427
428 const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
429 expect(resComment.body.data).to.have.lengthOf(1)
430 const commentId = resComment.body.data[0].id
431
432 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
433 })
434
435 it('Should send a new comment notification after a local reply on my video', async function () {
436 this.timeout(10000)
437
438 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
439 const uuid = resVideo.body.video.uuid
440
441 const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
442 const threadId = resThread.body.comment.id
443
444 const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply')
445 const commentId = resComment.body.comment.id
446
447 await wait(500)
448 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
449 })
450
451 it('Should send a new comment notification after a remote reply on my video', async function () {
452 this.timeout(10000)
453
454 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
455 const uuid = resVideo.body.video.uuid
456 await waitJobs(servers)
457
458 {
459 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
460 const threadId = resThread.body.comment.id
461 await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply')
462 }
463
464 await waitJobs(servers)
465
466 const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
467 expect(resThread.body.data).to.have.lengthOf(1)
468 const threadId = resThread.body.data[0].id
469
470 const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId)
471 const tree = resComments.body as VideoCommentThreadTree
472
473 expect(tree.children).to.have.lengthOf(1)
474 const commentId = tree.children[0].comment.id
475
476 await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
477 })
478 })
479
480 describe('Mention notifications', function () {
481 let baseParams: CheckerBaseParams
482
483 before(async () => {
484 baseParams = {
485 server: servers[0],
486 emails,
487 socketNotifications: userNotifications,
488 token: userAccessToken
489 }
490
491 await updateMyUser({
492 url: servers[0].url,
493 accessToken: servers[0].accessToken,
494 displayName: 'super root name'
495 })
496
497 await updateMyUser({
498 url: servers[1].url,
499 accessToken: servers[1].accessToken,
500 displayName: 'super root 2 name'
501 })
502 })
503
504 it('Should not send a new mention comment notification if I mention the video owner', async function () {
505 this.timeout(10000)
506
507 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
508 const uuid = resVideo.body.video.uuid
509
510 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
511 const commentId = resComment.body.comment.id
512
513 await wait(500)
514 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
515 })
516
517 it('Should not send a new mention comment notification if I mention myself', async function () {
518 this.timeout(10000)
519
520 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
521 const uuid = resVideo.body.video.uuid
522
523 const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello')
524 const commentId = resComment.body.comment.id
525
526 await wait(500)
527 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
528 })
529
530 it('Should not send a new mention notification if the account is muted', async function () {
531 this.timeout(10000)
532
533 await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
534
535 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
536 const uuid = resVideo.body.video.uuid
537
538 const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
539 const commentId = resComment.body.comment.id
540
541 await wait(500)
542 await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
543
544 await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
545 })
546
547 it('Should not send a new mention notification if the remote account mention a local account', async function () {
548 this.timeout(20000)
549
550 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
551 const uuid = resVideo.body.video.uuid
552
553 await waitJobs(servers)
554 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello')
555 const threadId = resThread.body.comment.id
556
557 await waitJobs(servers)
558 await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence')
559 })
560
561 it('Should send a new mention notification after local comments', async function () {
562 this.timeout(10000)
563
564 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
565 const uuid = resVideo.body.video.uuid
566
567 const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
568 const threadId = resThread.body.comment.id
569
570 await wait(500)
571 await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence')
572
573 const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1')
574 const commentId = resComment.body.comment.id
575
576 await wait(500)
577 await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence')
578 })
579
580 it('Should send a new mention notification after remote comments', async function () {
581 this.timeout(20000)
582
583 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
584 const uuid = resVideo.body.video.uuid
585
586 await waitJobs(servers)
587
588 const text1 = `hello @user_1@localhost:${servers[0].port} 1`
589 const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, text1)
590 const server2ThreadId = resThread.body.comment.id
591
592 await waitJobs(servers)
593
594 const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
595 expect(resThread2.body.data).to.have.lengthOf(1)
596 const server1ThreadId = resThread2.body.data[0].id
597 await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence')
598
599 const text2 = `@user_1@localhost:${servers[0].port} hello 2 @root@localhost:${servers[0].port}`
600 await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text2)
601
602 await waitJobs(servers)
603
604 const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId)
605 const tree = resComments.body as VideoCommentThreadTree
606
607 expect(tree.children).to.have.lengthOf(1)
608 const commentId = tree.children[0].comment.id
609
610 await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence')
611 })
612 })
613
614 describe('Video abuse for moderators notification', function () {
615 let baseParams: CheckerBaseParams
616
617 before(() => {
618 baseParams = {
619 server: servers[0],
620 emails,
621 socketNotifications: adminNotifications,
622 token: servers[0].accessToken
623 }
624 })
625
626 it('Should send a notification to moderators on local video abuse', async function () {
627 this.timeout(10000)
628
629 const name = 'video for abuse ' + uuidv4()
630 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
631 const uuid = resVideo.body.video.uuid
632
633 await reportVideoAbuse(servers[0].url, servers[0].accessToken, uuid, 'super reason')
634
635 await waitJobs(servers)
636 await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
637 })
638
639 it('Should send a notification to moderators on remote video abuse', async function () {
640 this.timeout(10000)
641
642 const name = 'video for abuse ' + uuidv4()
643 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
644 const uuid = resVideo.body.video.uuid
645
646 await waitJobs(servers)
647
648 await reportVideoAbuse(servers[1].url, servers[1].accessToken, uuid, 'super reason')
649
650 await waitJobs(servers)
651 await checkNewVideoAbuseForModerators(baseParams, uuid, name, 'presence')
652 })
653 })
654
655 describe('Video blacklist on my video', function () {
656 let baseParams: CheckerBaseParams
657
658 before(() => {
659 baseParams = {
660 server: servers[0],
661 emails,
662 socketNotifications: userNotifications,
663 token: userAccessToken
664 }
665 })
666
667 it('Should send a notification to video owner on blacklist', async function () {
668 this.timeout(10000)
669
670 const name = 'video for abuse ' + uuidv4()
671 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
672 const uuid = resVideo.body.video.uuid
673
674 await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
675
676 await waitJobs(servers)
677 await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'blacklist')
678 })
679
680 it('Should send a notification to video owner on unblacklist', async function () {
681 this.timeout(10000)
682
683 const name = 'video for abuse ' + uuidv4()
684 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
685 const uuid = resVideo.body.video.uuid
686
687 await addVideoToBlacklist(servers[0].url, servers[0].accessToken, uuid)
688
689 await waitJobs(servers)
690 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
691 await waitJobs(servers)
692
693 await wait(500)
694 await checkNewBlacklistOnMyVideo(baseParams, uuid, name, 'unblacklist')
695 })
696 })
697
698 describe('My video is published', function () { 227 describe('My video is published', function () {
699 let baseParams: CheckerBaseParams 228 let baseParams: CheckerBaseParams
700 229
@@ -710,7 +239,7 @@ describe('Test users notifications', function () {
710 it('Should not send a notification if transcoding is not enabled', async function () { 239 it('Should not send a notification if transcoding is not enabled', async function () {
711 this.timeout(10000) 240 this.timeout(10000)
712 241
713 const { name, uuid } = await uploadVideoByLocalAccount(servers) 242 const { name, uuid } = await uploadRandomVideoOnServers(servers, 1)
714 await waitJobs(servers) 243 await waitJobs(servers)
715 244
716 await checkVideoIsPublished(baseParams, name, uuid, 'absence') 245 await checkVideoIsPublished(baseParams, name, uuid, 'absence')
@@ -719,7 +248,7 @@ describe('Test users notifications', function () {
719 it('Should not send a notification if the wait transcoding is false', async function () { 248 it('Should not send a notification if the wait transcoding is false', async function () {
720 this.timeout(50000) 249 this.timeout(50000)
721 250
722 await uploadVideoByRemoteAccount(servers, { waitTranscoding: false }) 251 await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: false })
723 await waitJobs(servers) 252 await waitJobs(servers)
724 253
725 const notification = await getLastNotification(servers[0].url, userAccessToken) 254 const notification = await getLastNotification(servers[0].url, userAccessToken)
@@ -731,7 +260,7 @@ describe('Test users notifications', function () {
731 it('Should send a notification even if the video is not transcoded in other resolutions', async function () { 260 it('Should send a notification even if the video is not transcoded in other resolutions', async function () {
732 this.timeout(50000) 261 this.timeout(50000)
733 262
734 const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true, fixture: 'video_short_240p.mp4' }) 263 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true, fixture: 'video_short_240p.mp4' })
735 await waitJobs(servers) 264 await waitJobs(servers)
736 265
737 await checkVideoIsPublished(baseParams, name, uuid, 'presence') 266 await checkVideoIsPublished(baseParams, name, uuid, 'presence')
@@ -740,7 +269,7 @@ describe('Test users notifications', function () {
740 it('Should send a notification with a transcoded video', async function () { 269 it('Should send a notification with a transcoded video', async function () {
741 this.timeout(50000) 270 this.timeout(50000)
742 271
743 const { name, uuid } = await uploadVideoByRemoteAccount(servers, { waitTranscoding: true }) 272 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true })
744 await waitJobs(servers) 273 await waitJobs(servers)
745 274
746 await checkVideoIsPublished(baseParams, name, uuid, 'presence') 275 await checkVideoIsPublished(baseParams, name, uuid, 'presence')
@@ -778,14 +307,14 @@ describe('Test users notifications', function () {
778 privacy: VideoPrivacy.PUBLIC 307 privacy: VideoPrivacy.PUBLIC
779 } 308 }
780 } 309 }
781 const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) 310 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
782 311
783 await wait(6000) 312 await wait(6000)
784 await checkVideoIsPublished(baseParams, name, uuid, 'presence') 313 await checkVideoIsPublished(baseParams, name, uuid, 'presence')
785 }) 314 })
786 315
787 it('Should not send a notification before the video is published', async function () { 316 it('Should not send a notification before the video is published', async function () {
788 this.timeout(20000) 317 this.timeout(40000)
789 318
790 const updateAt = new Date(new Date().getTime() + 1000000) 319 const updateAt = new Date(new Date().getTime() + 1000000)
791 320
@@ -796,7 +325,7 @@ describe('Test users notifications', function () {
796 privacy: VideoPrivacy.PUBLIC 325 privacy: VideoPrivacy.PUBLIC
797 } 326 }
798 } 327 }
799 const { name, uuid } = await uploadVideoByRemoteAccount(servers, data) 328 const { name, uuid } = await uploadRandomVideoOnServers(servers, 2, data)
800 329
801 await wait(6000) 330 await wait(6000)
802 await checkVideoIsPublished(baseParams, name, uuid, 'absence') 331 await checkVideoIsPublished(baseParams, name, uuid, 'absence')
@@ -852,122 +381,6 @@ describe('Test users notifications', function () {
852 }) 381 })
853 }) 382 })
854 383
855 describe('New registration', function () {
856 let baseParams: CheckerBaseParams
857
858 before(() => {
859 baseParams = {
860 server: servers[0],
861 emails,
862 socketNotifications: adminNotifications,
863 token: servers[0].accessToken
864 }
865 })
866
867 it('Should send a notification only to moderators when a user registers on the instance', async function () {
868 this.timeout(10000)
869
870 await registerUser(servers[0].url, 'user_45', 'password')
871
872 await waitJobs(servers)
873
874 await checkUserRegistered(baseParams, 'user_45', 'presence')
875
876 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
877 await checkUserRegistered(immutableAssign(baseParams, userOverride), 'user_45', 'absence')
878 })
879 })
880
881 describe('New instance follows', function () {
882 const instanceIndexServer = new MockInstancesIndex()
883 const config = {
884 followings: {
885 instance: {
886 autoFollowIndex: {
887 indexUrl: 'http://localhost:42101/api/v1/instances/hosts',
888 enabled: true
889 }
890 }
891 }
892 }
893 let baseParams: CheckerBaseParams
894
895 before(async () => {
896 baseParams = {
897 server: servers[0],
898 emails,
899 socketNotifications: adminNotifications,
900 token: servers[0].accessToken
901 }
902
903 await instanceIndexServer.initialize()
904 instanceIndexServer.addInstance(servers[1].host)
905 })
906
907 it('Should send a notification only to admin when there is a new instance follower', async function () {
908 this.timeout(20000)
909
910 await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
911
912 await waitJobs(servers)
913
914 await checkNewInstanceFollower(baseParams, 'localhost:' + servers[2].port, 'presence')
915
916 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
917 await checkNewInstanceFollower(immutableAssign(baseParams, userOverride), 'localhost:' + servers[2].port, 'absence')
918 })
919
920 it('Should send a notification on auto follow back', async function () {
921 this.timeout(40000)
922
923 await unfollow(servers[2].url, servers[2].accessToken, servers[0])
924 await waitJobs(servers)
925
926 const config = {
927 followings: {
928 instance: {
929 autoFollowBack: { enabled: true }
930 }
931 }
932 }
933 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
934
935 await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
936
937 await waitJobs(servers)
938
939 const followerHost = servers[0].host
940 const followingHost = servers[2].host
941 await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
942
943 const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
944 await checkAutoInstanceFollowing(immutableAssign(baseParams, userOverride), followerHost, followingHost, 'absence')
945
946 config.followings.instance.autoFollowBack.enabled = false
947 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
948 await unfollow(servers[0].url, servers[0].accessToken, servers[2])
949 await unfollow(servers[2].url, servers[2].accessToken, servers[0])
950 })
951
952 it('Should send a notification on auto instances index follow', async function () {
953 this.timeout(30000)
954 await unfollow(servers[0].url, servers[0].accessToken, servers[1])
955
956 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
957
958 await wait(5000)
959 await waitJobs(servers)
960
961 const followerHost = servers[0].host
962 const followingHost = servers[1].host
963 await checkAutoInstanceFollowing(baseParams, followerHost, followingHost, 'presence')
964
965 config.followings.instance.autoFollowIndex.enabled = false
966 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
967 await unfollow(servers[0].url, servers[0].accessToken, servers[1])
968 })
969 })
970
971 describe('New actor follow', function () { 384 describe('New actor follow', function () {
972 let baseParams: CheckerBaseParams 385 let baseParams: CheckerBaseParams
973 const myChannelName = 'super channel name' 386 const myChannelName = 'super channel name'
@@ -1046,332 +459,6 @@ describe('Test users notifications', function () {
1046 // }) 459 // })
1047 }) 460 })
1048 461
1049 describe('Video-related notifications when video auto-blacklist is enabled', function () {
1050 let userBaseParams: CheckerBaseParams
1051 let adminBaseParamsServer1: CheckerBaseParams
1052 let adminBaseParamsServer2: CheckerBaseParams
1053 let videoUUID: string
1054 let videoName: string
1055 let currentCustomConfig: CustomConfig
1056
1057 before(async () => {
1058
1059 adminBaseParamsServer1 = {
1060 server: servers[0],
1061 emails,
1062 socketNotifications: adminNotifications,
1063 token: servers[0].accessToken
1064 }
1065
1066 adminBaseParamsServer2 = {
1067 server: servers[1],
1068 emails,
1069 socketNotifications: adminNotificationsServer2,
1070 token: servers[1].accessToken
1071 }
1072
1073 userBaseParams = {
1074 server: servers[0],
1075 emails,
1076 socketNotifications: userNotifications,
1077 token: userAccessToken
1078 }
1079
1080 const resCustomConfig = await getCustomConfig(servers[0].url, servers[0].accessToken)
1081 currentCustomConfig = resCustomConfig.body
1082 const autoBlacklistTestsCustomConfig = immutableAssign(currentCustomConfig, {
1083 autoBlacklist: {
1084 videos: {
1085 ofUsers: {
1086 enabled: true
1087 }
1088 }
1089 }
1090 })
1091 // enable transcoding otherwise own publish notification after transcoding not expected
1092 autoBlacklistTestsCustomConfig.transcoding.enabled = true
1093 await updateCustomConfig(servers[0].url, servers[0].accessToken, autoBlacklistTestsCustomConfig)
1094
1095 await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
1096 await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
1097
1098 })
1099
1100 it('Should send notification to moderators on new video with auto-blacklist', async function () {
1101 this.timeout(20000)
1102
1103 videoName = 'video with auto-blacklist ' + uuidv4()
1104 const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
1105 videoUUID = resVideo.body.video.uuid
1106
1107 await waitJobs(servers)
1108 await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, videoUUID, videoName, 'presence')
1109 })
1110
1111 it('Should not send video publish notification if auto-blacklisted', async function () {
1112 await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'absence')
1113 })
1114
1115 it('Should not send a local user subscription notification if auto-blacklisted', async function () {
1116 await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'absence')
1117 })
1118
1119 it('Should not send a remote user subscription notification if auto-blacklisted', async function () {
1120 await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'absence')
1121 })
1122
1123 it('Should send video published and unblacklist after video unblacklisted', async function () {
1124 this.timeout(20000)
1125
1126 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoUUID)
1127
1128 await waitJobs(servers)
1129
1130 // FIXME: Can't test as two notifications sent to same user and util only checks last one
1131 // One notification might be better anyways
1132 // await checkNewBlacklistOnMyVideo(userBaseParams, videoUUID, videoName, 'unblacklist')
1133 // await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'presence')
1134 })
1135
1136 it('Should send a local user subscription notification after removed from blacklist', async function () {
1137 await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'presence')
1138 })
1139
1140 it('Should send a remote user subscription notification after removed from blacklist', async function () {
1141 await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'presence')
1142 })
1143
1144 it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () {
1145 this.timeout(20000)
1146
1147 const updateAt = new Date(new Date().getTime() + 1000000)
1148
1149 const name = 'video with auto-blacklist and future schedule ' + uuidv4()
1150
1151 const data = {
1152 name,
1153 privacy: VideoPrivacy.PRIVATE,
1154 scheduleUpdate: {
1155 updateAt: updateAt.toISOString(),
1156 privacy: VideoPrivacy.PUBLIC
1157 }
1158 }
1159
1160 const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
1161 const uuid = resVideo.body.video.uuid
1162
1163 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
1164
1165 await waitJobs(servers)
1166 await checkNewBlacklistOnMyVideo(userBaseParams, uuid, name, 'unblacklist')
1167
1168 // FIXME: Can't test absence as two notifications sent to same user and util only checks last one
1169 // One notification might be better anyways
1170 // await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
1171
1172 await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
1173 await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
1174 })
1175
1176 it('Should not send publish/subscription notifications after scheduled update if video still auto-blacklisted', async function () {
1177 this.timeout(20000)
1178
1179 // In 2 seconds
1180 const updateAt = new Date(new Date().getTime() + 2000)
1181
1182 const name = 'video with schedule done and still auto-blacklisted ' + uuidv4()
1183
1184 const data = {
1185 name,
1186 privacy: VideoPrivacy.PRIVATE,
1187 scheduleUpdate: {
1188 updateAt: updateAt.toISOString(),
1189 privacy: VideoPrivacy.PUBLIC
1190 }
1191 }
1192
1193 const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
1194 const uuid = resVideo.body.video.uuid
1195
1196 await wait(6000)
1197 await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
1198 await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
1199 await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
1200 })
1201
1202 it('Should not send a notification to moderators on new video without auto-blacklist', async function () {
1203 this.timeout(20000)
1204
1205 const name = 'video without auto-blacklist ' + uuidv4()
1206
1207 // admin with blacklist right will not be auto-blacklisted
1208 const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name })
1209 const uuid = resVideo.body.video.uuid
1210
1211 await waitJobs(servers)
1212 await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, uuid, name, 'absence')
1213 })
1214
1215 after(async () => {
1216 await updateCustomConfig(servers[0].url, servers[0].accessToken, currentCustomConfig)
1217
1218 await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:' + servers[0].port)
1219 await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:' + servers[0].port)
1220 })
1221 })
1222
1223 describe('Mark as read', function () {
1224 it('Should mark as read some notifications', async function () {
1225 const res = await getUserNotifications(servers[0].url, userAccessToken, 2, 3)
1226 const ids = res.body.data.map(n => n.id)
1227
1228 await markAsReadNotifications(servers[0].url, userAccessToken, ids)
1229 })
1230
1231 it('Should have the notifications marked as read', async function () {
1232 const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10)
1233
1234 const notifications = res.body.data as UserNotification[]
1235 expect(notifications[0].read).to.be.false
1236 expect(notifications[1].read).to.be.false
1237 expect(notifications[2].read).to.be.true
1238 expect(notifications[3].read).to.be.true
1239 expect(notifications[4].read).to.be.true
1240 expect(notifications[5].read).to.be.false
1241 })
1242
1243 it('Should only list read notifications', async function () {
1244 const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, false)
1245
1246 const notifications = res.body.data as UserNotification[]
1247 for (const notification of notifications) {
1248 expect(notification.read).to.be.true
1249 }
1250 })
1251
1252 it('Should only list unread notifications', async function () {
1253 const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, true)
1254
1255 const notifications = res.body.data as UserNotification[]
1256 for (const notification of notifications) {
1257 expect(notification.read).to.be.false
1258 }
1259 })
1260
1261 it('Should mark as read all notifications', async function () {
1262 await markAsReadAllNotifications(servers[0].url, userAccessToken)
1263
1264 const res = await getUserNotifications(servers[0].url, userAccessToken, 0, 10, true)
1265
1266 expect(res.body.total).to.equal(0)
1267 expect(res.body.data).to.have.lengthOf(0)
1268 })
1269 })
1270
1271 describe('Notification settings', function () {
1272 let baseParams: CheckerBaseParams
1273
1274 before(() => {
1275 baseParams = {
1276 server: servers[0],
1277 emails,
1278 socketNotifications: userNotifications,
1279 token: userAccessToken
1280 }
1281 })
1282
1283 it('Should not have notifications', async function () {
1284 this.timeout(20000)
1285
1286 await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
1287 newVideoFromSubscription: UserNotificationSettingValue.NONE
1288 }))
1289
1290 {
1291 const res = await getMyUserInformation(servers[0].url, userAccessToken)
1292 const info = res.body as User
1293 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.NONE)
1294 }
1295
1296 const { name, uuid } = await uploadVideoByLocalAccount(servers)
1297
1298 const check = { web: true, mail: true }
1299 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
1300 })
1301
1302 it('Should only have web notifications', async function () {
1303 this.timeout(20000)
1304
1305 await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
1306 newVideoFromSubscription: UserNotificationSettingValue.WEB
1307 }))
1308
1309 {
1310 const res = await getMyUserInformation(servers[0].url, userAccessToken)
1311 const info = res.body as User
1312 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB)
1313 }
1314
1315 const { name, uuid } = await uploadVideoByLocalAccount(servers)
1316
1317 {
1318 const check = { mail: true, web: false }
1319 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
1320 }
1321
1322 {
1323 const check = { mail: false, web: true }
1324 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
1325 }
1326 })
1327
1328 it('Should only have mail notifications', async function () {
1329 this.timeout(20000)
1330
1331 await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
1332 newVideoFromSubscription: UserNotificationSettingValue.EMAIL
1333 }))
1334
1335 {
1336 const res = await getMyUserInformation(servers[0].url, userAccessToken)
1337 const info = res.body as User
1338 expect(info.notificationSettings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.EMAIL)
1339 }
1340
1341 const { name, uuid } = await uploadVideoByLocalAccount(servers)
1342
1343 {
1344 const check = { mail: false, web: true }
1345 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'absence')
1346 }
1347
1348 {
1349 const check = { mail: true, web: false }
1350 await checkNewVideoFromSubscription(immutableAssign(baseParams, { check }), name, uuid, 'presence')
1351 }
1352 })
1353
1354 it('Should have email and web notifications', async function () {
1355 this.timeout(20000)
1356
1357 await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
1358 newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
1359 }))
1360
1361 {
1362 const res = await getMyUserInformation(servers[0].url, userAccessToken)
1363 const info = res.body as User
1364 expect(info.notificationSettings.newVideoFromSubscription).to.equal(
1365 UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
1366 )
1367 }
1368
1369 const { name, uuid } = await uploadVideoByLocalAccount(servers)
1370
1371 await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
1372 })
1373 })
1374
1375 after(async function () { 462 after(async function () {
1376 MockSmtpServer.Instance.kill() 463 MockSmtpServer.Instance.kill()
1377 464
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index e7d9238dd..3493a723d 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -1,8 +1,7 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ 1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2 2
3import * as chai from 'chai'
4import 'mocha' 3import 'mocha'
5import { User, Video, VideoChannel, ViewsPerDate, VideoDetails } from '../../../../shared/index' 4import * as chai from 'chai'
6import { 5import {
7 cleanupTests, 6 cleanupTests,
8 createUser, 7 createUser,
@@ -30,6 +29,7 @@ import {
30 viewVideo 29 viewVideo
31} from '../../../../shared/extra-utils/index' 30} from '../../../../shared/extra-utils/index'
32import { waitJobs } from '../../../../shared/extra-utils/server/jobs' 31import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
32import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
33 33
34const expect = chai.expect 34const expect = chai.expect
35 35