"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const lodash_1 = require("lodash");
const core_utils_1 = require("../../../../shared/core-utils");
const server_commands_1 = require("../../../../shared/server-commands");
describe('Test config API validators', function () {
    const path = '/api/v1/config/custom';
    let server;
    let userAccessToken;
    const updateParams = {
        instance: {
            name: 'PeerTube updated',
            shortDescription: 'my short description',
            description: 'my super description',
            terms: 'my super terms',
            codeOfConduct: 'my super coc',
            creationReason: 'my super reason',
            moderationInformation: 'my super moderation information',
            administrator: 'Kuja',
            maintenanceLifetime: 'forever',
            businessModel: 'my super business model',
            hardwareInformation: '2vCore 3GB RAM',
            languages: ['en', 'es'],
            categories: [1, 2],
            isNSFW: true,
            defaultNSFWPolicy: 'blur',
            defaultClientRoute: '/videos/recently-added',
            customizations: {
                javascript: 'alert("coucou")',
                css: 'body { background-color: red; }'
            }
        },
        theme: {
            default: 'default'
        },
        services: {
            twitter: {
                username: '@MySuperUsername',
                whitelisted: true
            }
        },
        client: {
            videos: {
                miniature: {
                    preferAuthorDisplayName: false
                }
            },
            menu: {
                login: {
                    redirectOnSingleExternalAuth: false
                }
            }
        },
        cache: {
            previews: {
                size: 2
            },
            captions: {
                size: 3
            },
            torrents: {
                size: 4
            }
        },
        signup: {
            enabled: false,
            limit: 5,
            requiresEmailVerification: false,
            minimumAge: 16
        },
        admin: {
            email: 'superadmin1@example.com'
        },
        contactForm: {
            enabled: false
        },
        user: {
            videoQuota: 5242881,
            videoQuotaDaily: 318742
        },
        videoChannels: {
            maxPerUser: 20
        },
        transcoding: {
            enabled: true,
            allowAdditionalExtensions: true,
            allowAudioFiles: true,
            concurrency: 1,
            threads: 1,
            profile: 'vod_profile',
            resolutions: {
                '0p': false,
                '144p': false,
                '240p': false,
                '360p': true,
                '480p': true,
                '720p': false,
                '1080p': false,
                '1440p': false,
                '2160p': false
            },
            alwaysTranscodeOriginalResolution: false,
            webtorrent: {
                enabled: true
            },
            hls: {
                enabled: false
            }
        },
        live: {
            enabled: true,
            allowReplay: false,
            latencySetting: {
                enabled: false
            },
            maxDuration: 30,
            maxInstanceLives: -1,
            maxUserLives: 50,
            transcoding: {
                enabled: true,
                threads: 4,
                profile: 'live_profile',
                resolutions: {
                    '144p': true,
                    '240p': true,
                    '360p': true,
                    '480p': true,
                    '720p': true,
                    '1080p': true,
                    '1440p': true,
                    '2160p': true
                },
                alwaysTranscodeOriginalResolution: false
            }
        },
        videoStudio: {
            enabled: true
        },
        import: {
            videos: {
                concurrency: 1,
                http: {
                    enabled: false
                },
                torrent: {
                    enabled: false
                }
            },
            videoChannelSynchronization: {
                enabled: false,
                maxPerUser: 10
            }
        },
        trending: {
            videos: {
                algorithms: {
                    enabled: ['hot', 'most-viewed', 'most-liked'],
                    default: 'most-viewed'
                }
            }
        },
        autoBlacklist: {
            videos: {
                ofUsers: {
                    enabled: false
                }
            }
        },
        followers: {
            instance: {
                enabled: false,
                manualApproval: true
            }
        },
        followings: {
            instance: {
                autoFollowBack: {
                    enabled: true
                },
                autoFollowIndex: {
                    enabled: true,
                    indexUrl: 'https://index.example.com'
                }
            }
        },
        broadcastMessage: {
            enabled: true,
            dismissable: true,
            message: 'super message',
            level: 'warning'
        },
        search: {
            remoteUri: {
                users: true,
                anonymous: true
            },
            searchIndex: {
                enabled: true,
                url: 'https://search.joinpeertube.org',
                disableLocalSearch: true,
                isDefaultSearch: true
            }
        }
    };
    before(function () {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            this.timeout(30000);
            server = yield (0, server_commands_1.createSingleServer)(1);
            yield (0, server_commands_1.setAccessTokensToServers)([server]);
            const user = {
                username: 'user1',
                password: 'password'
            };
            yield server.users.create({ username: user.username, password: user.password });
            userAccessToken = yield server.login.getAccessToken(user);
        });
    });
    describe('When getting the configuration', function () {
        it('Should fail without token', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makeGetRequest)({
                    url: server.url,
                    path,
                    expectedStatus: 401
                });
            });
        });
        it('Should fail if the user is not an administrator', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makeGetRequest)({
                    url: server.url,
                    path,
                    token: userAccessToken,
                    expectedStatus: 403
                });
            });
        });
    });
    describe('When updating the configuration', function () {
        it('Should fail without token', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: updateParams,
                    expectedStatus: 401
                });
            });
        });
        it('Should fail if the user is not an administrator', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: updateParams,
                    token: userAccessToken,
                    expectedStatus: 403
                });
            });
        });
        it('Should fail if it misses a key', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const newUpdateParams = Object.assign(Object.assign({}, updateParams), { admin: (0, core_utils_1.omit)(updateParams.admin, ['email']) });
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: newUpdateParams,
                    token: server.accessToken,
                    expectedStatus: 400
                });
            });
        });
        it('Should fail with a bad default NSFW policy', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const newUpdateParams = Object.assign(Object.assign({}, updateParams), { instance: {
                        defaultNSFWPolicy: 'hello'
                    } });
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: newUpdateParams,
                    token: server.accessToken,
                    expectedStatus: 400
                });
            });
        });
        it('Should fail if email disabled and signup requires email verification', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const newUpdateParams = Object.assign(Object.assign({}, updateParams), { signup: {
                        enabled: true,
                        limit: 5,
                        requiresEmailVerification: true
                    } });
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: newUpdateParams,
                    token: server.accessToken,
                    expectedStatus: 400
                });
            });
        });
        it('Should fail with a disabled webtorrent & hls transcoding', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const newUpdateParams = Object.assign(Object.assign({}, updateParams), { transcoding: {
                        hls: {
                            enabled: false
                        },
                        webtorrent: {
                            enabled: false
                        }
                    } });
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: newUpdateParams,
                    token: server.accessToken,
                    expectedStatus: 400
                });
            });
        });
        it('Should fail with a disabled http upload & enabled sync', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const newUpdateParams = (0, lodash_1.merge)({}, updateParams, {
                    import: {
                        videos: {
                            http: { enabled: false }
                        },
                        videoChannelSynchronization: { enabled: true }
                    }
                });
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: newUpdateParams,
                    token: server.accessToken,
                    expectedStatus: 400
                });
            });
        });
        it('Should succeed with the correct parameters', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makePutBodyRequest)({
                    url: server.url,
                    path,
                    fields: updateParams,
                    token: server.accessToken,
                    expectedStatus: 200
                });
            });
        });
    });
    describe('When deleting the configuration', function () {
        it('Should fail without token', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makeDeleteRequest)({
                    url: server.url,
                    path,
                    expectedStatus: 401
                });
            });
        });
        it('Should fail if the user is not an administrator', function () {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                yield (0, server_commands_1.makeDeleteRequest)({
                    url: server.url,
                    path,
                    token: userAccessToken,
                    expectedStatus: 403
                });
            });
        });
    });
    after(function () {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            yield (0, server_commands_1.cleanupTests)([server]);
        });
    });
});
//# sourceMappingURL=config.js.map