server/tests/api/users/users.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import { testImage } from '@server/tests/shared'
   5 import { AbuseState, HttpStatusCode, OAuth2ErrorCode, UserAdminFlag, UserRole, VideoPlaylistType } from '@shared/models'
   6 import {
   7   cleanupTests,
   8   createSingleServer,
   9   killallServers,
  10   makePutBodyRequest,
  11   PeerTubeServer,
  12   setAccessTokensToServers
  13 } from '@shared/server-commands'
  14
  15 const expect = chai.expect
  16
  17 describe('Test users', function () {
  18   let server: PeerTubeServer
  19   let token: string
  20   let userToken: string
  21   let videoId: number
  22   let userId: number
  23   const user = {
  24     username: 'user_1',
  25     password: 'super password'
  26   }
  27
  28   before(async function () {
  29     this.timeout(30000)
  30
  31     server = await createSingleServer(1, {
  32       rates_limit: {
  33         login: {
  34           max: 30
  35         }
  36       }
  37     })
  38
  39     await setAccessTokensToServers([ server ])
  40
  41     await server.plugins.install({ npmName: 'peertube-theme-background-red' })
  42   })
  43
  44   describe('OAuth client', function () {
  45     it('Should create a new client')
  46
  47     it('Should return the first client')
  48
  49     it('Should remove the last client')
  50
  51     it('Should not login with an invalid client id', async function () {
  52       const client = { id: 'client', secret: server.store.client.secret }
  53       const body = await server.login.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  54
  55       expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
  56       expect(body.error).to.contain('client is invalid')
  57       expect(body.type.startsWith('https://')).to.be.true
  58       expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
  59     })
  60
  61     it('Should not login with an invalid client secret', async function () {
  62       const client = { id: server.store.client.id, secret: 'coucou' }
  63       const body = await server.login.login({ client, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  64
  65       expect(body.code).to.equal(OAuth2ErrorCode.INVALID_CLIENT)
  66       expect(body.error).to.contain('client is invalid')
  67       expect(body.type.startsWith('https://')).to.be.true
  68       expect(body.type).to.contain(OAuth2ErrorCode.INVALID_CLIENT)
  69     })
  70   })
  71
  72   describe('Login', function () {
  73
  74     it('Should not login with an invalid username', async function () {
  75       const user = { username: 'captain crochet', password: server.store.user.password }
  76       const body = await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  77
  78       expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
  79       expect(body.error).to.contain('credentials are invalid')
  80       expect(body.type.startsWith('https://')).to.be.true
  81       expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
  82     })
  83
  84     it('Should not login with an invalid password', async function () {
  85       const user = { username: server.store.user.username, password: 'mew_three' }
  86       const body = await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  87
  88       expect(body.code).to.equal(OAuth2ErrorCode.INVALID_GRANT)
  89       expect(body.error).to.contain('credentials are invalid')
  90       expect(body.type.startsWith('https://')).to.be.true
  91       expect(body.type).to.contain(OAuth2ErrorCode.INVALID_GRANT)
  92     })
  93
  94     it('Should not be able to upload a video', async function () {
  95       token = 'my_super_token'
  96
  97       await server.videos.upload({ token, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
  98     })
  99
 100     it('Should not be able to follow', async function () {
 101       token = 'my_super_token'
 102
 103       await server.follows.follow({
 104         hosts: [ 'http://example.com' ],
 105         token,
 106         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
 107       })
 108     })
 109
 110     it('Should not be able to unfollow')
 111
 112     it('Should be able to login', async function () {
 113       const body = await server.login.login({ expectedStatus: HttpStatusCode.OK_200 })
 114
 115       token = body.access_token
 116     })
 117
 118     it('Should be able to login with an insensitive username', async function () {
 119       const user = { username: 'RoOt', password: server.store.user.password }
 120       await server.login.login({ user, expectedStatus: HttpStatusCode.OK_200 })
 121
 122       const user2 = { username: 'rOoT', password: server.store.user.password }
 123       await server.login.login({ user: user2, expectedStatus: HttpStatusCode.OK_200 })
 124
 125       const user3 = { username: 'ROOt', password: server.store.user.password }
 126       await server.login.login({ user: user3, expectedStatus: HttpStatusCode.OK_200 })
 127     })
 128   })
 129
 130   describe('Logout', function () {
 131     it('Should logout (revoke token)', async function () {
 132       await server.login.logout({ token: server.accessToken })
 133     })
 134
 135     it('Should not be able to get the user information', async function () {
 136       await server.users.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 137     })
 138
 139     it('Should not be able to upload a video', async function () {
 140       await server.videos.upload({ attributes: { name: 'video' }, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 141     })
 142
 143     it('Should not be able to rate a video', async function () {
 144       const path = '/api/v1/videos/'
 145       const data = {
 146         rating: 'likes'
 147       }
 148
 149       const options = {
 150         url: server.url,
 151         path: path + videoId,
 152         token: 'wrong token',
 153         fields: data,
 154         expectedStatus: HttpStatusCode.UNAUTHORIZED_401
 155       }
 156       await makePutBodyRequest(options)
 157     })
 158
 159     it('Should be able to login again', async function () {
 160       const body = await server.login.login()
 161       server.accessToken = body.access_token
 162       server.refreshToken = body.refresh_token
 163     })
 164
 165     it('Should be able to get my user information again', async function () {
 166       await server.users.getMyInfo()
 167     })
 168
 169     it('Should have an expired access token', async function () {
 170       this.timeout(60000)
 171
 172       await server.sql.setTokenField(server.accessToken, 'accessTokenExpiresAt', new Date().toISOString())
 173       await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', new Date().toISOString())
 174
 175       await killallServers([ server ])
 176       await server.run()
 177
 178       await server.users.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 179     })
 180
 181     it('Should not be able to refresh an access token with an expired refresh token', async function () {
 182       await server.login.refreshToken({ refreshToken: server.refreshToken, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 183     })
 184
 185     it('Should refresh the token', async function () {
 186       this.timeout(15000)
 187
 188       const futureDate = new Date(new Date().getTime() + 1000 * 60).toISOString()
 189       await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', futureDate)
 190
 191       await killallServers([ server ])
 192       await server.run()
 193
 194       const res = await server.login.refreshToken({ refreshToken: server.refreshToken })
 195       server.accessToken = res.body.access_token
 196       server.refreshToken = res.body.refresh_token
 197     })
 198
 199     it('Should be able to get my user information again', async function () {
 200       await server.users.getMyInfo()
 201     })
 202   })
 203
 204   describe('Creating a user', function () {
 205
 206     it('Should be able to create a new user', async function () {
 207       await server.users.create({ ...user, videoQuota: 2 * 1024 * 1024, adminFlags: UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST })
 208     })
 209
 210     it('Should be able to login with this user', async function () {
 211       userToken = await server.login.getAccessToken(user)
 212     })
 213
 214     it('Should be able to get user information', async function () {
 215       const userMe = await server.users.getMyInfo({ token: userToken })
 216
 217       const userGet = await server.users.get({ userId: userMe.id, withStats: true })
 218
 219       for (const user of [ userMe, userGet ]) {
 220         expect(user.username).to.equal('user_1')
 221         expect(user.email).to.equal('user_1@example.com')
 222         expect(user.nsfwPolicy).to.equal('display')
 223         expect(user.videoQuota).to.equal(2 * 1024 * 1024)
 224         expect(user.roleLabel).to.equal('User')
 225         expect(user.id).to.be.a('number')
 226         expect(user.account.displayName).to.equal('user_1')
 227         expect(user.account.description).to.be.null
 228       }
 229
 230       expect(userMe.adminFlags).to.equal(UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST)
 231       expect(userGet.adminFlags).to.equal(UserAdminFlag.BYPASS_VIDEO_AUTO_BLACKLIST)
 232
 233       expect(userMe.specialPlaylists).to.have.lengthOf(1)
 234       expect(userMe.specialPlaylists[0].type).to.equal(VideoPlaylistType.WATCH_LATER)
 235
 236       // Check stats are included with withStats
 237       expect(userGet.videosCount).to.be.a('number')
 238       expect(userGet.videosCount).to.equal(0)
 239       expect(userGet.videoCommentsCount).to.be.a('number')
 240       expect(userGet.videoCommentsCount).to.equal(0)
 241       expect(userGet.abusesCount).to.be.a('number')
 242       expect(userGet.abusesCount).to.equal(0)
 243       expect(userGet.abusesAcceptedCount).to.be.a('number')
 244       expect(userGet.abusesAcceptedCount).to.equal(0)
 245     })
 246   })
 247
 248   describe('Users listing', function () {
 249
 250     it('Should list all the users', async function () {
 251       const { data, total } = await server.users.list()
 252
 253       expect(total).to.equal(2)
 254       expect(data).to.be.an('array')
 255       expect(data.length).to.equal(2)
 256
 257       const user = data[0]
 258       expect(user.username).to.equal('user_1')
 259       expect(user.email).to.equal('user_1@example.com')
 260       expect(user.nsfwPolicy).to.equal('display')
 261
 262       const rootUser = data[1]
 263       expect(rootUser.username).to.equal('root')
 264       expect(rootUser.email).to.equal('admin' + server.internalServerNumber + '@example.com')
 265       expect(user.nsfwPolicy).to.equal('display')
 266
 267       expect(rootUser.lastLoginDate).to.exist
 268       expect(user.lastLoginDate).to.exist
 269
 270       userId = user.id
 271     })
 272
 273     it('Should list only the first user by username asc', async function () {
 274       const { total, data } = await server.users.list({ start: 0, count: 1, sort: 'username' })
 275
 276       expect(total).to.equal(2)
 277       expect(data.length).to.equal(1)
 278
 279       const user = data[0]
 280       expect(user.username).to.equal('root')
 281       expect(user.email).to.equal('admin' + server.internalServerNumber + '@example.com')
 282       expect(user.roleLabel).to.equal('Administrator')
 283       expect(user.nsfwPolicy).to.equal('display')
 284     })
 285
 286     it('Should list only the first user by username desc', async function () {
 287       const { total, data } = await server.users.list({ start: 0, count: 1, sort: '-username' })
 288
 289       expect(total).to.equal(2)
 290       expect(data.length).to.equal(1)
 291
 292       const user = data[0]
 293       expect(user.username).to.equal('user_1')
 294       expect(user.email).to.equal('user_1@example.com')
 295       expect(user.nsfwPolicy).to.equal('display')
 296     })
 297
 298     it('Should list only the second user by createdAt desc', async function () {
 299       const { data, total } = await server.users.list({ start: 0, count: 1, sort: '-createdAt' })
 300       expect(total).to.equal(2)
 301
 302       expect(data.length).to.equal(1)
 303
 304       const user = data[0]
 305       expect(user.username).to.equal('user_1')
 306       expect(user.email).to.equal('user_1@example.com')
 307       expect(user.nsfwPolicy).to.equal('display')
 308     })
 309
 310     it('Should list all the users by createdAt asc', async function () {
 311       const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt' })
 312
 313       expect(total).to.equal(2)
 314       expect(data.length).to.equal(2)
 315
 316       expect(data[0].username).to.equal('root')
 317       expect(data[0].email).to.equal('admin' + server.internalServerNumber + '@example.com')
 318       expect(data[0].nsfwPolicy).to.equal('display')
 319
 320       expect(data[1].username).to.equal('user_1')
 321       expect(data[1].email).to.equal('user_1@example.com')
 322       expect(data[1].nsfwPolicy).to.equal('display')
 323     })
 324
 325     it('Should search user by username', async function () {
 326       const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'oot' })
 327       expect(total).to.equal(1)
 328       expect(data.length).to.equal(1)
 329       expect(data[0].username).to.equal('root')
 330     })
 331
 332     it('Should search user by email', async function () {
 333       {
 334         const { total, data } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'r_1@exam' })
 335         expect(total).to.equal(1)
 336         expect(data.length).to.equal(1)
 337         expect(data[0].username).to.equal('user_1')
 338         expect(data[0].email).to.equal('user_1@example.com')
 339       }
 340
 341       {
 342         const { total, data } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', search: 'example' })
 343         expect(total).to.equal(2)
 344         expect(data.length).to.equal(2)
 345         expect(data[0].username).to.equal('root')
 346         expect(data[1].username).to.equal('user_1')
 347       }
 348     })
 349   })
 350
 351   describe('Update my account', function () {
 352
 353     it('Should update my password', async function () {
 354       await server.users.updateMe({
 355         token: userToken,
 356         currentPassword: 'super password',
 357         password: 'new password'
 358       })
 359       user.password = 'new password'
 360
 361       await server.login.login({ user })
 362     })
 363
 364     it('Should be able to change the NSFW display attribute', async function () {
 365       await server.users.updateMe({
 366         token: userToken,
 367         nsfwPolicy: 'do_not_list'
 368       })
 369
 370       const user = await server.users.getMyInfo({ token: userToken })
 371       expect(user.username).to.equal('user_1')
 372       expect(user.email).to.equal('user_1@example.com')
 373       expect(user.nsfwPolicy).to.equal('do_not_list')
 374       expect(user.videoQuota).to.equal(2 * 1024 * 1024)
 375       expect(user.id).to.be.a('number')
 376       expect(user.account.displayName).to.equal('user_1')
 377       expect(user.account.description).to.be.null
 378     })
 379
 380     it('Should be able to change the autoPlayVideo attribute', async function () {
 381       await server.users.updateMe({
 382         token: userToken,
 383         autoPlayVideo: false
 384       })
 385
 386       const user = await server.users.getMyInfo({ token: userToken })
 387       expect(user.autoPlayVideo).to.be.false
 388     })
 389
 390     it('Should be able to change the autoPlayNextVideo attribute', async function () {
 391       await server.users.updateMe({
 392         token: userToken,
 393         autoPlayNextVideo: true
 394       })
 395
 396       const user = await server.users.getMyInfo({ token: userToken })
 397       expect(user.autoPlayNextVideo).to.be.true
 398     })
 399
 400     it('Should be able to change the p2p attribute', async function () {
 401       {
 402         await server.users.updateMe({
 403           token: userToken,
 404           webTorrentEnabled: false
 405         })
 406
 407         const user = await server.users.getMyInfo({ token: userToken })
 408         expect(user.p2pEnabled).to.be.false
 409       }
 410
 411       {
 412         await server.users.updateMe({
 413           token: userToken,
 414           p2pEnabled: true
 415         })
 416
 417         const user = await server.users.getMyInfo({ token: userToken })
 418         expect(user.p2pEnabled).to.be.true
 419       }
 420     })
 421
 422     it('Should be able to change the email attribute', async function () {
 423       await server.users.updateMe({
 424         token: userToken,
 425         currentPassword: 'new password',
 426         email: 'updated@example.com'
 427       })
 428
 429       const user = await server.users.getMyInfo({ token: userToken })
 430       expect(user.username).to.equal('user_1')
 431       expect(user.email).to.equal('updated@example.com')
 432       expect(user.nsfwPolicy).to.equal('do_not_list')
 433       expect(user.videoQuota).to.equal(2 * 1024 * 1024)
 434       expect(user.id).to.be.a('number')
 435       expect(user.account.displayName).to.equal('user_1')
 436       expect(user.account.description).to.be.null
 437     })
 438
 439     it('Should be able to update my avatar with a gif', async function () {
 440       const fixture = 'avatar.gif'
 441
 442       await server.users.updateMyAvatar({ token: userToken, fixture })
 443
 444       const user = await server.users.getMyInfo({ token: userToken })
 445       for (const avatar of user.account.avatars) {
 446         await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, '.gif')
 447       }
 448     })
 449
 450     it('Should be able to update my avatar with a gif, and then a png', async function () {
 451       for (const extension of [ '.png', '.gif' ]) {
 452         const fixture = 'avatar' + extension
 453
 454         await server.users.updateMyAvatar({ token: userToken, fixture })
 455
 456         const user = await server.users.getMyInfo({ token: userToken })
 457         for (const avatar of user.account.avatars) {
 458           await testImage(server.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, extension)
 459         }
 460       }
 461     })
 462
 463     it('Should be able to update my display name', async function () {
 464       await server.users.updateMe({ token: userToken, displayName: 'new display name' })
 465
 466       const user = await server.users.getMyInfo({ token: userToken })
 467       expect(user.username).to.equal('user_1')
 468       expect(user.email).to.equal('updated@example.com')
 469       expect(user.nsfwPolicy).to.equal('do_not_list')
 470       expect(user.videoQuota).to.equal(2 * 1024 * 1024)
 471       expect(user.id).to.be.a('number')
 472       expect(user.account.displayName).to.equal('new display name')
 473       expect(user.account.description).to.be.null
 474     })
 475
 476     it('Should be able to update my description', async function () {
 477       await server.users.updateMe({ token: userToken, description: 'my super description updated' })
 478
 479       const user = await server.users.getMyInfo({ token: userToken })
 480       expect(user.username).to.equal('user_1')
 481       expect(user.email).to.equal('updated@example.com')
 482       expect(user.nsfwPolicy).to.equal('do_not_list')
 483       expect(user.videoQuota).to.equal(2 * 1024 * 1024)
 484       expect(user.id).to.be.a('number')
 485       expect(user.account.displayName).to.equal('new display name')
 486       expect(user.account.description).to.equal('my super description updated')
 487       expect(user.noWelcomeModal).to.be.false
 488       expect(user.noInstanceConfigWarningModal).to.be.false
 489       expect(user.noAccountSetupWarningModal).to.be.false
 490     })
 491
 492     it('Should be able to update my theme', async function () {
 493       for (const theme of [ 'background-red', 'default', 'instance-default' ]) {
 494         await server.users.updateMe({ token: userToken, theme })
 495
 496         const user = await server.users.getMyInfo({ token: userToken })
 497         expect(user.theme).to.equal(theme)
 498       }
 499     })
 500
 501     it('Should be able to update my modal preferences', async function () {
 502       await server.users.updateMe({
 503         token: userToken,
 504         noInstanceConfigWarningModal: true,
 505         noWelcomeModal: true,
 506         noAccountSetupWarningModal: true
 507       })
 508
 509       const user = await server.users.getMyInfo({ token: userToken })
 510       expect(user.noWelcomeModal).to.be.true
 511       expect(user.noInstanceConfigWarningModal).to.be.true
 512       expect(user.noAccountSetupWarningModal).to.be.true
 513     })
 514   })
 515
 516   describe('Updating another user', function () {
 517     it('Should be able to update another user', async function () {
 518       await server.users.update({
 519         userId,
 520         token,
 521         email: 'updated2@example.com',
 522         emailVerified: true,
 523         videoQuota: 42,
 524         role: UserRole.MODERATOR,
 525         adminFlags: UserAdminFlag.NONE,
 526         pluginAuth: 'toto'
 527       })
 528
 529       const user = await server.users.get({ token, userId })
 530
 531       expect(user.username).to.equal('user_1')
 532       expect(user.email).to.equal('updated2@example.com')
 533       expect(user.emailVerified).to.be.true
 534       expect(user.nsfwPolicy).to.equal('do_not_list')
 535       expect(user.videoQuota).to.equal(42)
 536       expect(user.roleLabel).to.equal('Moderator')
 537       expect(user.id).to.be.a('number')
 538       expect(user.adminFlags).to.equal(UserAdminFlag.NONE)
 539       expect(user.pluginAuth).to.equal('toto')
 540     })
 541
 542     it('Should reset the auth plugin', async function () {
 543       await server.users.update({ userId, token, pluginAuth: null })
 544
 545       const user = await server.users.get({ token, userId })
 546       expect(user.pluginAuth).to.be.null
 547     })
 548
 549     it('Should have removed the user token', async function () {
 550       await server.users.getMyQuotaUsed({ token: userToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 551
 552       userToken = await server.login.getAccessToken(user)
 553     })
 554
 555     it('Should be able to update another user password', async function () {
 556       await server.users.update({ userId, token, password: 'password updated' })
 557
 558       await server.users.getMyQuotaUsed({ token: userToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 559
 560       await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 561
 562       user.password = 'password updated'
 563       userToken = await server.login.getAccessToken(user)
 564     })
 565   })
 566
 567   describe('Video blacklists', function () {
 568
 569     it('Should be able to list my video blacklist', async function () {
 570       await server.blacklist.list({ token: userToken })
 571     })
 572   })
 573
 574   describe('Remove a user', function () {
 575
 576     before(async function () {
 577       await server.users.update({
 578         userId,
 579         token,
 580         videoQuota: 2 * 1024 * 1024
 581       })
 582
 583       await server.videos.quickUpload({ name: 'user video', token: userToken, fixture: 'video_short.webm' })
 584       await server.videos.quickUpload({ name: 'root video' })
 585
 586       const { total } = await server.videos.list()
 587       expect(total).to.equal(2)
 588     })
 589
 590     it('Should be able to remove this user', async function () {
 591       await server.users.remove({ userId, token })
 592     })
 593
 594     it('Should not be able to login with this user', async function () {
 595       await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 596     })
 597
 598     it('Should not have videos of this user', async function () {
 599       const { data, total } = await server.videos.list()
 600       expect(total).to.equal(1)
 601
 602       const video = data[0]
 603       expect(video.account.name).to.equal('root')
 604     })
 605   })
 606
 607   describe('Registering a new user', function () {
 608     let user15AccessToken: string
 609
 610     it('Should register a new user', async function () {
 611       const user = { displayName: 'super user 15', username: 'user_15', password: 'my super password' }
 612       const channel = { name: 'my_user_15_channel', displayName: 'my channel rocks' }
 613
 614       await server.users.register({ ...user, channel })
 615     })
 616
 617     it('Should be able to login with this registered user', async function () {
 618       const user15 = {
 619         username: 'user_15',
 620         password: 'my super password'
 621       }
 622
 623       user15AccessToken = await server.login.getAccessToken(user15)
 624     })
 625
 626     it('Should have the correct display name', async function () {
 627       const user = await server.users.getMyInfo({ token: user15AccessToken })
 628       expect(user.account.displayName).to.equal('super user 15')
 629     })
 630
 631     it('Should have the correct video quota', async function () {
 632       const user = await server.users.getMyInfo({ token: user15AccessToken })
 633       expect(user.videoQuota).to.equal(5 * 1024 * 1024)
 634     })
 635
 636     it('Should have created the channel', async function () {
 637       const { displayName } = await server.channels.get({ channelName: 'my_user_15_channel' })
 638
 639       expect(displayName).to.equal('my channel rocks')
 640     })
 641
 642     it('Should remove me', async function () {
 643       {
 644         const { data } = await server.users.list()
 645         expect(data.find(u => u.username === 'user_15')).to.not.be.undefined
 646       }
 647
 648       await server.users.deleteMe({ token: user15AccessToken })
 649
 650       {
 651         const { data } = await server.users.list()
 652         expect(data.find(u => u.username === 'user_15')).to.be.undefined
 653       }
 654     })
 655   })
 656
 657   describe('User blocking', function () {
 658     let user16Id
 659     let user16AccessToken
 660     const user16 = {
 661       username: 'user_16',
 662       password: 'my super password'
 663     }
 664
 665     it('Should block a user', async function () {
 666       const user = await server.users.create({ ...user16 })
 667       user16Id = user.id
 668
 669       user16AccessToken = await server.login.getAccessToken(user16)
 670
 671       await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
 672       await server.users.banUser({ userId: user16Id })
 673
 674       await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 675       await server.login.login({ user: user16, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 676     })
 677
 678     it('Should search user by banned status', async function () {
 679       {
 680         const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', blocked: true })
 681         expect(total).to.equal(1)
 682         expect(data.length).to.equal(1)
 683
 684         expect(data[0].username).to.equal(user16.username)
 685       }
 686
 687       {
 688         const { data, total } = await server.users.list({ start: 0, count: 2, sort: 'createdAt', blocked: false })
 689         expect(total).to.equal(1)
 690         expect(data.length).to.equal(1)
 691
 692         expect(data[0].username).to.not.equal(user16.username)
 693       }
 694     })
 695
 696     it('Should unblock a user', async function () {
 697       await server.users.unbanUser({ userId: user16Id })
 698       user16AccessToken = await server.login.getAccessToken(user16)
 699       await server.users.getMyInfo({ token: user16AccessToken, expectedStatus: HttpStatusCode.OK_200 })
 700     })
 701   })
 702
 703   describe('User stats', function () {
 704     let user17Id: number
 705     let user17AccessToken: string
 706
 707     it('Should report correct initial statistics about a user', async function () {
 708       const user17 = {
 709         username: 'user_17',
 710         password: 'my super password'
 711       }
 712       const created = await server.users.create({ ...user17 })
 713
 714       user17Id = created.id
 715       user17AccessToken = await server.login.getAccessToken(user17)
 716
 717       const user = await server.users.get({ userId: user17Id, withStats: true })
 718       expect(user.videosCount).to.equal(0)
 719       expect(user.videoCommentsCount).to.equal(0)
 720       expect(user.abusesCount).to.equal(0)
 721       expect(user.abusesCreatedCount).to.equal(0)
 722       expect(user.abusesAcceptedCount).to.equal(0)
 723     })
 724
 725     it('Should report correct videos count', async function () {
 726       const attributes = { name: 'video to test user stats' }
 727       await server.videos.upload({ token: user17AccessToken, attributes })
 728
 729       const { data } = await server.videos.list()
 730       videoId = data.find(video => video.name === attributes.name).id
 731
 732       const user = await server.users.get({ userId: user17Id, withStats: true })
 733       expect(user.videosCount).to.equal(1)
 734     })
 735
 736     it('Should report correct video comments for user', async function () {
 737       const text = 'super comment'
 738       await server.comments.createThread({ token: user17AccessToken, videoId, text })
 739
 740       const user = await server.users.get({ userId: user17Id, withStats: true })
 741       expect(user.videoCommentsCount).to.equal(1)
 742     })
 743
 744     it('Should report correct abuses counts', async function () {
 745       const reason = 'my super bad reason'
 746       await server.abuses.report({ token: user17AccessToken, videoId, reason })
 747
 748       const body1 = await server.abuses.getAdminList()
 749       const abuseId = body1.data[0].id
 750
 751       const user2 = await server.users.get({ userId: user17Id, withStats: true })
 752       expect(user2.abusesCount).to.equal(1) // number of incriminations
 753       expect(user2.abusesCreatedCount).to.equal(1) // number of reports created
 754
 755       await server.abuses.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
 756
 757       const user3 = await server.users.get({ userId: user17Id, withStats: true })
 758       expect(user3.abusesAcceptedCount).to.equal(1) // number of reports created accepted
 759     })
 760   })
 761
 762   after(async function () {
 763     await cleanupTests([ server ])
 764   })
 765 })