[github/Chocobozzz/PeerTube.git] / server / tests / api / videos / video-change-ownership.ts

/* tslint:disable:no-unused-expression */

import * as chai from 'chai'
import 'mocha'
import {
  acceptChangeOwnership,
  changeVideoOwnership,
  createUser,
  flushTests,
  getMyUserInformation,
  getVideoChangeOwnershipList,
  getVideosList,
  killallServers,
  refuseChangeOwnership,
  runServer,
  ServerInfo,
  setAccessTokensToServers,
  uploadVideo,
  userLogin
} from '../../utils'
import { waitJobs } from '../../utils/server/jobs'
import { User } from '../../../../shared/models/users'

const expect = chai.expect

describe('Test video change ownership - nominal', function () {
  let server: ServerInfo = undefined
  const firstUser = {
    username: 'first',
    password: 'My great password'
  }
  const secondUser = {
    username: 'second',
    password: 'My other password'
  }
  let firstUserAccessToken = ''
  let secondUserAccessToken = ''
  let lastRequestChangeOwnershipId = undefined

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

    // Run one server
    await flushTests()
    server = await runServer(1)
    await setAccessTokensToServers([server])

    const videoQuota = 42000000
    await createUser(server.url, server.accessToken, firstUser.username, firstUser.password, videoQuota)
    await createUser(server.url, server.accessToken, secondUser.username, secondUser.password, videoQuota)

    firstUserAccessToken = await userLogin(server, firstUser)
    secondUserAccessToken = await userLogin(server, secondUser)

    // Upload some videos on the server
    const video1Attributes = {
      name: 'my super name',
      description: 'my super description'
    }
    await uploadVideo(server.url, firstUserAccessToken, video1Attributes)

    await waitJobs(server)

    const res = await getVideosList(server.url)
    const videos = res.body.data

    expect(videos.length).to.equal(1)

    server.video = videos.find(video => video.name === 'my super name')
  })

  it('Should not have video change ownership', async function () {
    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)

    expect(resFirstUser.body.total).to.equal(0)
    expect(resFirstUser.body.data).to.be.an('array')
    expect(resFirstUser.body.data.length).to.equal(0)

    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)

    expect(resSecondUser.body.total).to.equal(0)
    expect(resSecondUser.body.data).to.be.an('array')
    expect(resSecondUser.body.data.length).to.equal(0)
  })

  it('Should send a request to change ownership of a video', async function () {
    this.timeout(15000)

    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
  })

  it('Should only return a request to change ownership for the second user', async function () {
    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)

    expect(resFirstUser.body.total).to.equal(0)
    expect(resFirstUser.body.data).to.be.an('array')
    expect(resFirstUser.body.data.length).to.equal(0)

    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)

    expect(resSecondUser.body.total).to.equal(1)
    expect(resSecondUser.body.data).to.be.an('array')
    expect(resSecondUser.body.data.length).to.equal(1)

    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
  })

  it('Should accept the same change ownership request without crashing', async function () {
    this.timeout(10000)

    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
  })

  it('Should not create multiple change ownership requests while one is waiting', async function () {
    this.timeout(10000)

    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)

    expect(resSecondUser.body.total).to.equal(1)
    expect(resSecondUser.body.data).to.be.an('array')
    expect(resSecondUser.body.data.length).to.equal(1)
  })

  it('Should not be possible to refuse the change of ownership from first user', async function () {
    this.timeout(10000)

    await refuseChangeOwnership(server.url, firstUserAccessToken, lastRequestChangeOwnershipId, 403)
  })

  it('Should be possible to refuse the change of ownership from second user', async function () {
    this.timeout(10000)

    await refuseChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId)
  })

  it('Should send a new request to change ownership of a video', async function () {
    this.timeout(15000)

    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
  })

  it('Should return two requests to change ownership for the second user', async function () {
    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)

    expect(resFirstUser.body.total).to.equal(0)
    expect(resFirstUser.body.data).to.be.an('array')
    expect(resFirstUser.body.data.length).to.equal(0)

    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)

    expect(resSecondUser.body.total).to.equal(2)
    expect(resSecondUser.body.data).to.be.an('array')
    expect(resSecondUser.body.data.length).to.equal(2)

    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
  })

  it('Should not be possible to accept the change of ownership from first user', async function () {
    this.timeout(10000)

    const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
    const secondUserInformation: User = secondUserInformationResponse.body
    const channelId = secondUserInformation.videoChannels[0].id
    await acceptChangeOwnership(server.url, firstUserAccessToken, lastRequestChangeOwnershipId, channelId, 403)
  })

  it('Should be possible to accept the change of ownership from second user', async function () {
    this.timeout(10000)

    const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
    const secondUserInformation: User = secondUserInformationResponse.body
    const channelId = secondUserInformation.videoChannels[0].id
    await acceptChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId, channelId)
  })

  after(async function () {
    killallServers([server])
  })
})

describe('Test video change ownership - quota too small', function () {
  let server: ServerInfo = undefined
  const firstUser = {
    username: 'first',
    password: 'My great password'
  }
  const secondUser = {
    username: 'second',
    password: 'My other password'
  }
  let firstUserAccessToken = ''
  let secondUserAccessToken = ''
  let lastRequestChangeOwnershipId = undefined

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

    // Run one server
    await flushTests()
    server = await runServer(1)
    await setAccessTokensToServers([server])

    const videoQuota = 42000000
    const limitedVideoQuota = 10
    await createUser(server.url, server.accessToken, firstUser.username, firstUser.password, videoQuota)
    await createUser(server.url, server.accessToken, secondUser.username, secondUser.password, limitedVideoQuota)

    firstUserAccessToken = await userLogin(server, firstUser)
    secondUserAccessToken = await userLogin(server, secondUser)

    // Upload some videos on the server
    const video1Attributes = {
      name: 'my super name',
      description: 'my super description'
    }
    await uploadVideo(server.url, firstUserAccessToken, video1Attributes)

    await waitJobs(server)

    const res = await getVideosList(server.url)
    const videos = res.body.data

    expect(videos.length).to.equal(1)

    server.video = videos.find(video => video.name === 'my super name')
  })

  it('Should send a request to change ownership of a video', async function () {
    this.timeout(15000)

    await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
  })

  it('Should only return a request to change ownership for the second user', async function () {
    const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)

    expect(resFirstUser.body.total).to.equal(0)
    expect(resFirstUser.body.data).to.be.an('array')
    expect(resFirstUser.body.data.length).to.equal(0)

    const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)

    expect(resSecondUser.body.total).to.equal(1)
    expect(resSecondUser.body.data).to.be.an('array')
    expect(resSecondUser.body.data.length).to.equal(1)

    lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
  })

  it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
    this.timeout(10000)

    const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
    const secondUserInformation: User = secondUserInformationResponse.body
    const channelId = secondUserInformation.videoChannels[0].id
    await acceptChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId, channelId, 403)
  })

  after(async function () {
    killallServers([server])
  })
})
Commit	Line	Data
74d63469 GR	1	/* tslint:disable:no-unused-expression */
	2
	3	import * as chai from 'chai'
	4	import 'mocha'
	5	import {
	6	acceptChangeOwnership,
	7	changeVideoOwnership,
	8	createUser,
	9	flushTests,
	10	getMyUserInformation,
	11	getVideoChangeOwnershipList,
	12	getVideosList,
	13	killallServers,
	14	refuseChangeOwnership,
	15	runServer,
	16	ServerInfo,
	17	setAccessTokensToServers,
	18	uploadVideo,
	19	userLogin
	20	} from '../../utils'
	21	import { waitJobs } from '../../utils/server/jobs'
	22	import { User } from '../../../../shared/models/users'
	23
	24	const expect = chai.expect
	25
	26	describe('Test video change ownership - nominal', function () {
	27	let server: ServerInfo = undefined
	28	const firstUser = {
	29	username: 'first',
	30	password: 'My great password'
	31	}
	32	const secondUser = {
	33	username: 'second',
	34	password: 'My other password'
	35	}
	36	let firstUserAccessToken = ''
	37	let secondUserAccessToken = ''
	38	let lastRequestChangeOwnershipId = undefined
	39
	40	before(async function () {
	41	this.timeout(50000)
	42
	43	// Run one server
	44	await flushTests()
	45	server = await runServer(1)
	46	await setAccessTokensToServers([server])
	47
	48	const videoQuota = 42000000
	49	await createUser(server.url, server.accessToken, firstUser.username, firstUser.password, videoQuota)
	50	await createUser(server.url, server.accessToken, secondUser.username, secondUser.password, videoQuota)
	51
	52	firstUserAccessToken = await userLogin(server, firstUser)
	53	secondUserAccessToken = await userLogin(server, secondUser)
	54
	55	// Upload some videos on the server
	56	const video1Attributes = {
	57	name: 'my super name',
	58	description: 'my super description'
	59	}
	60	await uploadVideo(server.url, firstUserAccessToken, video1Attributes)
	61
	62	await waitJobs(server)
	63
	64	const res = await getVideosList(server.url)
65	const videos = res.body.data
66
67	expect(videos.length).to.equal(1)
68
69	server.video = videos.find(video => video.name === 'my super name')
70	})
71
72	it('Should not have video change ownership', async function () {
73	const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
74
75	expect(resFirstUser.body.total).to.equal(0)
76	expect(resFirstUser.body.data).to.be.an('array')
77	expect(resFirstUser.body.data.length).to.equal(0)
78
79	const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
80
81	expect(resSecondUser.body.total).to.equal(0)
82	expect(resSecondUser.body.data).to.be.an('array')
83	expect(resSecondUser.body.data.length).to.equal(0)
84	})
85
86	it('Should send a request to change ownership of a video', async function () {
87	this.timeout(15000)
88
89	await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
90	})
91
92	it('Should only return a request to change ownership for the second user', async function () {
93	const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
94
95	expect(resFirstUser.body.total).to.equal(0)
96	expect(resFirstUser.body.data).to.be.an('array')
97	expect(resFirstUser.body.data.length).to.equal(0)
98
99	const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
100
101	expect(resSecondUser.body.total).to.equal(1)
102	expect(resSecondUser.body.data).to.be.an('array')
103	expect(resSecondUser.body.data.length).to.equal(1)
104
105	lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
106	})
107
108	it('Should accept the same change ownership request without crashing', async function () {
109	this.timeout(10000)
110
111	await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
112	})
113
114	it('Should not create multiple change ownership requests while one is waiting', async function () {
115	this.timeout(10000)
116
117	const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
118
119	expect(resSecondUser.body.total).to.equal(1)
120	expect(resSecondUser.body.data).to.be.an('array')
121	expect(resSecondUser.body.data.length).to.equal(1)
122	})
123
124	it('Should not be possible to refuse the change of ownership from first user', async function () {
125	this.timeout(10000)
126
127	await refuseChangeOwnership(server.url, firstUserAccessToken, lastRequestChangeOwnershipId, 403)
128	})
129
130	it('Should be possible to refuse the change of ownership from second user', async function () {
131	this.timeout(10000)
132
133	await refuseChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId)
134	})
135
136	it('Should send a new request to change ownership of a video', async function () {
137	this.timeout(15000)
138
139	await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
140	})
141
142	it('Should return two requests to change ownership for the second user', async function () {
143	const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
144
145	expect(resFirstUser.body.total).to.equal(0)
146	expect(resFirstUser.body.data).to.be.an('array')
147	expect(resFirstUser.body.data.length).to.equal(0)
148
149	const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
150
151	expect(resSecondUser.body.total).to.equal(2)
152	expect(resSecondUser.body.data).to.be.an('array')
153	expect(resSecondUser.body.data.length).to.equal(2)
154
155	lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
156	})
157
158	it('Should not be possible to accept the change of ownership from first user', async function () {
159	this.timeout(10000)
160
161	const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
162	const secondUserInformation: User = secondUserInformationResponse.body
163	const channelId = secondUserInformation.videoChannels[0].id
164	await acceptChangeOwnership(server.url, firstUserAccessToken, lastRequestChangeOwnershipId, channelId, 403)
165	})
166
167	it('Should be possible to accept the change of ownership from second user', async function () {
168	this.timeout(10000)
169
170	const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
171	const secondUserInformation: User = secondUserInformationResponse.body
172	const channelId = secondUserInformation.videoChannels[0].id
173	await acceptChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId, channelId)
174	})
175
176	after(async function () {
177	killallServers([server])
178	})
179	})
180
181	describe('Test video change ownership - quota too small', function () {
182	let server: ServerInfo = undefined
183	const firstUser = {
184	username: 'first',
185	password: 'My great password'
186	}
187	const secondUser = {
188	username: 'second',
189	password: 'My other password'
190	}
191	let firstUserAccessToken = ''
192	let secondUserAccessToken = ''
193	let lastRequestChangeOwnershipId = undefined
194
195	before(async function () {
196	this.timeout(50000)
197
198	// Run one server
199	await flushTests()
200	server = await runServer(1)
201	await setAccessTokensToServers([server])
202
203	const videoQuota = 42000000
204	const limitedVideoQuota = 10
205	await createUser(server.url, server.accessToken, firstUser.username, firstUser.password, videoQuota)
206	await createUser(server.url, server.accessToken, secondUser.username, secondUser.password, limitedVideoQuota)
207
208	firstUserAccessToken = await userLogin(server, firstUser)
209	secondUserAccessToken = await userLogin(server, secondUser)
210
211	// Upload some videos on the server
212	const video1Attributes = {
213	name: 'my super name',
214	description: 'my super description'
215	}
216	await uploadVideo(server.url, firstUserAccessToken, video1Attributes)
217
218	await waitJobs(server)
219
220	const res = await getVideosList(server.url)
221	const videos = res.body.data
222
223	expect(videos.length).to.equal(1)
224
225	server.video = videos.find(video => video.name === 'my super name')
226	})
227
228	it('Should send a request to change ownership of a video', async function () {
229	this.timeout(15000)
230
231	await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
232	})
233
234	it('Should only return a request to change ownership for the second user', async function () {
235	const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
236
237	expect(resFirstUser.body.total).to.equal(0)
238	expect(resFirstUser.body.data).to.be.an('array')
239	expect(resFirstUser.body.data.length).to.equal(0)
240
241	const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
242
243	expect(resSecondUser.body.total).to.equal(1)
244	expect(resSecondUser.body.data).to.be.an('array')
245	expect(resSecondUser.body.data.length).to.equal(1)
246
247	lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
248	})
249
250	it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
251	this.timeout(10000)
252
253	const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
254	const secondUserInformation: User = secondUserInformationResponse.body
255	const channelId = secondUserInformation.videoChannels[0].id
256	await acceptChangeOwnership(server.url, secondUserAccessToken, lastRequestChangeOwnershipId, channelId, 403)
257	})
258
259	after(async function () {
260	killallServers([server])
261	})
262	})