Add tests regarding video import

server/controllers/api/videos/import.ts

@@ -62,7 +62,7 @@ async function addVideoImport (req: express.Request, res: express.Response) {
     remote: false,
     category: body.category || youtubeDLInfo.category,
     licence: body.licence || youtubeDLInfo.licence,
-    language: undefined,
+    language: body.language || undefined,
     commentsEnabled: body.commentsEnabled || true,
     waitTranscoding: body.waitTranscoding || false,
     state: VideoState.TO_IMPORT,
@@ -102,8 +102,9 @@ async function addVideoImport (req: express.Request, res: express.Response) {
     videoCreated.VideoChannel = res.locals.videoChannel
 
     // Set tags to the video
-    if (youtubeDLInfo.tags !== undefined) {
+    const tags = body.tags ? body.tags : youtubeDLInfo.tags
-      const tagInstances = await TagModel.findOrCreateTags(youtubeDLInfo.tags, t)
+    if (tags !== undefined) {
+      const tagInstances = await TagModel.findOrCreateTags(tags, t)
 
       await videoCreated.$set('Tags', tagInstances, sequelizeOptions)
       videoCreated.Tags = tagInstances
@@ -133,5 +134,5 @@ async function addVideoImport (req: express.Request, res: express.Response) {
 
   auditLogger.create(res.locals.oauth.token.User.Account.Actor.getIdentifier(), new VideoImportAuditView(videoImport.toFormattedJSON()))
 
-  return res.json(videoImport.toFormattedJSON())
+  return res.json(videoImport.toFormattedJSON()).end()
 }

server/helpers/youtube-dl.ts

@@ -120,7 +120,7 @@ function getTags (tags: any) {
 function getLicence (licence: string) {
   if (!licence) return undefined
 
-  if (licence.indexOf('Creative Commons Attribution licence') !== -1) return 1
+  if (licence.indexOf('Creative Commons Attribution') !== -1) return 1
 
   return undefined
 }

server/lib/job-queue/handlers/video-import.ts

@@ -98,8 +98,9 @@ async function processVideoImport (job: Bull.Job) {
       video.state = CONFIG.TRANSCODING.ENABLED ? VideoState.TO_TRANSCODE : VideoState.PUBLISHED
       const videoUpdated = await video.save({ transaction: t })
 
-      // Now we can federate the video
+      // Now we can federate the video (reload from database, we need more attributes)
-      await federateVideoIfNeeded(video, true, t)
+      const videoForFederation = await VideoModel.loadByUUIDAndPopulateAccountAndServerAndTags(video.uuid, t)
+      await federateVideoIfNeeded(videoForFederation, true, t)
 
       // Update video import object
       videoImport.state = VideoImportState.SUCCESS

server/models/video/video-import.ts

@@ -39,8 +39,7 @@ import { TagModel } from './tag'
           ]
         },
         {
-          model: () => TagModel,
+          model: () => TagModel
-          required: false
         }
       ]
     }
@@ -106,6 +105,7 @@ export class VideoImportModel extends Model<VideoImportModel> {
 
   static listUserVideoImportsForApi (accountId: number, start: number, count: number, sort: string) {
     const query = {
+      distinct: true,
       offset: start,
       limit: count,
       order: getSort(sort),

server/tests/api/check-params/video-imports.ts

@@ -16,9 +16,11 @@ import {
   runServer,
   ServerInfo,
   setAccessTokensToServers,
+  updateCustomSubConfig,
   userLogin
 } from '../../utils'
 import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '../../utils/requests/check-api-params'
+import { getYoutubeVideoUrl } from '../../utils/videos/video-imports'
 
 describe('Test video imports API validator', function () {
   const path = '/api/v1/videos/imports'
@@ -77,7 +79,7 @@ describe('Test video imports API validator', function () {
 
     before(function () {
       baseCorrectParams = {
-        targetUrl: 'https://youtu.be/msX3jv1XdvM',
+        targetUrl: getYoutubeVideoUrl(),
         name: 'my super name',
         category: 5,
         licence: 1,
@@ -98,6 +100,17 @@ describe('Test video imports API validator', function () {
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
+    it('Should fail without a target url', async function () {
+      const fields = omit(baseCorrectParams, 'targetUrl')
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 400 })
+    })
+
+    it('Should fail with a bad target url', async function () {
+      const fields = immutableAssign(baseCorrectParams, { targetUrl: 'htt://hello' })
+
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
+    })
+
     it('Should fail with a long name', async function () {
       const fields = immutableAssign(baseCorrectParams, { name: 'super'.repeat(65) })
 
@@ -219,20 +232,36 @@ describe('Test video imports API validator', function () {
     it('Should succeed with the correct parameters', async function () {
       this.timeout(10000)
 
-      const fields = baseCorrectParams
-
       {
         await makePostBodyRequest({
           url: server.url,
           path,
           token: server.accessToken,
-          fields,
+          fields: baseCorrectParams,
           statusCodeExpected: 200
         })
       }
     })
 
-    it('Should forbid importing')
+    it('Should forbid to import videos', async function () {
+      await updateCustomSubConfig(server.url, server.accessToken, {
+        import: {
+          videos: {
+            http: {
+              enabled: false
+            }
+          }
+        }
+      })
+
+      await makePostBodyRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        fields: baseCorrectParams,
+        statusCodeExpected: 409
+      })
+    })
   })
 
   after(async function () {

server/tests/api/index-slow.ts

@@ -1,4 +1,5 @@
 // Order of the tests we want to execute
+import './videos/video-channels'
 import './videos/video-transcoder'
 import './videos/multiple-servers'
 import './server/follows'
@@ -7,3 +8,4 @@ import './videos/video-comments'
 import './users/users-multiple-servers'
 import './server/handle-down'
 import './videos/video-schedule-update'
+import './videos/video-imports'

server/tests/api/videos/video-imports.ts

@@ -0,0 +1,161 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
+import {
+  doubleFollow,
+  flushAndRunMultipleServers,
+  getMyUserInformation,
+  getMyVideos,
+  getVideo,
+  getVideosList,
+  killallServers,
+  ServerInfo,
+  setAccessTokensToServers
+} from '../../utils'
+import { waitJobs } from '../../utils/server/jobs'
+import { getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../utils/videos/video-imports'
+
+const expect = chai.expect
+
+describe('Test video imports', function () {
+  let servers: ServerInfo[] = []
+  let channelIdServer1: number
+  let channelIdServer2: number
+
+  async function checkVideoServer1 (url: string, id: number | string) {
+    const res = await getVideo(url, id)
+    const video: VideoDetails = res.body
+
+    expect(video.name).to.equal('small video - youtube')
+    expect(video.category.label).to.equal('News')
+    expect(video.licence.label).to.equal('Attribution')
+    expect(video.language.label).to.equal('Unknown')
+    expect(video.nsfw).to.be.false
+    expect(video.description).to.equal('this is a super description')
+    expect(video.tags).to.deep.equal([ 'tag1', 'tag2' ])
+
+    expect(video.files).to.have.lengthOf(1)
+  }
+
+  async function checkVideoServer2 (url: string, id: number | string) {
+    const res = await getVideo(url, id)
+    const video = res.body
+
+    expect(video.name).to.equal('my super name')
+    expect(video.category.label).to.equal('Entertainment')
+    expect(video.licence.label).to.equal('Public Domain Dedication')
+    expect(video.language.label).to.equal('English')
+    expect(video.nsfw).to.be.false
+    expect(video.description).to.equal('my super description')
+    expect(video.tags).to.deep.equal([ 'supertag1', 'supertag2' ])
+
+    expect(video.files).to.have.lengthOf(1)
+  }
+
+  before(async function () {
+    this.timeout(30000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+
+    {
+      const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
+      channelIdServer1 = res.body.videoChannels[ 0 ].id
+    }
+
+    {
+      const res = await getMyUserInformation(servers[1].url, servers[1].accessToken)
+      channelIdServer2 = res.body.videoChannels[ 0 ].id
+    }
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should import a video on server 1', async function () {
+    this.timeout(60000)
+
+    const attributes = {
+      targetUrl: getYoutubeVideoUrl(),
+      channelId: channelIdServer1,
+      privacy: VideoPrivacy.PUBLIC
+    }
+    const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
+    expect(res.body.video.name).to.equal('small video - youtube')
+  })
+
+  it('Should list the video to import in my videos on server 1', async function () {
+    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5)
+
+    expect(res.body.total).to.equal(1)
+
+    const videos = res.body.data
+    expect(videos).to.have.lengthOf(1)
+    expect(videos[0].name).to.equal('small video - youtube')
+  })
+
+  it('Should list the video to import in my imports on server 1', async function () {
+    const res = await getMyVideoImports(servers[0].url, servers[0].accessToken)
+
+    expect(res.body.total).to.equal(1)
+    const videoImports = res.body.data
+    expect(videoImports).to.have.lengthOf(1)
+
+    expect(videoImports[0].targetUrl).to.equal(getYoutubeVideoUrl())
+    expect(videoImports[0].video.name).to.equal('small video - youtube')
+  })
+
+  it('Should have the video listed on the two instances1', async function () {
+    this.timeout(120000)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      await checkVideoServer1(server.url, res.body.data[0].uuid)
+    }
+  })
+
+  it('Should import a video on server 2 with some fields', async function () {
+    this.timeout(60000)
+
+    const attributes = {
+      targetUrl: getYoutubeVideoUrl(),
+      channelId: channelIdServer1,
+      privacy: VideoPrivacy.PUBLIC,
+      category: 10,
+      licence: 7,
+      language: 'en',
+      name: 'my super name',
+      description: 'my super description',
+      tags: [ 'supertag1', 'supertag2' ]
+    }
+    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
+    expect(res.body.video.name).to.equal('my super name')
+  })
+
+  it('Should have the video listed on the two instances', async function () {
+    this.timeout(120000)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+      expect(res.body.total).to.equal(2)
+      expect(res.body.data).to.have.lengthOf(2)
+
+      await checkVideoServer2(server.url, res.body.data[0].uuid)
+      await checkVideoServer1(server.url, res.body.data[1].uuid)
+    }
+  })
+
+  after(async function () {
+    killallServers(servers)
+  })
+})

server/tests/client.ts

@@ -3,17 +3,21 @@
 import 'mocha'
 import * as chai from 'chai'
 import * as request from 'supertest'
-const expect = chai.expect
-
 import {
-  ServerInfo,
   flushTests,
+  getCustomConfig,
+  getVideosList,
+  killallServers,
+  makeHTMLRequest,
   runServer,
+  ServerInfo,
   serverLogin,
-  uploadVideo,
+  updateCustomConfig,
-  getVideosList, updateCustomConfig, getCustomConfig, killallServers, makeHTMLRequest
+  updateCustomSubConfig,
+  uploadVideo
 } from './utils'
-import { CustomConfig } from '../../shared/models/server/custom-config.model'
+
+const expect = chai.expect
 
 function checkIndexTags (html: string, title: string, description: string, css: string) {
   expect(html).to.contain('<title>' + title + '</title>')
@@ -117,63 +121,14 @@ describe('Test a client controllers', function () {
   })
 
   it('Should update the customized configuration and have the correct index html tags', async function () {
-    const newCustomConfig: CustomConfig = {
+    await updateCustomSubConfig(server.url, server.accessToken, {
       instance: {
-        name: 'PeerTube updated',
-        shortDescription: 'my short description',
-        description: 'my super description',
-        terms: 'my super terms',
-        defaultClientRoute: '/videos/recently-added',
-        defaultNSFWPolicy: 'blur' as 'blur',
         customizations: {
           javascript: 'alert("coucou")',
           css: 'body { background-color: red; }'
         }
-      },
-      services: {
-        twitter: {
-          username: '@Kuja',
-          whitelisted: true
       }
-      },
+    })
-      cache: {
-        previews: {
-          size: 2
-        },
-        captions: {
-          size: 3
-        }
-      },
-      signup: {
-        enabled: false,
-        limit: 5
-      },
-      admin: {
-        email: 'superadmin1@example.com'
-      },
-      user: {
-        videoQuota: 5242881
-      },
-      transcoding: {
-        enabled: true,
-        threads: 1,
-        resolutions: {
-          '240p': false,
-          '360p': true,
-          '480p': true,
-          '720p': false,
-          '1080p': false
-        }
-      },
-      import: {
-        videos: {
-          http: {
-            enabled: false
-          }
-        }
-      }
-    }
-    await updateCustomConfig(server.url, server.accessToken, newCustomConfig)
 
     const res = await makeHTMLRequest(server.url, '/videos/trending')
 

server/tests/utils/server/config.ts

@@ -44,6 +44,69 @@ function updateCustomConfig (url: string, token: string, newCustomConfig: Custom
   })
 }
 
+function updateCustomSubConfig (url: string, token: string, newConfig: any) {
+  const updateParams: CustomConfig = {
+    instance: {
+      name: 'PeerTube updated',
+      shortDescription: 'my short description',
+      description: 'my super description',
+      terms: 'my super terms',
+      defaultClientRoute: '/videos/recently-added',
+      defaultNSFWPolicy: 'blur',
+      customizations: {
+        javascript: 'alert("coucou")',
+        css: 'body { background-color: red; }'
+      }
+    },
+    services: {
+      twitter: {
+        username: '@MySuperUsername',
+        whitelisted: true
+      }
+    },
+    cache: {
+      previews: {
+        size: 2
+      },
+      captions: {
+        size: 3
+      }
+    },
+    signup: {
+      enabled: false,
+      limit: 5
+    },
+    admin: {
+      email: 'superadmin1@example.com'
+    },
+    user: {
+      videoQuota: 5242881
+    },
+    transcoding: {
+      enabled: true,
+      threads: 1,
+      resolutions: {
+        '240p': false,
+        '360p': true,
+        '480p': true,
+        '720p': false,
+        '1080p': false
+      }
+    },
+    import: {
+      videos: {
+        http: {
+          enabled: false
+        }
+      }
+    }
+  }
+
+  Object.assign(updateParams, newConfig)
+
+  return updateCustomConfig(url, token, updateParams)
+}
+
 function deleteCustomConfig (url: string, token: string, statusCodeExpected = 200) {
   const path = '/api/v1/config/custom'
 
@@ -62,5 +125,6 @@ export {
   getCustomConfig,
   updateCustomConfig,
   getAbout,
-  deleteCustomConfig
+  deleteCustomConfig,
+  updateCustomSubConfig
 }

server/tests/utils/videos/video-imports.ts

@@ -0,0 +1,37 @@
+import { VideoImportCreate } from '../../../../shared/models/videos'
+import { makeGetRequest, makePostBodyRequest } from '..'
+
+function getYoutubeVideoUrl () {
+  return 'https://youtu.be/msX3jv1XdvM'
+}
+
+function importVideo (url: string, token: string, attributes: VideoImportCreate) {
+  const path = '/api/v1/videos/imports'
+
+  return makePostBodyRequest({
+    url,
+    path,
+    token,
+    fields: attributes,
+    statusCodeExpected: 200
+  })
+}
+
+function getMyVideoImports (url: string, token: string) {
+  const path = '/api/v1/users/me/videos/imports'
+
+  return makeGetRequest({
+    url,
+    path,
+    token,
+    statusCodeExpected: 200
+  })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  getYoutubeVideoUrl,
+  importVideo,
+  getMyVideoImports
+}

shared/models/videos/index.ts

@@ -16,7 +16,6 @@ export * from './video.model'
 export * from './video-state.enum'
 export * from './video-caption-update.model'
 export * from './video-import-create.model'
-export * from './video-import-update.model'
 export * from './video-import-state.enum'
 export * from './video-import.model'
 export { VideoConstant } from './video-constant.model'

shared/models/videos/video-import-update.model.ts

@@ -1,5 +0,0 @@
-import { VideoUpdate } from './video-update.model'
-
-export interface VideoImportUpdate extends VideoUpdate {
-  targetUrl: string
-}