--- /dev/null
+image: chocobozzz/peertube-ci:10
+
+stages:
+ - build-and-lint
+ - test
+ - nightly
+
+before_script:
+ - 'sed -i -z "s/database:\n hostname: ''localhost''/database:\n hostname: ''postgres''/" config/test.yaml'
+ - 'sed -i -z "s/redis:\n hostname: ''localhost''/redis:\n hostname: ''redis''/" config/test.yaml'
+ - if [[ $CI_JOB_STAGE == "test" ]]; then psql -c "create user peertube with password 'peertube';"; fi
+ - NOCLIENT=1 yarn install --pure-lockfile --cache-folder .yarn-cache
+
+cache:
+ key: yarn
+ paths:
+ - .yarn-cache
+ - cached-fixtures
+
+###
+## Jobs templates
+#
+#.build-and-lint: &build-and-lint
+# stage: build-and-lint
+#
+#.tests: &tests
+# stage: test
+# dependencies:
+# - build-server
+# services:
+# - name: postgres:9.6
+# alias: postgres
+# - name: redis:latest
+# alias: redis
+# variables:
+# PGHOST: postgres
+# PGUSER: postgres
+# REDIS_HOST: redis
+# artifacts:
+# expire_in: 1 day
+# paths:
+# - test*/logs
+# when: always
+#
+####
+### Build and lint
+##
+#build-server:
+# <<: *build-and-lint
+# artifacts:
+# expire_in: 5h
+# paths:
+# - dist/
+# script:
+# - npm run build:server
+#
+#lint:
+# <<: *build-and-lint
+# script:
+# - yarn install --pure-lockfile --cache-folder .yarn-cache
+# - npm run ci -- "lint"
+#
+####
+### Tests
+#
+#test-misc:
+# <<: *tests
+# script:
+# - yarn install --pure-lockfile --cache-folder .yarn-cache
+# - npm run ci -- "misc"
+#
+#test-cli:
+# <<: *tests
+# retry:
+# max: 1
+# script:
+# - npm run ci -- "cli"
+#
+#api:
+# <<: *tests
+# parallel: 4
+# retry:
+# max: 1
+# script:
+# - NODE_PENDING_JOB_WAIT=1000 npm run ci -- api-$CI_NODE_INDEX
+
+build-nightly:
+ stage: nightly
+ only:
+ - schedules
+ script:
+ - yarn install --pure-lockfile --cache-folder .yarn-cache
+ - npm run nightly
+ - mkdir "${HOME}/.ssh"
+ - chmod 700 "${HOME}/.ssh"
+ - if [ ! -z ${DEPLOYEMENT_KNOWN_HOSTS+x} ]; then echo -e "${DEPLOYEMENT_KNOWN_HOSTS}" > ${HOME}/.ssh/known_hosts; fi
+ - eval `ssh-agent -s`
+ - if [ ! -z ${DEPLOYEMENT_KEY+x} ]; then ssh-add <(echo "${DEPLOYEMENT_KEY}"); fi
+ - if [ ! -z ${DEPLOYEMENT_KEY+x} ]; then scp ./peertube-nightly-* ${DEPLOYEMENT_USER}@${DEPLOYEMENT_HOST}:../../web/nightly; fi
+
- env: TEST_SUITE=lint
script:
- - NODE_PENDING_JOB_WAIT=2000 travis_retry npm run travis -- "$TEST_SUITE"
+ - NODE_PENDING_JOB_WAIT=2000 travis_retry npm run ci -- "$TEST_SUITE"
after_failure:
- cat test1/logs/peertube.log
<br />
- <a href="https://travis-ci.org/Chocobozzz/PeerTube">
- <img src="https://travis-ci.org/Chocobozzz/PeerTube.svg?branch=develop" alt="Build Status" />
+ <a href="https://framagit.org/framasoft/peertube/PeerTube/commits/develop">
+ <img alt="pipeline status" src="https://framagit.org/framasoft/peertube/PeerTube/badges/develop/pipeline.svg" />
</a>
<a href="https://david-dm.org/Chocobozzz/PeerTube">
hostname: 'localhost'
port: 5432
+redis:
+ hostname: 'localhost'
+
smtp:
hostname: null
port: 1025
"postinstall": "test -n \"$NOCLIENT\" || (cd client && yarn install --pure-lockfile)",
"tsc": "tsc",
"commander": "commander",
- "lint": "npm run travis -- lint",
+ "lint": "npm run ci -- lint",
"ng": "ng",
"nodemon": "nodemon",
"ts-node": "ts-node",
"tslint": "tslint",
"concurrently": "concurrently",
+ "mocha-parallel-tests": "mocha-parallel-tests",
"sasslint": "sass-lint --verbose --no-exit",
"sasslint:fix": "sass-lint-auto-fix -c .sass-lint.yml --verbose",
"mocha": "mocha",
- "travis": "scripty",
+ "ci": "scripty",
"release": "scripty",
+ "nightly": "scripty",
"client-report": "scripty"
},
"husky": {
]
},
"resolutions": {
- "@types/bluebird": "3.5.21"
+ "@types/bluebird": "3.5.27"
},
"dependencies": {
"apicache": "^1.4.0",
"maildev": "^1.0.0-rc3",
"marked-man": "^0.6.0",
"mocha": "^6.0.0",
- "mocha-parallel-tests": "^2.1.0",
+ "mocha-parallel-tests": "^2.2.1",
"nodemon": "^1.18.6",
"sass-lint": "^1.12.1",
"source-map-support": "^0.5.0",
--- /dev/null
+#!/bin/sh
+
+set -eu
+
+if [ $# -eq 0 ]; then
+ echo "Need test suite argument."
+ exit -1
+fi
+
+killall -q peertube || true
+
+if [ "$1" = "misc" ]; then
+ npm run build -- --light-fr
+ mocha --timeout 5000 --exit --require ts-node/register --bail server/tests/client.ts \
+ server/tests/feeds/index.ts \
+ server/tests/misc-endpoints.ts \
+ server/tests/helpers/index.ts \
+ server/tests/plugins/index.ts
+elif [ "$1" = "cli" ]; then
+ npm run build:server
+ CC=gcc-4.9 CXX=g++-4.9 npm run setup:cli
+ mocha --timeout 5000 --exit --require ts-node/register --bail server/tests/cli/index.ts
+elif [ "$1" = "api-1" ]; then
+ npm run build:server
+ sh ./server/tests/api/ci-1.sh 2
+elif [ "$1" = "api-2" ]; then
+ npm run build:server
+ sh ./server/tests/api/ci-2.sh 2
+elif [ "$1" = "api-3" ]; then
+ npm run build:server
+ sh ./server/tests/api/ci-3.sh 2
+elif [ "$1" = "api-4" ]; then
+ npm run build:server
+ sh ./server/tests/api/ci-4.sh 2
+elif [ "$1" = "lint" ]; then
+ npm run tslint -- --project ./tsconfig.json -c ./tslint.json server.ts "server/**/*.ts" "shared/**/*.ts"
+
+ ( cd client
+ npm run lint
+ )
+fi
recreateDB () {
dbname="peertube_test$1"
- dropdb --if-exists "$dbname"
+ dropdb --if-exists "$dbname" 2>&1
createdb -O peertube "$dbname"
psql -c "CREATE EXTENSION pg_trgm;" "$dbname" &
dropRedis () {
port=$((9000+$1))
+ host="localhost"
- redis-cli KEYS "bull-localhost:$port*" | grep -v empty | xargs --no-run-if-empty redis-cli DEL
- redis-cli KEYS "redis-localhost:$port*" | grep -v empty | xargs --no-run-if-empty redis-cli DEL
- redis-cli KEYS "*redis-localhost:$port-" | grep -v empty | xargs --no-run-if-empty redis-cli DEL
+ if [ ! -z ${GITLAB_CI+x} ]; then
+ host="redis"
+ fi
+
+ redis-cli -h "$host" KEYS "bull-localhost:$port*" | grep -v empty | xargs --no-run-if-empty redis-cli -h "$host" DEL
+ redis-cli -h "$host" KEYS "redis-localhost:$port*" | grep -v empty | xargs --no-run-if-empty redis-cli -h "$host" DEL
+ redis-cli -h "$host" KEYS "*redis-localhost:$port-" | grep -v empty | xargs --no-run-if-empty redis-cli -h "$host" DEL
}
seq=$(seq 1 6)
--- /dev/null
+#!/bin/bash
+
+set -eu
+
+shutdown() {
+ # Get our process group id
+ # shellcheck disable=SC2009
+ PGID=$(ps -o pgid= $$ | grep -o "[0-9]*")
+
+ # Kill it in a new new process group
+ setsid kill -- -"$PGID"
+ exit 0
+}
+
+trap "shutdown" SIGINT SIGTERM
+
+today=$(date '+%F')
+directory_name="peertube-nightly-$today"
+tar_name="peertube-nightly-$today.tar.xz"
+
+npm run build
+
+# Creating the archives
+(
+ # local variables
+ directories_to_archive=("$directory_name/CREDITS.md" "$directory_name/FAQ.md" \
+ "$directory_name/LICENSE" "$directory_name/README.md" \
+ "$directory_name/client/dist/" "$directory_name/client/yarn.lock" \
+ "$directory_name/client/package.json" "$directory_name/config" \
+ "$directory_name/dist" "$directory_name/package.json" \
+ "$directory_name/scripts" "$directory_name/support" \
+ "$directory_name/tsconfig.json" "$directory_name/yarn.lock")
+
+ # temporary setup
+ cd ..
+ ln -s "PeerTube" "$directory_name"
+
+ XZ_OPT=-e9 tar cfJ "PeerTube/$tar_name" "${directories_to_archive[@]}"
+
+ # temporary setup destruction
+ rm "$directory_name"
+)
npm run build:server
npm run setup:cli
-npm run travis -- lint
+npm run ci -- lint
mocha --exit --require ts-node/register/type-check --bail server/tests/index.ts
+++ /dev/null
-#!/bin/sh
-
-set -eu
-
-if [ $# -eq 0 ]; then
- echo "Need test suite argument."
- exit -1
-fi
-
-killall -q peertube || true
-
-if [ "$1" = "misc" ]; then
- npm run build -- --light-fr
- mocha --timeout 5000 --exit --require ts-node/register --bail server/tests/client.ts \
- server/tests/feeds/index.ts \
- server/tests/misc-endpoints.ts \
- server/tests/helpers/index.ts \
- server/tests/plugins/index.ts
-elif [ "$1" = "cli" ]; then
- npm run build:server
- CC=gcc-4.9 CXX=g++-4.9 npm run setup:cli
- mocha --timeout 5000 --exit --require ts-node/register --bail server/tests/cli/index.ts
-elif [ "$1" = "api-1" ]; then
- npm run build:server
- sh ./server/tests/api/travis-1.sh 2
-elif [ "$1" = "api-2" ]; then
- npm run build:server
- sh ./server/tests/api/travis-2.sh 2
-elif [ "$1" = "api-3" ]; then
- npm run build:server
- sh ./server/tests/api/travis-3.sh 2
-elif [ "$1" = "api-4" ]; then
- npm run build:server
- sh ./server/tests/api/travis-4.sh 2
-elif [ "$1" = "lint" ]; then
- npm run tslint -- --project ./tsconfig.json -c ./tslint.json server.ts "server/**/*.ts" "shared/**/*.ts"
-
- ( cd client
- npm run lint
- )
-fi
// We send the video abuse to the origin server
if (videoInstance.isOwned() === false) {
- await sendVideoAbuse(reporterAccount.Actor, videoAbuseInstance, videoInstance)
+ await sendVideoAbuse(reporterAccount.Actor, videoAbuseInstance, videoInstance, t)
}
- Notifier.Instance.notifyOnNewVideoAbuse(videoAbuseInstance)
-
auditLogger.create(reporterAccount.Actor.getIdentifier(), new VideoAbuseAuditView(videoAbuseInstance.toFormattedJSON()))
return videoAbuseInstance
})
+ Notifier.Instance.notifyOnNewVideoAbuse(videoAbuse)
+
logger.info('Abuse report for video %s created.', videoInstance.name)
return res.json({ videoAbuse: videoAbuse.toFormattedJSON() }).end()
import * as Bluebird from 'bluebird'
import { Model } from 'sequelize-typescript'
import { logger } from './logger'
+import { Transaction } from 'sequelize'
function retryTransactionWrapper <T, A, B, C> (
functionToRetry: (arg1: A, arg2: B, arg3: C) => Promise<T> | Bluebird<T>,
})
}
+function afterCommitIfTransaction (t: Transaction, fn: Function) {
+ if (t) return t.afterCommit(() => fn())
+
+ return fn()
+}
+
// ---------------------------------------------------------------------------
export {
resetSequelizeInstance,
retryTransactionWrapper,
transactionRetryer,
- updateInstanceWithAnother
+ updateInstanceWithAnother,
+ afterCommitIfTransaction
}
const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: flag.object })
- return sequelizeTypescript.transaction(async t => {
+ const videoAbuse = await sequelizeTypescript.transaction(async t => {
const videoAbuseData = {
reporterAccountId: account.id,
reason: flag.content,
const videoAbuseInstance = await VideoAbuseModel.create(videoAbuseData, { transaction: t })
videoAbuseInstance.Video = video
- Notifier.Instance.notifyOnNewVideoAbuse(videoAbuseInstance)
-
logger.info('Remote abuse for video uuid %s created', flag.object)
+
+ return videoAbuseInstance
})
+
+ Notifier.Instance.notifyOnNewVideoAbuse(videoAbuse)
}
import { VideoPlaylistModel } from '../../../models/video/video-playlist'
import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
import { getServerActor } from '../../../helpers/utils'
+import * as Bluebird from 'bluebird'
async function sendCreateVideo (video: VideoModel, t: Transaction) {
if (video.privacy === VideoPrivacy.PRIVATE) return undefined
// This was a reply, send it to the parent actors
const actorsException = [ byActor ]
- await broadcastToActors(createActivity, byActor, parentsCommentActors, actorsException)
+ await broadcastToActors(createActivity, byActor, parentsCommentActors, t, actorsException)
// Broadcast to our followers
await broadcastToFollowers(createActivity, byActor, [ byActor ], t)
if (isOrigin) return broadcastToFollowers(createActivity, byActor, actorsInvolvedInComment, t, actorsException)
// Send to origin
- return unicastTo(createActivity, byActor, comment.Video.VideoChannel.Account.Actor.sharedInboxUrl)
+ t.afterCommit(() => unicastTo(createActivity, byActor, comment.Video.VideoChannel.Account.Actor.sharedInboxUrl))
}
function buildCreateActivity (url: string, byActor: ActorModel, object: any, audience?: ActivityAudience): ActivityCreate {
// This was a reply, send it to the parent actors
const actorsException = [ byActor ]
- await broadcastToActors(activity, byActor, threadParentComments.map(c => c.Account.Actor), actorsException)
+ await broadcastToActors(activity, byActor, threadParentComments.map(c => c.Account.Actor), t, actorsException)
// Broadcast to our followers
await broadcastToFollowers(activity, byActor, [ byActor ], t)
if (isVideoOrigin) return broadcastToFollowers(activity, byActor, actorsInvolvedInComment, t, actorsException)
// Send to origin
- return unicastTo(activity, byActor, videoComment.Video.VideoChannel.Account.Actor.sharedInboxUrl)
+ t.afterCommit(() => unicastTo(activity, byActor, videoComment.Video.VideoChannel.Account.Actor.sharedInboxUrl))
}
async function sendDeleteVideoPlaylist (videoPlaylist: VideoPlaylistModel, t: Transaction) {
import { logger } from '../../../helpers/logger'
import { ActivityAudience, ActivityFlag } from '../../../../shared/models/activitypub'
import { audiencify, getAudience } from '../audience'
+import { Transaction } from 'sequelize'
-async function sendVideoAbuse (byActor: ActorModel, videoAbuse: VideoAbuseModel, video: VideoModel) {
+async function sendVideoAbuse (byActor: ActorModel, videoAbuse: VideoAbuseModel, video: VideoModel, t: Transaction) {
if (!video.VideoChannel.Account.Actor.serverId) return // Local user
const url = getVideoAbuseActivityPubUrl(videoAbuse)
const audience = { to: [ video.VideoChannel.Account.Actor.url ], cc: [] }
const flagActivity = buildFlagActivity(url, byActor, videoAbuse, audience)
- return unicastTo(flagActivity, byActor, video.VideoChannel.Account.Actor.sharedInboxUrl)
+ t.afterCommit(() => unicastTo(flagActivity, byActor, video.VideoChannel.Account.Actor.sharedInboxUrl))
}
function buildFlagActivity (url: string, byActor: ActorModel, videoAbuse: VideoAbuseModel, audience: ActivityAudience): ActivityFlag {
import { getActorFollowActivityPubUrl } from '../url'
import { unicastTo } from './utils'
import { logger } from '../../../helpers/logger'
+import { Transaction } from 'sequelize'
-function sendFollow (actorFollow: ActorFollowModel) {
+function sendFollow (actorFollow: ActorFollowModel, t: Transaction) {
const me = actorFollow.ActorFollower
const following = actorFollow.ActorFollowing
const url = getActorFollowActivityPubUrl(me, following)
const data = buildFollowActivity(url, me, following)
- return unicastTo(data, me, following.inboxUrl)
+ t.afterCommit(() => unicastTo(data, me, following.inboxUrl))
}
function buildFollowActivity (url: string, byActor: ActorModel, targetActor: ActorModel): ActivityFollow {
const followActivity = buildFollowActivity(followUrl, me, following)
const undoActivity = undoActivityData(undoUrl, me, followActivity)
- return unicastTo(undoActivity, me, following.inboxUrl)
+ t.afterCommit(() => unicastTo(undoActivity, me, following.inboxUrl))
}
async function sendUndoAnnounce (byActor: ActorModel, videoShare: VideoShareModel, video: VideoModel, t: Transaction) {
const url = getUpdateActivityPubUrl(video.url, video.updatedAt.toISOString())
// Needed to build the AP object
- if (!video.VideoCaptions) video.VideoCaptions = await video.$get('VideoCaptions') as VideoCaptionModel[]
+ if (!video.VideoCaptions) {
+ video.VideoCaptions = await video.$get('VideoCaptions', { transaction: t }) as VideoCaptionModel[]
+ }
const videoObject = video.toActivityPubObject()
const audience = getAudience(byActor, video.privacy === VideoPrivacy.PUBLIC)
import { VideoModel } from '../../../models/video/video'
import { getActorsInvolvedInVideo, getAudienceFromFollowersOf, getRemoteVideoAudience } from '../audience'
import { getServerActor } from '../../../helpers/utils'
+import { afterCommitIfTransaction } from '../../../helpers/database-utils'
async function sendVideoRelatedActivity (activityBuilder: (audience: ActivityAudience) => Activity, options: {
byActor: ActorModel,
const audience = getRemoteVideoAudience(options.video, actorsInvolvedInVideo)
const activity = activityBuilder(audience)
- return unicastTo(activity, options.byActor, options.video.VideoChannel.Account.Actor.sharedInboxUrl)
+ return afterCommitIfTransaction(options.transaction, () => {
+ return unicastTo(activity, options.byActor, options.video.VideoChannel.Account.Actor.sharedInboxUrl)
+ })
}
// Send to followers
const activity = activityBuilder(audience)
const actorsException = [ options.byActor ]
+
return broadcastToFollowers(activity, options.byActor, actorsInvolvedInVideo, options.transaction, actorsException)
}
uris,
body: activity
}
- return JobQueue.Instance.createJob({ type: 'activitypub-http-broadcast', payload })
+ return afterCommitIfTransaction(t, () => JobQueue.Instance.createJob({ type: 'activitypub-http-broadcast', payload }))
}
async function broadcastToFollowers (
actorsException: ActorModel[] = []
) {
const uris = await computeFollowerUris(toFollowersOf, actorsException, t)
- return broadcastTo(uris, data, byActor)
+
+ return afterCommitIfTransaction(t, () => broadcastTo(uris, data, byActor))
}
async function broadcastToActors (
data: any,
byActor: ActorModel,
toActors: ActorModel[],
+ t?: Transaction,
actorsException: ActorModel[] = []
) {
const uris = await computeUris(toActors, actorsException)
- return broadcastTo(uris, data, byActor)
+ return afterCommitIfTransaction(t, () => broadcastTo(uris, data, byActor))
}
-async function broadcastTo (uris: string[], data: any, byActor: ActorModel) {
+function broadcastTo (uris: string[], data: any, byActor: ActorModel) {
if (uris.length === 0) return undefined
logger.debug('Creating broadcast job.', { uris })
return JobQueue.Instance.createJob({ type: 'activitypub-http-broadcast', payload })
}
-async function unicastTo (data: any, byActor: ActorModel, toActorUrl: string) {
+function unicastTo (data: any, byActor: ActorModel, toActorUrl: string) {
logger.debug('Creating unicast job.', { uri: toActorUrl })
const payload = {
body: data
}
- return JobQueue.Instance.createJob({ type: 'activitypub-http-unicast', payload })
+ JobQueue.Instance.createJob({ type: 'activitypub-http-unicast', payload })
}
// ---------------------------------------------------------------------------
actorFollow.ActorFollower = fromActor
// Send a notification to remote server if our follow is not already accepted
- if (actorFollow.state !== 'accepted') await sendFollow(actorFollow)
+ if (actorFollow.state !== 'accepted') sendFollow(actorFollow, t)
return actorFollow
})
})
after(async function () {
- this.timeout(10000)
+ this.timeout(20000)
await cleanupTests(servers)
--- /dev/null
+#!/usr/bin/env sh
+
+set -eu
+
+checkParamFiles=$(find server/tests/api/check-params -type f | grep -v index.ts | xargs echo)
+notificationsFiles=$(find server/tests/api/notifications -type f | grep -v index.ts | xargs echo)
+searchFiles=$(find server/tests/api/search -type f | grep -v index.ts | xargs echo)
+
+MOCHA_PARALLEL=true npm run mocha --timeout 30000 --exit --require ts-node/register --bail \
+ $notificationsFiles $searchFiles $checkParamFiles
--- /dev/null
+#!/usr/bin/env sh
+
+set -eu
+
+serverFiles=$(find server/tests/api/server -type f | grep -v index.ts | xargs echo)
+usersFiles=$(find server/tests/api/users -type f | grep -v index.ts | xargs echo)
+
+MOCHA_PARALLEL=true npm run mocha-parallel-tests -- --max-parallel $1 --timeout 30000 --exit --require ts-node/register --bail \
+ $serverFiles $usersFiles
--- /dev/null
+#!/usr/bin/env sh
+
+set -eu
+
+videosFiles=$(find server/tests/api/videos -type f | grep -v index.ts | xargs echo)
+
+MOCHA_PARALLEL=true npm run mocha --timeout 30000 --exit --require ts-node/register --bail \
+ $videosFiles
--- /dev/null
+#!/usr/bin/env sh
+
+set -eu
+
+redundancyFiles=$(find server/tests/api/redundancy -type f | grep -v index.ts | xargs echo)
+activitypubFiles=$(find server/tests/api/activitypub -type f | grep -v index.ts | xargs echo)
+
+MOCHA_PARALLEL=true npm run mocha-parallel-tests -- --max-parallel $1 --timeout 30000 --exit --require ts-node/register --bail \
+ $redundancyFiles $activitypubFiles
it('Should not send a notification before the video is published', async function () {
this.timeout(20000)
- let updateAt = new Date(new Date().getTime() + 100000)
+ let updateAt = new Date(new Date().getTime() + 1000000)
const data = {
privacy: VideoPrivacy.PRIVATE,
it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () {
this.timeout(20000)
- let updateAt = new Date(new Date().getTime() + 100000)
+ let updateAt = new Date(new Date().getTime() + 1000000)
const name = 'video with auto-blacklist and future schedule ' + uuidv4()
let emailPort: number
before(async function () {
- this.timeout(30000)
+ this.timeout(50000)
emailPort = await MockSmtpServer.Instance.collectEmails(emails)
})
it('Should remove followers that are often down', async function () {
- this.timeout(60000)
+ this.timeout(240000)
// Server 2 and 3 follow server 1
await follow(servers[1].url, [ servers[0].url ], servers[1].accessToken)
import { flushAndRunMultipleServers } from '../../../../shared/extra-utils/server/servers'
import { uploadVideo } from '../../../../shared/extra-utils/videos/videos'
import { dateIsValid } from '../../../../shared/extra-utils/miscs/miscs'
+import { Job } from '../../../../shared/models/server'
const expect = chai.expect
if (job.type === 'videos-views') job = res.body.data[1]
expect(job.state).to.equal('completed')
- expect(job.type).to.equal('activitypub-follow')
+ expect(job.type.startsWith('activitypub-')).to.be.true
expect(dateIsValid(job.createdAt)).to.be.true
expect(dateIsValid(job.processedOn)).to.be.true
expect(dateIsValid(job.finishedOn)).to.be.true
+++ /dev/null
-#!/usr/bin/env sh
-
-set -eu
-
-checkParamFiles=$(find server/tests/api/check-params -type f | grep -v index.ts | xargs echo)
-notificationsFiles=$(find server/tests/api/notifications -type f | grep -v index.ts | xargs echo)
-searchFiles=$(find server/tests/api/search -type f | grep -v index.ts | xargs echo)
-
-MOCHA_PARALLEL=true mocha --timeout 5000 --exit --require ts-node/register --bail \
- $notificationsFiles $searchFiles $checkParamFiles
+++ /dev/null
-#!/usr/bin/env sh
-
-set -eu
-
-serverFiles=$(find server/tests/api/server -type f | grep -v index.ts | xargs echo)
-usersFiles=$(find server/tests/api/users -type f | grep -v index.ts | xargs echo)
-
-MOCHA_PARALLEL=true mocha --timeout 5000 --exit --require ts-node/register --bail \
- $serverFiles $usersFiles
+++ /dev/null
-#!/usr/bin/env sh
-
-set -eu
-
-videosFiles=$(find server/tests/api/videos -type f | grep -v index.ts | xargs echo)
-
-MOCHA_PARALLEL=true mocha --timeout 5000 --exit --require ts-node/register --bail \
- $videosFiles
+++ /dev/null
-#!/usr/bin/env sh
-
-set -eu
-
-redundancyFiles=$(find server/tests/api/redundancy -type f | grep -v index.ts | xargs echo)
-activitypubFiles=$(find server/tests/api/activitypub -type f | grep -v index.ts | xargs echo)
-
-MOCHA_PARALLEL=true mocha-parallel-tests --max-parallel $1 --timeout 5000 --exit --require ts-node/register --bail \
- $redundancyFiles $activitypubFiles
})
it('Should wait some seconds and have the video in public privacy', async function () {
- this.timeout(20000)
+ this.timeout(50000)
await wait(15000)
await waitJobs(servers)
/* tslint:disable:no-unused-expression */
import * as chai from 'chai'
-import { basename, isAbsolute, join, resolve } from 'path'
+import { basename, dirname, isAbsolute, join, resolve } from 'path'
import * as request from 'supertest'
import * as WebTorrent from 'webtorrent'
-import { pathExists, readFile } from 'fs-extra'
+import { ensureDir, pathExists, readFile } from 'fs-extra'
import * as ffmpeg from 'fluent-ffmpeg'
const expect = chai.expect
expect(data.length).to.be.below(maxLength)
}
-function buildAbsoluteFixturePath (path: string, customTravisPath = false) {
+function buildAbsoluteFixturePath (path: string, customCIPath = false) {
if (isAbsolute(path)) {
return path
}
- if (customTravisPath && process.env.TRAVIS) return join(process.env.HOME, 'fixtures', path)
+ if (customCIPath && process.env.GITLAB_CI) return join(root(), 'cached-fixtures', path)
return join(root(), 'server', 'tests', 'fixtures', path)
}
async function generateHighBitrateVideo () {
const tempFixturePath = buildAbsoluteFixturePath('video_high_bitrate_1080p.mp4', true)
+ await ensureDir(dirname(tempFixturePath))
+
const exists = await pathExists(tempFixturePath)
if (!exists) {
import { QueryTypes, Sequelize } from 'sequelize'
import { ServerInfo } from '../server/servers'
-import { PluginType } from '../../models/plugins/plugin.type'
let sequelizes: { [ id: number ]: Sequelize } = {}
const dbname = 'peertube_test' + internalServerNumber
const username = 'peertube'
const password = 'peertube'
- const host = 'localhost'
+ const host = process.env.GITLAB_CI ? 'postgres' : 'localhost'
const port = 5432
const seq = new Sequelize(dbname, username, password, {
import { Job, JobState } from '../../models'
import { wait } from '../miscs/miscs'
import { ServerInfo } from './servers'
+import { inspect } from 'util'
function getJobsList (url: string, accessToken: string, state: JobState) {
const path = '/api/v1/jobs/' + state
.then(res => res.body.data)
.then((jobs: Job[]) => jobs.filter(j => j.type !== 'videos-views'))
.then(jobs => {
- if (jobs.length !== 0) pendingRequests = true
+ if (jobs.length !== 0) {
+ pendingRequests = true
+ }
})
tasks.push(p)
}
return new Promise<void>((res, rej) => {
const suffix = serverNumber ? ` -- ${serverNumber}` : ''
- return exec('npm run clean:server:test' + suffix, err => {
- if (err) return rej(err)
+ return exec('npm run clean:server:test' + suffix, (err, _stdout, stderr) => {
+ if (err || stderr) return rej(err || new Error(stderr))
return res()
})
* `NODE_APP_INSTANCE=6 NODE_ENV=test npm run start` and check migrations does not fail
* Run `rm -r node_modules && rm -r client/node_modules && yarn install --pure-lockfile && npm run build` to see if all the supported languages compile correctly
* Update https://peertube2.cpy.re and check it works correctly
- * Check Travis tests are green
+ * Check CI tests are green
* Run E2E tests: `BROWSERSTACK_USER=my_user BROWSERSTACK_KEY=my_key npm run e2e`
* Release: `GITHUB_TOKEN=my_token npm run release -- 1.x.x`
* Create a dedicated branch: `git checkout -b release/1.x.x && git push origin release/1.x.x`
dependencies:
"@types/node" "*"
-"@types/bluebird@*", "@types/bluebird@3.5.21":
+"@types/bluebird@*", "@types/bluebird@3.5.27":
+ version "3.5.27"
+ resolved "https://registry.yarnpkg.com/@types/bluebird/-/bluebird-3.5.27.tgz#61eb4d75dc6bfbce51cf49ee9bbebe941b2cb5d0"
+ integrity sha512-6BmYWSBea18+tSjjSC3QIyV93ZKAeNWGM7R6aYt1ryTZXrlHF+QLV0G2yV0viEGVyRkyQsWfMoJ0k/YghBX5sQ==
+
+"@types/bluebird@3.5.21":
version "3.5.21"
resolved "https://registry.yarnpkg.com/@types/bluebird/-/bluebird-3.5.21.tgz#567615589cc913e84a28ecf9edb031732bdf2634"
integrity sha512-6UNEwyw+6SGMC/WMI0ld0PS4st7Qq51qgguFrFizOSpGvZiqe9iswztFSdZvwJBEhLOy2JaxNE6VC7yMAlbfyQ==
dependencies:
minimist "0.0.8"
-mocha-parallel-tests@^2.1.0:
+mocha-parallel-tests@^2.2.1:
version "2.2.1"
resolved "https://registry.yarnpkg.com/mocha-parallel-tests/-/mocha-parallel-tests-2.2.1.tgz#616b316c9f20c956a6ce18cd38d45e7db3045b99"
integrity sha512-9t0NtQ2V/KrNKaUj08RVZp0dqJxeRMTGvC7JA5Daw/LA8GOP+4P7NxRgU0e2sM0JRWYxSakXtpE+MEVGX1ifuw==
projects / oweals / peertube.git / commitdiff