aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/tests/plugins/video-constants.ts
blob: f527a2b3019e78c09b7b9175cfd231be9b5ff80b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */

import 'mocha'
import * as chai from 'chai'
import { cleanupTests, createSingleServer, PeerTubeServer, PluginsCommand, setAccessTokensToServers } from '@shared/extra-utils'
import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'

const expect = chai.expect

describe('Test plugin altering video constants', function () {
  let server: PeerTubeServer

  before(async function () {
    this.timeout(30000)

    server = await createSingleServer(1)
    await setAccessTokensToServers([ server ])

    await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-video-constants') })
  })

  it('Should have updated languages', async function () {
    const languages = await server.videos.getLanguages()

    expect(languages['en']).to.not.exist
    expect(languages['fr']).to.not.exist

    expect(languages['al_bhed']).to.equal('Al Bhed')
    expect(languages['al_bhed2']).to.equal('Al Bhed 2')
    expect(languages['al_bhed3']).to.not.exist
  })

  it('Should have updated categories', async function () {
    const categories = await server.videos.getCategories()

    expect(categories[1]).to.not.exist
    expect(categories[2]).to.not.exist

    expect(categories[42]).to.equal('Best category')
    expect(categories[43]).to.equal('High best category')
  })

  it('Should have updated licences', async function () {
    const licences = await server.videos.getLicences()

    expect(licences[1]).to.not.exist
    expect(licences[7]).to.not.exist

    expect(licences[42]).to.equal('Best licence')
    expect(licences[43]).to.equal('High best licence')
  })

  it('Should have updated video privacies', async function () {
    const privacies = await server.videos.getPrivacies()

    expect(privacies[1]).to.exist
    expect(privacies[2]).to.not.exist
    expect(privacies[3]).to.exist
    expect(privacies[4]).to.exist
  })

  it('Should have updated playlist privacies', async function () {
    const playlistPrivacies = await server.playlists.getPrivacies()

    expect(playlistPrivacies[1]).to.exist
    expect(playlistPrivacies[2]).to.exist
    expect(playlistPrivacies[3]).to.not.exist
  })

  it('Should not be able to create a video with this privacy', async function () {
    const attributes = { name: 'video', privacy: 2 }
    await server.videos.upload({ attributes, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  })

  it('Should not be able to create a video with this privacy', async function () {
    const attributes = { displayName: 'video playlist', privacy: VideoPlaylistPrivacy.PRIVATE }
    await server.playlists.create({ attributes, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
  })

  it('Should be able to upload a video with these values', async function () {
    const attributes = { name: 'video', category: 42, licence: 42, language: 'al_bhed2' }
    const { uuid } = await server.videos.upload({ attributes })

    const video = await server.videos.get({ id: uuid })
    expect(video.language.label).to.equal('Al Bhed 2')
    expect(video.licence.label).to.equal('Best licence')
    expect(video.category.label).to.equal('Best category')
  })

  it('Should uninstall the plugin and reset languages, categories, licences and privacies', async function () {
    await server.plugins.uninstall({ npmName: 'peertube-plugin-test-video-constants' })

    {
      const languages = await server.videos.getLanguages()

      expect(languages['en']).to.equal('English')
      expect(languages['fr']).to.equal('French')

      expect(languages['al_bhed']).to.not.exist
      expect(languages['al_bhed2']).to.not.exist
      expect(languages['al_bhed3']).to.not.exist
    }

    {
      const categories = await server.videos.getCategories()

      expect(categories[1]).to.equal('Music')
      expect(categories[2]).to.equal('Films')

      expect(categories[42]).to.not.exist
      expect(categories[43]).to.not.exist
    }

    {
      const licences = await server.videos.getLicences()

      expect(licences[1]).to.equal('Attribution')
      expect(licences[7]).to.equal('Public Domain Dedication')

      expect(licences[42]).to.not.exist
      expect(licences[43]).to.not.exist
    }

    {
      const privacies = await server.videos.getPrivacies()

      expect(privacies[1]).to.exist
      expect(privacies[2]).to.exist
      expect(privacies[3]).to.exist
      expect(privacies[4]).to.exist
    }

    {
      const playlistPrivacies = await server.playlists.getPrivacies()

      expect(playlistPrivacies[1]).to.exist
      expect(playlistPrivacies[2]).to.exist
      expect(playlistPrivacies[3]).to.exist
    }
  })

  after(async function () {
    await cleanupTests([ server ])
  })
})