server/tests/api/check-params/user-notifications.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { io } from 'socket.io-client'
   5 import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '@server/tests/shared'
   6 import { wait } from '@shared/core-utils'
   7 import { HttpStatusCode, UserNotificationSetting, UserNotificationSettingValue } from '@shared/models'
   8 import {
   9   cleanupTests,
  10   createSingleServer,
  11   makeGetRequest,
  12   makePostBodyRequest,
  13   makePutBodyRequest,
  14   PeerTubeServer,
  15   setAccessTokensToServers
  16 } from '@shared/server-commands'
  17
  18 describe('Test user notifications API validators', function () {
  19   let server: PeerTubeServer
  20
  21   // ---------------------------------------------------------------
  22
  23   before(async function () {
  24     this.timeout(30000)
  25
  26     server = await createSingleServer(1)
  27
  28     await setAccessTokensToServers([ server ])
  29   })
  30
  31   describe('When listing my notifications', function () {
  32     const path = '/api/v1/users/me/notifications'
  33
  34     it('Should fail with a bad start pagination', async function () {
  35       await checkBadStartPagination(server.url, path, server.accessToken)
  36     })
  37
  38     it('Should fail with a bad count pagination', async function () {
  39       await checkBadCountPagination(server.url, path, server.accessToken)
  40     })
  41
  42     it('Should fail with an incorrect sort', async function () {
  43       await checkBadSortPagination(server.url, path, server.accessToken)
  44     })
  45
  46     it('Should fail with an incorrect unread parameter', async function () {
  47       await makeGetRequest({
  48         url: server.url,
  49         path,
  50         query: {
  51           unread: 'toto'
  52         },
  53         token: server.accessToken,
  54         expectedStatus: HttpStatusCode.OK_200
  55       })
  56     })
  57
  58     it('Should fail with a non authenticated user', async function () {
  59       await makeGetRequest({
  60         url: server.url,
  61         path,
  62         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
  63       })
  64     })
  65
  66     it('Should succeed with the correct parameters', async function () {
  67       await makeGetRequest({
  68         url: server.url,
  69         path,
  70         token: server.accessToken,
  71         expectedStatus: HttpStatusCode.OK_200
  72       })
  73     })
  74   })
  75
  76   describe('When marking as read my notifications', function () {
  77     const path = '/api/v1/users/me/notifications/read'
  78
  79     it('Should fail with wrong ids parameters', async function () {
  80       await makePostBodyRequest({
  81         url: server.url,
  82         path,
  83         fields: {
  84           ids: [ 'hello' ]
  85         },
  86         token: server.accessToken,
  87         expectedStatus: HttpStatusCode.BAD_REQUEST_400
  88       })
  89
  90       await makePostBodyRequest({
  91         url: server.url,
  92         path,
  93         fields: {
  94           ids: [ ]
  95         },
  96         token: server.accessToken,
  97         expectedStatus: HttpStatusCode.BAD_REQUEST_400
  98       })
  99
 100       await makePostBodyRequest({
 101         url: server.url,
 102         path,
 103         fields: {
 104           ids: 5
 105         },
 106         token: server.accessToken,
 107         expectedStatus: HttpStatusCode.BAD_REQUEST_400
 108       })
 109     })
 110
 111     it('Should fail with a non authenticated user', async function () {
 112       await makePostBodyRequest({
 113         url: server.url,
 114         path,
 115         fields: {
 116           ids: [ 5 ]
 117         },
 118         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
 119       })
 120     })
 121
 122     it('Should succeed with the correct parameters', async function () {
 123       await makePostBodyRequest({
 124         url: server.url,
 125         path,
 126         fields: {
 127           ids: [ 5 ]
 128         },
 129         token: server.accessToken,
 130         expectedStatus: HttpStatusCode.NO_CONTENT_204
 131       })
 132     })
 133   })
 134
 135   describe('When marking as read my notifications', function () {
 136     const path = '/api/v1/users/me/notifications/read-all'
 137
 138     it('Should fail with a non authenticated user', async function () {
 139       await makePostBodyRequest({
 140         url: server.url,
 141         path,
 142         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
 143       })
 144     })
 145
 146     it('Should succeed with the correct parameters', async function () {
 147       await makePostBodyRequest({
 148         url: server.url,
 149         path,
 150         token: server.accessToken,
 151         expectedStatus: HttpStatusCode.NO_CONTENT_204
 152       })
 153     })
 154   })
 155
 156   describe('When updating my notification settings', function () {
 157     const path = '/api/v1/users/me/notification-settings'
 158     const correctFields: UserNotificationSetting = {
 159       newVideoFromSubscription: UserNotificationSettingValue.WEB,
 160       newCommentOnMyVideo: UserNotificationSettingValue.WEB,
 161       abuseAsModerator: UserNotificationSettingValue.WEB,
 162       videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB,
 163       blacklistOnMyVideo: UserNotificationSettingValue.WEB,
 164       myVideoImportFinished: UserNotificationSettingValue.WEB,
 165       myVideoPublished: UserNotificationSettingValue.WEB,
 166       commentMention: UserNotificationSettingValue.WEB,
 167       newFollow: UserNotificationSettingValue.WEB,
 168       newUserRegistration: UserNotificationSettingValue.WEB,
 169       newInstanceFollower: UserNotificationSettingValue.WEB,
 170       autoInstanceFollowing: UserNotificationSettingValue.WEB,
 171       abuseNewMessage: UserNotificationSettingValue.WEB,
 172       abuseStateChange: UserNotificationSettingValue.WEB,
 173       newPeerTubeVersion: UserNotificationSettingValue.WEB,
 174       myVideoStudioEditionFinished: UserNotificationSettingValue.WEB,
 175       newPluginVersion: UserNotificationSettingValue.WEB
 176     }
 177
 178     it('Should fail with missing fields', async function () {
 179       await makePutBodyRequest({
 180         url: server.url,
 181         path,
 182         token: server.accessToken,
 183         fields: { newVideoFromSubscription: UserNotificationSettingValue.WEB },
 184         expectedStatus: HttpStatusCode.BAD_REQUEST_400
 185       })
 186     })
 187
 188     it('Should fail with incorrect field values', async function () {
 189       {
 190         const fields = { ...correctFields, newCommentOnMyVideo: 15 }
 191
 192         await makePutBodyRequest({
 193           url: server.url,
 194           path,
 195           token: server.accessToken,
 196           fields,
 197           expectedStatus: HttpStatusCode.BAD_REQUEST_400
 198         })
 199       }
 200
 201       {
 202         const fields = { ...correctFields, newCommentOnMyVideo: 'toto' }
 203
 204         await makePutBodyRequest({
 205           url: server.url,
 206           path,
 207           fields,
 208           token: server.accessToken,
 209           expectedStatus: HttpStatusCode.BAD_REQUEST_400
 210         })
 211       }
 212     })
 213
 214     it('Should fail with a non authenticated user', async function () {
 215       await makePutBodyRequest({
 216         url: server.url,
 217         path,
 218         fields: correctFields,
 219         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
 220       })
 221     })
 222
 223     it('Should succeed with the correct parameters', async function () {
 224       await makePutBodyRequest({
 225         url: server.url,
 226         path,
 227         token: server.accessToken,
 228         fields: correctFields,
 229         expectedStatus: HttpStatusCode.NO_CONTENT_204
 230       })
 231     })
 232   })
 233
 234   describe('When connecting to my notification socket', function () {
 235
 236     it('Should fail with no token', function (next) {
 237       const socket = io(`http://localhost:${server.port}/user-notifications`, { reconnection: false })
 238
 239       socket.once('connect_error', function () {
 240         socket.disconnect()
 241         next()
 242       })
 243
 244       socket.on('connect', () => {
 245         socket.disconnect()
 246         next(new Error('Connected with a missing token.'))
 247       })
 248     })
 249
 250     it('Should fail with an invalid token', function (next) {
 251       const socket = io(`http://localhost:${server.port}/user-notifications`, {
 252         query: { accessToken: 'bad_access_token' },
 253         reconnection: false
 254       })
 255
 256       socket.once('connect_error', function () {
 257         socket.disconnect()
 258         next()
 259       })
 260
 261       socket.on('connect', () => {
 262         socket.disconnect()
 263         next(new Error('Connected with an invalid token.'))
 264       })
 265     })
 266
 267     it('Should success with the correct token', function (next) {
 268       const socket = io(`http://localhost:${server.port}/user-notifications`, {
 269         query: { accessToken: server.accessToken },
 270         reconnection: false
 271       })
 272
 273       function errorListener (err) {
 274         next(new Error('Error in connection: ' + err))
 275       }
 276
 277       socket.on('connect_error', errorListener)
 278
 279       socket.once('connect', async () => {
 280         socket.disconnect()
 281
 282         await wait(500)
 283         next()
 284       })
 285     })
 286   })
 287
 288   after(async function () {
 289     await cleanupTests([ server ])
 290   })
 291 })