server/tests/api/users/users.ts

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