mirror of
https://github.com/Tzahi12345/YoutubeDL-Material.git
synced 2026-03-10 14:50:58 +03:00
ca5381fe0f
Added DB functionality to remove properties from records DB records in local DB can now be updated if nested
731 lines
33 KiB
JavaScript
731 lines
33 KiB
JavaScript
const assert = require('assert');
|
|
const low = require('lowdb')
|
|
const winston = require('winston');
|
|
const path = require('path');
|
|
|
|
|
|
const FileSync = require('lowdb/adapters/FileSync');
|
|
|
|
const adapter = new FileSync('./appdata/db.json');
|
|
const db = low(adapter)
|
|
|
|
const users_adapter = new FileSync('./appdata/users.json');
|
|
const users_db = low(users_adapter);
|
|
|
|
const defaultFormat = winston.format.printf(({ level, message, label, timestamp }) => {
|
|
return `${timestamp} ${level.toUpperCase()}: ${message}`;
|
|
});
|
|
|
|
let debugMode = process.env.YTDL_MODE === 'debug';
|
|
|
|
const logger = winston.createLogger({
|
|
level: 'info',
|
|
format: winston.format.combine(winston.format.timestamp(), defaultFormat),
|
|
defaultMeta: {},
|
|
transports: [
|
|
//
|
|
// - Write to all logs with level `info` and below to `combined.log`
|
|
// - Write all logs error (and below) to `error.log`.
|
|
//
|
|
new winston.transports.File({ filename: 'appdata/logs/error.log', level: 'error' }),
|
|
new winston.transports.File({ filename: 'appdata/logs/combined.log' }),
|
|
new winston.transports.Console({level: 'debug', name: 'console'})
|
|
]
|
|
});
|
|
|
|
var auth_api = require('../authentication/auth');
|
|
var db_api = require('../db');
|
|
const utils = require('../utils');
|
|
const subscriptions_api = require('../subscriptions');
|
|
const archive_api = require('../archive');
|
|
const fs = require('fs-extra');
|
|
const { uuid } = require('uuidv4');
|
|
const NodeID3 = require('node-id3');
|
|
|
|
db_api.initialize(db, users_db);
|
|
|
|
const sample_video_json = {
|
|
id: "Sample Video",
|
|
title: "Sample Video",
|
|
thumbnailURL: "https://sampleurl.jpg",
|
|
isAudio: false,
|
|
duration: 177.413,
|
|
url: "sampleurl.com",
|
|
uploader: "Sample Uploader",
|
|
size: 2838445,
|
|
path: "users\\admin\\video\\Sample Video.mp4",
|
|
upload_date: "2017-07-28",
|
|
description: null,
|
|
view_count: 230,
|
|
abr: 128,
|
|
thumbnailPath: null,
|
|
user_uid: "admin",
|
|
uid: "1ada04ab-2773-4dd4-bbdd-3e2d40761c50",
|
|
registered: 1628469039377
|
|
}
|
|
|
|
describe('Database', async function() {
|
|
describe('Import', async function() {
|
|
// it('Migrate', async function() {
|
|
// await db_api.connectToDB();
|
|
// await db_api.removeAllRecords();
|
|
// const success = await db_api.importJSONToDB(db.value(), users_db.value());
|
|
// assert(success);
|
|
// });
|
|
|
|
it('Transfer to remote', async function() {
|
|
await db_api.removeAllRecords('test');
|
|
await db_api.insertRecordIntoTable('test', {test: 'test'});
|
|
|
|
await db_api.transferDB(true);
|
|
const success = await db_api.getRecord('test', {test: 'test'});
|
|
assert(success);
|
|
});
|
|
|
|
it('Transfer to local', async function() {
|
|
await db_api.connectToDB();
|
|
await db_api.removeAllRecords('test');
|
|
await db_api.insertRecordIntoTable('test', {test: 'test'});
|
|
|
|
await db_api.transferDB(false);
|
|
const success = await db_api.getRecord('test', {test: 'test'});
|
|
assert(success);
|
|
});
|
|
|
|
it('Restore db', async function() {
|
|
const db_stats = await db_api.getDBStats();
|
|
|
|
const file_name = await db_api.backupDB();
|
|
await db_api.restoreDB(file_name);
|
|
|
|
const new_db_stats = await db_api.getDBStats();
|
|
|
|
assert(JSON.stringify(db_stats), JSON.stringify(new_db_stats));
|
|
});
|
|
});
|
|
|
|
describe('Basic functions', async function() {
|
|
|
|
// test both local_db and remote_db
|
|
const local_db_modes = [false, true];
|
|
|
|
for (const local_db_mode of local_db_modes) {
|
|
let use_local_db = local_db_mode;
|
|
describe(`Use local DB - ${use_local_db}`, async function() {
|
|
beforeEach(async function() {
|
|
if (!use_local_db) {
|
|
this.timeout(120000);
|
|
await db_api.connectToDB(0);
|
|
}
|
|
await db_api.removeAllRecords('test');
|
|
});
|
|
it('Add and read record', async function() {
|
|
this.timeout(120000);
|
|
await db_api.insertRecordIntoTable('test', {test_add: 'test', test_undefined: undefined, test_null: undefined});
|
|
const added_record = await db_api.getRecord('test', {test_add: 'test', test_undefined: undefined, test_null: null});
|
|
assert(added_record['test_add'] === 'test');
|
|
await db_api.removeRecord('test', {test_add: 'test'});
|
|
});
|
|
it('Add and read record - Nested property', async function() {
|
|
this.timeout(120000);
|
|
await db_api.insertRecordIntoTable('test', {test_add: 'test', test_nested: {test_key1: 'test1', test_key2: 'test2'}});
|
|
const added_record = await db_api.getRecord('test', {test_add: 'test', 'test_nested.test_key1': 'test1', 'test_nested.test_key2': 'test2'});
|
|
const not_added_record = await db_api.getRecord('test', {test_add: 'test', 'test_nested.test_key1': 'test1', 'test_nested.test_key2': 'test3'});
|
|
assert(added_record['test_add'] === 'test');
|
|
assert(!not_added_record);
|
|
await db_api.removeRecord('test', {test_add: 'test'});
|
|
});
|
|
it('Replace filter', async function() {
|
|
this.timeout(120000);
|
|
await db_api.insertRecordIntoTable('test', {test_replace_filter: 'test', test_nested: {test_key1: 'test1', test_key2: 'test2'}}, {test_nested: {test_key1: 'test1', test_key2: 'test2'}});
|
|
await db_api.insertRecordIntoTable('test', {test_replace_filter: 'test', test_nested: {test_key1: 'test1', test_key2: 'test2'}}, {test_nested: {test_key1: 'test1', test_key2: 'test2'}});
|
|
const count = await db_api.getRecords('test', {test_replace_filter: 'test'}, true);
|
|
assert(count === 1);
|
|
await db_api.removeRecord('test', {test_replace_filter: 'test'});
|
|
});
|
|
it('Find duplicates by key', async function() {
|
|
const test_duplicates = [
|
|
{
|
|
test: 'testing',
|
|
key: '1'
|
|
},
|
|
{
|
|
test: 'testing',
|
|
key: '2'
|
|
},
|
|
{
|
|
test: 'testing_missing',
|
|
key: '3'
|
|
},
|
|
{
|
|
test: 'testing',
|
|
key: '4'
|
|
}
|
|
];
|
|
await db_api.insertRecordsIntoTable('test', test_duplicates);
|
|
const duplicates = await db_api.findDuplicatesByKey('test', 'test');
|
|
console.log(duplicates);
|
|
});
|
|
|
|
it('Update record', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test_update: 'test'});
|
|
await db_api.updateRecord('test', {test_update: 'test'}, {added_field: true});
|
|
const updated_record = await db_api.getRecord('test', {test_update: 'test'});
|
|
assert(updated_record['added_field']);
|
|
await db_api.removeRecord('test', {test_update: 'test'});
|
|
});
|
|
|
|
it('Remove property from record', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test_keep: 'test', test_remove: 'test'});
|
|
await db_api.removePropertyFromRecord('test', {test_keep: 'test'}, {test_remove: true});
|
|
const updated_record = await db_api.getRecord('test', {test_keep: 'test'});
|
|
assert(updated_record['test_keep']);
|
|
assert(!updated_record['test_remove']);
|
|
await db_api.removeRecord('test', {test_keep: 'test'});
|
|
});
|
|
|
|
it('Remove record', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test_remove: 'test'});
|
|
const delete_succeeded = await db_api.removeRecord('test', {test_remove: 'test'});
|
|
assert(delete_succeeded);
|
|
const deleted_record = await db_api.getRecord('test', {test_remove: 'test'});
|
|
assert(!deleted_record);
|
|
});
|
|
|
|
it('Remove records', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test_remove: 'test', test_property: 'test'});
|
|
await db_api.insertRecordIntoTable('test', {test_remove: 'test', test_property: 'test2'});
|
|
await db_api.insertRecordIntoTable('test', {test_remove: 'test'});
|
|
const delete_succeeded = await db_api.removeAllRecords('test', {test_remove: 'test'});
|
|
assert(delete_succeeded);
|
|
const count = await db_api.getRecords('test', {test_remove: 'test'}, true);
|
|
assert(count === 0);
|
|
});
|
|
|
|
it('Push to record array', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test: 'test', test_array: []});
|
|
await db_api.pushToRecordsArray('test', {test: 'test'}, 'test_array', 'test_item');
|
|
const record = await db_api.getRecord('test', {test: 'test'});
|
|
assert(record);
|
|
assert(record['test_array'].length === 1);
|
|
});
|
|
|
|
it('Pull from record array', async function() {
|
|
await db_api.insertRecordIntoTable('test', {test: 'test', test_array: ['test_item']});
|
|
await db_api.pullFromRecordsArray('test', {test: 'test'}, 'test_array', 'test_item');
|
|
const record = await db_api.getRecord('test', {test: 'test'});
|
|
assert(record);
|
|
assert(record['test_array'].length === 0);
|
|
});
|
|
|
|
it('Bulk add', async function() {
|
|
this.timeout(120000);
|
|
const NUM_RECORDS_TO_ADD = 2002; // max batch ops is 1000
|
|
const test_records = [];
|
|
for (let i = 0; i < NUM_RECORDS_TO_ADD; i++) {
|
|
test_records.push({
|
|
uid: uuid()
|
|
});
|
|
}
|
|
const succcess = await db_api.bulkInsertRecordsIntoTable('test', test_records);
|
|
|
|
const received_records = await db_api.getRecords('test');
|
|
assert(succcess && received_records && received_records.length === NUM_RECORDS_TO_ADD);
|
|
});
|
|
|
|
it('Bulk update', async function() {
|
|
// bulk add records
|
|
const NUM_RECORDS_TO_ADD = 100; // max batch ops is 1000
|
|
const test_records = [];
|
|
const update_obj = {};
|
|
for (let i = 0; i < NUM_RECORDS_TO_ADD; i++) {
|
|
const test_uid = uuid();
|
|
test_records.push({
|
|
uid: test_uid
|
|
});
|
|
update_obj[test_uid] = {added_field: true};
|
|
}
|
|
let success = await db_api.bulkInsertRecordsIntoTable('test', test_records);
|
|
assert(success);
|
|
|
|
// makes sure they are added
|
|
const received_records = await db_api.getRecords('test');
|
|
assert(received_records && received_records.length === NUM_RECORDS_TO_ADD);
|
|
|
|
success = await db_api.bulkUpdateRecordsByKey('test', 'uid', update_obj);
|
|
assert(success);
|
|
|
|
const received_updated_records = await db_api.getRecords('test');
|
|
for (let i = 0; i < received_updated_records.length; i++) {
|
|
success &= received_updated_records[i]['added_field'];
|
|
}
|
|
assert(success);
|
|
});
|
|
|
|
it('Stats', async function() {
|
|
const stats = await db_api.getDBStats();
|
|
assert(stats);
|
|
});
|
|
|
|
it('Query speed', async function() {
|
|
this.timeout(120000);
|
|
const NUM_RECORDS_TO_ADD = 300004; // max batch ops is 1000
|
|
const test_records = [];
|
|
let random_uid = '06241f83-d1b8-4465-812c-618dfa7f2943';
|
|
for (let i = 0; i < NUM_RECORDS_TO_ADD; i++) {
|
|
const uid = uuid();
|
|
if (i === NUM_RECORDS_TO_ADD/2) random_uid = uid;
|
|
test_records.push({"id":"RandomTextRandomText","title":"RandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomText","thumbnailURL":"https://i.ytimg.com/vi/randomurl/maxresdefault.jpg","isAudio":true,"duration":312,"url":"https://www.youtube.com/watch?v=randomvideo","uploader":"randomUploader","size":5060157,"path":"audio\\RandomTextRandomText.mp3","upload_date":"2016-05-11","description":"RandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomTextRandomText","view_count":118689353,"height":null,"abr":160,"uid": uid,"registered":1626672120632});
|
|
}
|
|
const insert_start = Date.now();
|
|
let success = await db_api.bulkInsertRecordsIntoTable('test', test_records);
|
|
const insert_end = Date.now();
|
|
|
|
console.log(`Insert time: ${(insert_end - insert_start)/1000}s`);
|
|
|
|
const query_start = Date.now();
|
|
const random_record = await db_api.getRecord('test', {uid: random_uid});
|
|
const query_end = Date.now();
|
|
|
|
console.log(random_record)
|
|
|
|
console.log(`Query time: ${(query_end - query_start)/1000}s`);
|
|
|
|
success = !!random_record;
|
|
|
|
assert(success);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
describe('Local DB Filters', async function() {
|
|
it('Basic', async function() {
|
|
const result = db_api.applyFilterLocalDB([{test: 'test'}, {test: 'test1'}], {test: 'test'}, 'find');
|
|
assert(result && result['test'] === 'test');
|
|
});
|
|
|
|
it('Regex', async function() {
|
|
const filter = {$regex: `\\w+\\d`, $options: 'i'};
|
|
const result = db_api.applyFilterLocalDB([{test: 'test'}, {test: 'test1'}], {test: filter}, 'find');
|
|
assert(result && result['test'] === 'test1');
|
|
});
|
|
|
|
it('Not equals', async function() {
|
|
const filter = {$ne: 'test'};
|
|
const result = db_api.applyFilterLocalDB([{test: 'test'}, {test: 'test1'}], {test: filter}, 'find');
|
|
assert(result && result['test'] === 'test1');
|
|
});
|
|
|
|
it('Nested', async function() {
|
|
const result = db_api.applyFilterLocalDB([{test1: {test2: 'test3'}}, {test4: 'test5'}], {'test1.test2': 'test3'}, 'find');
|
|
assert(result && result['test1']['test2'] === 'test3');
|
|
});
|
|
})
|
|
});
|
|
|
|
describe('Multi User', async function() {
|
|
let user = null;
|
|
const user_to_test = 'admin';
|
|
const sub_to_test = 'dc834388-3454-41bf-a618-e11cb8c7de1c';
|
|
const playlist_to_test = 'ysabVZz4x';
|
|
beforeEach(async function() {
|
|
await db_api.connectToDB();
|
|
user = await auth_api.login('admin', 'pass');
|
|
});
|
|
describe('Authentication', function() {
|
|
it('login', async function() {
|
|
assert(user);
|
|
});
|
|
});
|
|
describe('Video player - normal', async function() {
|
|
await db_api.removeRecord('files', {uid: sample_video_json['uid']});
|
|
await db_api.insertRecordIntoTable('files', sample_video_json);
|
|
const video_to_test = sample_video_json['uid'];
|
|
it('Get video', async function() {
|
|
const video_obj = await db_api.getVideo(video_to_test);
|
|
assert(video_obj);
|
|
});
|
|
|
|
it('Video access - disallowed', async function() {
|
|
await db_api.setVideoProperty(video_to_test, {sharingEnabled: false}, user_to_test);
|
|
const video_obj = auth_api.getUserVideo('admin', video_to_test, true);
|
|
assert(!video_obj);
|
|
});
|
|
|
|
it('Video access - allowed', async function() {
|
|
await db_api.setVideoProperty(video_to_test, {sharingEnabled: true}, user_to_test);
|
|
const video_obj = auth_api.getUserVideo('admin', video_to_test, true);
|
|
assert(video_obj);
|
|
});
|
|
});
|
|
describe('Zip generators', function() {
|
|
it('Playlist zip generator', async function() {
|
|
const playlist = await db_api.getPlaylist(playlist_to_test, user_to_test);
|
|
assert(playlist);
|
|
const playlist_files_to_download = [];
|
|
for (let i = 0; i < playlist['uids'].length; i++) {
|
|
const uid = playlist['uids'][i];
|
|
const playlist_file = await db_api.getVideo(uid, user_to_test);
|
|
playlist_files_to_download.push(playlist_file);
|
|
}
|
|
const zip_path = await utils.createContainerZipFile(playlist, playlist_files_to_download);
|
|
const zip_exists = fs.pathExistsSync(zip_path);
|
|
assert(zip_exists);
|
|
if (zip_exists) fs.unlinkSync(zip_path);
|
|
});
|
|
|
|
it('Subscription zip generator', async function() {
|
|
const sub = await subscriptions_api.getSubscription(sub_to_test, user_to_test);
|
|
const sub_videos = await db_api.getRecords('files', {sub_id: sub.id});
|
|
assert(sub);
|
|
const sub_files_to_download = [];
|
|
for (let i = 0; i < sub_videos.length; i++) {
|
|
const sub_file = sub_videos[i];
|
|
sub_files_to_download.push(sub_file);
|
|
}
|
|
const zip_path = await utils.createContainerZipFile(sub, sub_files_to_download);
|
|
const zip_exists = fs.pathExistsSync(zip_path);
|
|
assert(zip_exists);
|
|
if (zip_exists) fs.unlinkSync(zip_path);
|
|
});
|
|
});
|
|
// describe('Video player - subscription', function() {
|
|
// const sub_to_test = '';
|
|
// const video_to_test = 'ebbcfffb-d6f1-4510-ad25-d1ec82e0477e';
|
|
// it('Get video', async function() {
|
|
// const video_obj = db_api.getVideo(video_to_test, 'admin', );
|
|
// assert(video_obj);
|
|
// });
|
|
|
|
// it('Video access - disallowed', async function() {
|
|
// await db_api.setVideoProperty(video_to_test, {sharingEnabled: false}, user_to_test, sub_to_test);
|
|
// const video_obj = auth_api.getUserVideo('admin', video_to_test, true);
|
|
// assert(!video_obj);
|
|
// });
|
|
|
|
// it('Video access - allowed', async function() {
|
|
// await db_api.setVideoProperty(video_to_test, {sharingEnabled: true}, user_to_test, sub_to_test);
|
|
// const video_obj = auth_api.getUserVideo('admin', video_to_test, true);
|
|
// assert(video_obj);
|
|
// });
|
|
// });
|
|
|
|
});
|
|
|
|
describe('Downloader', function() {
|
|
const downloader_api = require('../downloader');
|
|
const url = 'https://www.youtube.com/watch?v=dQw4w9WgXcQ';
|
|
const sub_id = 'dc834388-3454-41bf-a618-e11cb8c7de1c';
|
|
const options = {
|
|
ui_uid: uuid(),
|
|
user: 'admin'
|
|
}
|
|
|
|
beforeEach(async function() {
|
|
await db_api.connectToDB();
|
|
await db_api.removeAllRecords('download_queue');
|
|
});
|
|
|
|
it('Get file info', async function() {
|
|
this.timeout(300000);
|
|
const info = await downloader_api.getVideoInfoByURL(url);
|
|
assert(!!info);
|
|
});
|
|
|
|
it('Download file', async function() {
|
|
this.timeout(300000);
|
|
const returned_download = await downloader_api.createDownload(url, 'video', options);
|
|
console.log(returned_download);
|
|
await utils.wait(20000);
|
|
|
|
});
|
|
|
|
it('Tag file', async function() {
|
|
const audio_path = './test/sample.mp3';
|
|
const sample_json = fs.readJSONSync('./test/sample.info.json');
|
|
const tags = {
|
|
title: sample_json['title'],
|
|
artist: sample_json['artist'] ? sample_json['artist'] : sample_json['uploader'],
|
|
TRCK: '27'
|
|
}
|
|
NodeID3.write(tags, audio_path);
|
|
const written_tags = NodeID3.read(audio_path);
|
|
assert(written_tags['raw']['TRCK'] === '27');
|
|
});
|
|
|
|
it('Queue file', async function() {
|
|
this.timeout(300000);
|
|
const returned_download = await downloader_api.createDownload(url, 'video', options);
|
|
console.log(returned_download);
|
|
await utils.wait(20000);
|
|
});
|
|
|
|
it('Pause file', async function() {
|
|
const returned_download = await downloader_api.createDownload(url, 'video', options);
|
|
await downloader_api.pauseDownload(returned_download['uid']);
|
|
const updated_download = await db_api.getRecord('download_queue', {uid: returned_download['uid']});
|
|
assert(updated_download['paused'] && !updated_download['running']);
|
|
});
|
|
|
|
it('Generate args', async function() {
|
|
const args = await downloader_api.generateArgs(url, 'video', options);
|
|
assert(args.length > 0);
|
|
});
|
|
|
|
it('Generate args - subscription', async function() {
|
|
const sub = await subscriptions_api.getSubscription(sub_id);
|
|
const sub_options = subscriptions_api.generateOptionsForSubscriptionDownload(sub, 'admin');
|
|
const args_normal = await downloader_api.generateArgs(url, 'video', options);
|
|
const args_sub = await downloader_api.generateArgs(url, 'video', sub_options, 'admin');
|
|
console.log(JSON.stringify(args_normal) !== JSON.stringify(args_sub));
|
|
});
|
|
|
|
it('Generate kodi NFO file', async function() {
|
|
const nfo_file_path = './test/sample.nfo';
|
|
if (fs.existsSync(nfo_file_path)) {
|
|
fs.unlinkSync(nfo_file_path);
|
|
}
|
|
const sample_json = fs.readJSONSync('./test/sample.info.json');
|
|
downloader_api.generateNFOFile(sample_json, nfo_file_path);
|
|
assert(fs.existsSync(nfo_file_path), true);
|
|
fs.unlinkSync(nfo_file_path);
|
|
});
|
|
|
|
it('Inject args', async function() {
|
|
const original_args1 = ['--no-resize-buffer', '-o', '%(title)s', '--no-mtime'];
|
|
const new_args1 = ['--age-limit', '25', '--yes-playlist', '--abort-on-error', '-o', '%(id)s'];
|
|
const updated_args1 = utils.injectArgs(original_args1, new_args1);
|
|
const expected_args1 = ['--no-resize-buffer', '--no-mtime', '--age-limit', '25', '--yes-playlist', '--abort-on-error', '-o', '%(id)s'];
|
|
assert(JSON.stringify(updated_args1), JSON.stringify(expected_args1));
|
|
|
|
const original_args2 = ['-o', '%(title)s.%(ext)s', '--write-info-json', '--print-json', '--audio-quality', '0', '-x', '--audio-format', 'mp3'];
|
|
const new_args2 = ['--add-metadata', '--embed-thumbnail', '--convert-thumbnails', 'jpg'];
|
|
const updated_args2 = utils.injectArgs(original_args2, new_args2);
|
|
const expected_args2 = ['-o', '%(title)s.%(ext)s', '--write-info-json', '--print-json', '--audio-quality', '0', '-x', '--audio-format', 'mp3', '--add-metadata', '--embed-thumbnail', '--convert_thumbnails', 'jpg'];
|
|
console.log(updated_args2);
|
|
assert(JSON.stringify(updated_args2), JSON.stringify(expected_args2));
|
|
});
|
|
describe('Twitch', async function () {
|
|
const twitch_api = require('../twitch');
|
|
const example_vod = '1493770675';
|
|
it('Download VOD', async function() {
|
|
const sample_path = path.join('test', 'sample.twitch_chat.json');
|
|
if (fs.existsSync(sample_path)) fs.unlinkSync(sample_path);
|
|
this.timeout(300000);
|
|
await twitch_api.downloadTwitchChatByVODID(example_vod, 'sample', null, null, null, './test');
|
|
assert(fs.existsSync(sample_path));
|
|
|
|
// cleanup
|
|
if (fs.existsSync(sample_path)) fs.unlinkSync(sample_path);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Tasks', function() {
|
|
const tasks_api = require('../tasks');
|
|
beforeEach(async function() {
|
|
await db_api.connectToDB();
|
|
await db_api.removeAllRecords('tasks');
|
|
|
|
const dummy_task = {
|
|
run: async () => { await utils.wait(500); return true; },
|
|
confirm: async () => { await utils.wait(500); return true; },
|
|
title: 'Dummy task',
|
|
job: null
|
|
};
|
|
tasks_api.TASKS['dummy_task'] = dummy_task;
|
|
|
|
await tasks_api.setupTasks();
|
|
});
|
|
it('Backup db', async function() {
|
|
const backups_original = await utils.recFindByExt('appdata', 'bak');
|
|
const original_length = backups_original.length;
|
|
await tasks_api.executeTask('backup_local_db');
|
|
const backups_new = await utils.recFindByExt('appdata', 'bak');
|
|
const new_length = backups_new.length;
|
|
assert(original_length, new_length-1);
|
|
});
|
|
|
|
it('Check for missing files', async function() {
|
|
this.timeout(300000);
|
|
await db_api.removeAllRecords('files', {uid: 'test'});
|
|
const test_missing_file = {uid: 'test', path: 'test/missing_file.mp4'};
|
|
await db_api.insertRecordIntoTable('files', test_missing_file);
|
|
await tasks_api.executeTask('missing_files_check');
|
|
const missing_file_db_record = await db_api.getRecord('files', {uid: 'test'});
|
|
assert(!missing_file_db_record, true);
|
|
});
|
|
|
|
it('Check for duplicate files', async function() {
|
|
this.timeout(300000);
|
|
await db_api.removeAllRecords('files', {uid: 'test1'});
|
|
await db_api.removeAllRecords('files', {uid: 'test2'});
|
|
const test_duplicate_file1 = {uid: 'test1', path: 'test/missing_file.mp4'};
|
|
const test_duplicate_file2 = {uid: 'test2', path: 'test/missing_file.mp4'};
|
|
const test_duplicate_file3 = {uid: 'test3', path: 'test/missing_file.mp4'};
|
|
await db_api.insertRecordIntoTable('files', test_duplicate_file1);
|
|
await db_api.insertRecordIntoTable('files', test_duplicate_file2);
|
|
await db_api.insertRecordIntoTable('files', test_duplicate_file3);
|
|
|
|
await tasks_api.executeRun('duplicate_files_check');
|
|
const task_obj = await db_api.getRecord('tasks', {key: 'duplicate_files_check'});
|
|
assert(task_obj['data'] && task_obj['data']['uids'] && task_obj['data']['uids'].length >= 1, true);
|
|
|
|
await tasks_api.executeTask('duplicate_files_check');
|
|
const duplicated_record_count = await db_api.getRecords('files', {path: 'test/missing_file.mp4'}, true);
|
|
assert(duplicated_record_count == 1, true);
|
|
});
|
|
|
|
it('Import unregistered files', async function() {
|
|
this.timeout(300000);
|
|
|
|
// pre-test cleanup
|
|
await db_api.removeAllRecords('files', {title: 'Sample File'});
|
|
if (fs.existsSync('video/sample.info.json')) fs.unlinkSync('video/sample.info.json');
|
|
if (fs.existsSync('video/sample.mp4')) fs.unlinkSync('video/sample.mp4');
|
|
|
|
// copies in files
|
|
fs.copyFileSync('test/sample.info.json', 'video/sample.info.json');
|
|
fs.copyFileSync('test/sample.mp4', 'video/sample.mp4');
|
|
await tasks_api.executeTask('missing_db_records');
|
|
const imported_file = await db_api.getRecord('files', {title: 'Sample File'});
|
|
assert(!!imported_file, true);
|
|
|
|
// post-test cleanup
|
|
if (fs.existsSync('video/sample.info.json')) fs.unlinkSync('video/sample.info.json');
|
|
if (fs.existsSync('video/sample.mp4')) fs.unlinkSync('video/sample.mp4');
|
|
});
|
|
|
|
it('Schedule and cancel task', async function() {
|
|
this.timeout(5000);
|
|
const today_one_year = new Date();
|
|
today_one_year.setFullYear(today_one_year.getFullYear() + 1);
|
|
const schedule_obj = {
|
|
type: 'timestamp',
|
|
data: { timestamp: today_one_year.getTime() }
|
|
}
|
|
await tasks_api.updateTaskSchedule('dummy_task', schedule_obj);
|
|
const dummy_task = await db_api.getRecord('tasks', {key: 'dummy_task'});
|
|
assert(!!tasks_api.TASKS['dummy_task']['job']);
|
|
assert(!!dummy_task['schedule']);
|
|
|
|
await tasks_api.updateTaskSchedule('dummy_task', null);
|
|
const dummy_task_updated = await db_api.getRecord('tasks', {key: 'dummy_task'});
|
|
assert(!tasks_api.TASKS['dummy_task']['job']);
|
|
assert(!dummy_task_updated['schedule']);
|
|
});
|
|
|
|
it('Schedule and run task', async function() {
|
|
this.timeout(5000);
|
|
const today_1_second = new Date();
|
|
today_1_second.setSeconds(today_1_second.getSeconds() + 1);
|
|
const schedule_obj = {
|
|
type: 'timestamp',
|
|
data: { timestamp: today_1_second.getTime() }
|
|
}
|
|
await tasks_api.updateTaskSchedule('dummy_task', schedule_obj);
|
|
assert(!!tasks_api.TASKS['dummy_task']['job']);
|
|
await utils.wait(2000);
|
|
const dummy_task_obj = await db_api.getRecord('tasks', {key: 'dummy_task'});
|
|
assert(dummy_task_obj['data']);
|
|
});
|
|
});
|
|
|
|
describe('Archive', async function() {
|
|
beforeEach(async function() {
|
|
await db_api.connectToDB();
|
|
await db_api.removeAllRecords('archives', {user_uid: 'test_user'});
|
|
});
|
|
|
|
afterEach(async function() {
|
|
await db_api.removeAllRecords('archives', {user_uid: 'test_user'});
|
|
});
|
|
|
|
it('Import archive', async function() {
|
|
const archive_text = `
|
|
testextractor1 testing1
|
|
testextractor1 testing2
|
|
testextractor2 testing1
|
|
testextractor1 testing3
|
|
|
|
`;
|
|
const count = await archive_api.importArchiveFile(archive_text, 'video', 'test_user', 'test_sub');
|
|
assert(count === 4)
|
|
const archive_items = await db_api.getRecords('archives', {user_uid: 'test_user', sub_id: 'test_sub'});
|
|
console.log(archive_items);
|
|
assert(archive_items.length === 4);
|
|
assert(archive_items.filter(archive_item => archive_item.extractor === 'testextractor2').length === 1);
|
|
assert(archive_items.filter(archive_item => archive_item.extractor === 'testextractor1').length === 3);
|
|
|
|
const success = await db_api.removeAllRecords('archives', {user_uid: 'test_user', sub_id: 'test_sub'});
|
|
assert(success);
|
|
});
|
|
|
|
it('Get archive', async function() {
|
|
await archive_api.addToArchive('testextractor1', 'testing1', 'video', 'test_user');
|
|
await archive_api.addToArchive('testextractor2', 'testing1', 'video', 'test_user');
|
|
|
|
const archive_item1 = await db_api.getRecord('archives', {extractor: 'testextractor1', id: 'testing1'});
|
|
const archive_item2 = await db_api.getRecord('archives', {extractor: 'testextractor2', id: 'testing1'});
|
|
|
|
assert(archive_item1 && archive_item2);
|
|
});
|
|
|
|
it('Archive duplicates', async function() {
|
|
await archive_api.addToArchive('testextractor1', 'testing1', 'video', 'test_user');
|
|
await archive_api.addToArchive('testextractor2', 'testing1', 'video', 'test_user');
|
|
await archive_api.addToArchive('testextractor2', 'testing1', 'video', 'test_user');
|
|
|
|
await archive_api.addToArchive('testextractor1', 'testing1', 'audio', 'test_user');
|
|
|
|
const count = await db_api.getRecords('archives', {id: 'testing1'}, true);
|
|
assert(count === 3);
|
|
});
|
|
|
|
it('Remove from archive', async function() {
|
|
await archive_api.addToArchive('testextractor1', 'testing1', 'video', 'test_user');
|
|
await archive_api.addToArchive('testextractor2', 'testing1', 'video', 'test_user');
|
|
await archive_api.addToArchive('testextractor2', 'testing2', 'video', 'test_user');
|
|
|
|
const success = await archive_api.removeFromArchive('testextractor2', 'testing1', 'video', 'test_user');
|
|
assert(success);
|
|
|
|
const archive_item1 = await db_api.getRecord('archives', {extractor: 'testextractor1', id: 'testing1'});
|
|
assert(!!archive_item1);
|
|
|
|
const archive_item2 = await db_api.getRecord('archives', {extractor: 'testextractor2', id: 'testing1'});
|
|
assert(!archive_item2);
|
|
|
|
const archive_item3 = await db_api.getRecord('archives', {extractor: 'testextractor2', id: 'testing2'});
|
|
assert(!!archive_item3);
|
|
});
|
|
});
|
|
|
|
describe('Utils', async function() {
|
|
it('Strip properties', async function() {
|
|
const test_obj = {test1: 'test1', test2: 'test2', test3: 'test3'};
|
|
const stripped_obj = utils.stripPropertiesFromObject(test_obj, ['test1', 'test3']);
|
|
assert(!stripped_obj['test1'] && stripped_obj['test2'] && !stripped_obj['test3'])
|
|
});
|
|
|
|
it('Convert flat object to nested object', async function() {
|
|
// No modfication
|
|
const flat_obj0 = {'test1': {'test_sub': true}, 'test2': {test_sub: true}};
|
|
const nested_obj0 = utils.convertFlatObjectToNestedObject(flat_obj0);
|
|
assert(nested_obj0['test1'] && nested_obj0['test1']['test_sub']);
|
|
assert(nested_obj0['test2'] && nested_obj0['test2']['test_sub']);
|
|
|
|
// Standard setup
|
|
const flat_obj1 = {'test1.test_sub': true, 'test2.test_sub': true};
|
|
const nested_obj1 = utils.convertFlatObjectToNestedObject(flat_obj1);
|
|
assert(nested_obj1['test1'] && nested_obj1['test1']['test_sub']);
|
|
assert(nested_obj1['test2'] && nested_obj1['test2']['test_sub']);
|
|
|
|
// Nested branches
|
|
const flat_obj2 = {'test1.test_sub': true, 'test1.test2.test_sub': true};
|
|
const nested_obj2 = utils.convertFlatObjectToNestedObject(flat_obj2);
|
|
assert(nested_obj2['test1'] && nested_obj2['test1']['test_sub']);
|
|
assert(nested_obj2['test1'] && nested_obj2['test1']['test2'] && nested_obj2['test1']['test2']['test_sub']);
|
|
});
|
|
}); |