server/tests/api/server/logs.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { HttpStatusCode } from '@shared/models'
   5 import {
   6   cleanupTests,
   7   createSingleServer,
   8   killallServers,
   9   LogsCommand,
  10   PeerTubeServer,
  11   setAccessTokensToServers,
  12   waitJobs
  13 } from '@shared/server-commands'
  14
  15 describe('Test logs', function () {
  16   let server: PeerTubeServer
  17   let logsCommand: LogsCommand
  18
  19   before(async function () {
  20     this.timeout(30000)
  21
  22     server = await createSingleServer(1)
  23     await setAccessTokensToServers([ server ])
  24
  25     logsCommand = server.logs
  26   })
  27
  28   describe('With the standard log file', function () {
  29
  30     it('Should get logs with a start date', async function () {
  31       this.timeout(20000)
  32
  33       await server.videos.upload({ attributes: { name: 'video 1' } })
  34       await waitJobs([ server ])
  35
  36       const now = new Date()
  37
  38       await server.videos.upload({ attributes: { name: 'video 2' } })
  39       await waitJobs([ server ])
  40
  41       const body = await logsCommand.getLogs({ startDate: now })
  42       const logsString = JSON.stringify(body)
  43
  44       expect(logsString.includes('video 1')).to.be.false
  45       expect(logsString.includes('video 2')).to.be.true
  46     })
  47
  48     it('Should get logs with an end date', async function () {
  49       this.timeout(30000)
  50
  51       await server.videos.upload({ attributes: { name: 'video 3' } })
  52       await waitJobs([ server ])
  53
  54       const now1 = new Date()
  55
  56       await server.videos.upload({ attributes: { name: 'video 4' } })
  57       await waitJobs([ server ])
  58
  59       const now2 = new Date()
  60
  61       await server.videos.upload({ attributes: { name: 'video 5' } })
  62       await waitJobs([ server ])
  63
  64       const body = await logsCommand.getLogs({ startDate: now1, endDate: now2 })
  65       const logsString = JSON.stringify(body)
  66
  67       expect(logsString.includes('video 3')).to.be.false
  68       expect(logsString.includes('video 4')).to.be.true
  69       expect(logsString.includes('video 5')).to.be.false
  70     })
  71
  72     it('Should filter by level', async function () {
  73       this.timeout(20000)
  74
  75       const now = new Date()
  76
  77       await server.videos.upload({ attributes: { name: 'video 6' } })
  78       await waitJobs([ server ])
  79
  80       {
  81         const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
  82         const logsString = JSON.stringify(body)
  83
  84         expect(logsString.includes('video 6')).to.be.true
  85       }
  86
  87       {
  88         const body = await logsCommand.getLogs({ startDate: now, level: 'warn' })
  89         const logsString = JSON.stringify(body)
  90
  91         expect(logsString.includes('video 6')).to.be.false
  92       }
  93     })
  94
  95     it('Should filter by tag', async function () {
  96       const now = new Date()
  97
  98       const { uuid } = await server.videos.upload({ attributes: { name: 'video 6' } })
  99       await waitJobs([ server ])
 100
 101       {
 102         const body = await logsCommand.getLogs({ startDate: now, level: 'debug', tagsOneOf: [ 'toto' ] })
 103         expect(body).to.have.lengthOf(0)
 104       }
 105
 106       {
 107         const body = await logsCommand.getLogs({ startDate: now, level: 'debug', tagsOneOf: [ uuid ] })
 108         expect(body).to.not.have.lengthOf(0)
 109
 110         for (const line of body) {
 111           expect(line.tags).to.contain(uuid)
 112         }
 113       }
 114     })
 115
 116     it('Should log ping requests', async function () {
 117       this.timeout(10000)
 118
 119       const now = new Date()
 120
 121       await server.servers.ping()
 122
 123       const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
 124       const logsString = JSON.stringify(body)
 125
 126       expect(logsString.includes('/api/v1/ping')).to.be.true
 127     })
 128
 129     it('Should not log ping requests', async function () {
 130       this.timeout(30000)
 131
 132       await killallServers([ server ])
 133
 134       await server.run({ log: { log_ping_requests: false } })
 135
 136       const now = new Date()
 137
 138       await server.servers.ping()
 139
 140       const body = await logsCommand.getLogs({ startDate: now, level: 'info' })
 141       const logsString = JSON.stringify(body)
 142
 143       expect(logsString.includes('/api/v1/ping')).to.be.false
 144     })
 145   })
 146
 147   describe('With the audit log', function () {
 148     it('Should get logs with a start date', async function () {
 149       this.timeout(20000)
 150
 151       await server.videos.upload({ attributes: { name: 'video 7' } })
 152       await waitJobs([ server ])
 153
 154       const now = new Date()
 155
 156       await server.videos.upload({ attributes: { name: 'video 8' } })
 157       await waitJobs([ server ])
 158
 159       const body = await logsCommand.getAuditLogs({ startDate: now })
 160       const logsString = JSON.stringify(body)
 161
 162       expect(logsString.includes('video 7')).to.be.false
 163       expect(logsString.includes('video 8')).to.be.true
 164
 165       expect(body).to.have.lengthOf(1)
 166
 167       const item = body[0]
 168
 169       const message = JSON.parse(item.message)
 170       expect(message.domain).to.equal('videos')
 171       expect(message.action).to.equal('create')
 172     })
 173
 174     it('Should get logs with an end date', async function () {
 175       this.timeout(30000)
 176
 177       await server.videos.upload({ attributes: { name: 'video 9' } })
 178       await waitJobs([ server ])
 179
 180       const now1 = new Date()
 181
 182       await server.videos.upload({ attributes: { name: 'video 10' } })
 183       await waitJobs([ server ])
 184
 185       const now2 = new Date()
 186
 187       await server.videos.upload({ attributes: { name: 'video 11' } })
 188       await waitJobs([ server ])
 189
 190       const body = await logsCommand.getAuditLogs({ startDate: now1, endDate: now2 })
 191       const logsString = JSON.stringify(body)
 192
 193       expect(logsString.includes('video 9')).to.be.false
 194       expect(logsString.includes('video 10')).to.be.true
 195       expect(logsString.includes('video 11')).to.be.false
 196     })
 197   })
 198
 199   describe('When creating log from the client', function () {
 200
 201     it('Should create a warn client log', async function () {
 202       const now = new Date()
 203
 204       await server.logs.createLogClient({
 205         payload: {
 206           level: 'warn',
 207           url: 'http://example.com',
 208           message: 'my super client message'
 209         },
 210         token: null
 211       })
 212
 213       const body = await logsCommand.getLogs({ startDate: now })
 214       const logsString = JSON.stringify(body)
 215
 216       expect(logsString.includes('my super client message')).to.be.true
 217     })
 218
 219     it('Should create an error authenticated client log', async function () {
 220       const now = new Date()
 221
 222       await server.logs.createLogClient({
 223         payload: {
 224           url: 'https://example.com/page1',
 225           level: 'error',
 226           message: 'my super client message 2',
 227           userAgent: 'super user agent',
 228           meta: '{hello}',
 229           stackTrace: 'super stack trace'
 230         }
 231       })
 232
 233       const body = await logsCommand.getLogs({ startDate: now })
 234       const logsString = JSON.stringify(body)
 235
 236       expect(logsString.includes('my super client message 2')).to.be.true
 237       expect(logsString.includes('super user agent')).to.be.true
 238       expect(logsString.includes('super stack trace')).to.be.true
 239       expect(logsString.includes('{hello}')).to.be.true
 240       expect(logsString.includes('https://example.com/page1')).to.be.true
 241     })
 242
 243     it('Should refuse to create client logs', async function () {
 244       await server.kill()
 245
 246       await server.run({
 247         log: {
 248           accept_client_log: false
 249         }
 250       })
 251
 252       await server.logs.createLogClient({
 253         payload: {
 254           level: 'warn',
 255           url: 'http://example.com',
 256           message: 'my super client message'
 257         },
 258         expectedStatus: HttpStatusCode.FORBIDDEN_403
 259       })
 260     })
 261   })
 262
 263   after(async function () {
 264     await cleanupTests([ server ])
 265   })
 266 })