95 lines
4.8 KiB
TypeScript
95 lines
4.8 KiB
TypeScript
import { test } from '@japa/runner'
|
|
import db from '@adonisjs/lucid/services/db'
|
|
import testUtils from '@adonisjs/core/services/test_utils'
|
|
import NameService from '#services/NameService'
|
|
|
|
async function release(name: string, files: { name: string; size: number; md5_16k: string }[]) {
|
|
const now = new Date()
|
|
const [row] = await db
|
|
.table('releases')
|
|
.insert({ release_key: `${name}`.padEnd(40, 'x').slice(0, 40), name, source: 'par2', groups: '[]', posted_at: now, first_seen_at: now, last_seen_at: now })
|
|
.returning('id')
|
|
for (const [i, f] of files.entries()) {
|
|
await db.table('release_files').insert({ release_id: row.id, par2_file_id: String(i).padStart(32, '0'), name: f.name, size: f.size, md5_16k: f.md5_16k })
|
|
}
|
|
return Number(row.id)
|
|
}
|
|
|
|
async function binary(key: string, fields: Record<string, unknown>) {
|
|
const now = new Date()
|
|
const [row] = await db
|
|
.table('binaries')
|
|
.insert({ file_key: key.padEnd(40, '0'), poster: 'x', subject: '"x" yEnc', name: 'Xq8r2KdLm3Zw91PqA7', total_parts: 1, groups: '[]', first_seen_at: now, last_seen_at: now, ...fields })
|
|
.returning('id')
|
|
return Number(row.id)
|
|
}
|
|
|
|
test.group('NameService', (group) => {
|
|
group.each.setup(() => testUtils.db().withGlobalTransaction())
|
|
|
|
test('an exact match leaves a random-named single-file release for the par2 set', async ({ assert }) => {
|
|
const season = await release('SEAL.Team.S03', [
|
|
{ name: 'SEAL.Team.S03E18.1080p.WEB-DL-nitrato.mkv', size: 939_684_767, md5_16k: 'd'.repeat(32) },
|
|
])
|
|
const now = new Date()
|
|
const [weak] = await db
|
|
.table('releases')
|
|
.insert({ release_key: 'w'.repeat(40), name: 'mOzyyxCyYUjAbCdEf12', source: 'stem', groups: '[]', first_seen_at: now, last_seen_at: now })
|
|
.returning('id')
|
|
const [file] = await db
|
|
.table('files')
|
|
.insert({ filename: 'mOzyyxCyYUjAbCdEf12', poster: 'x', date: now.getTime(), parts: 1, size: 1, groups: '[]', message_ids: '{}', release_id: weak.id, created_at: now, updated_at: now })
|
|
.returning('id')
|
|
const episode = await binary('ep18', { size: 939_684_767, md5_16k: 'd'.repeat(32), release_id: weak.id, file_id: file.id })
|
|
|
|
await NameService.resolve([episode])
|
|
const moved = await db.from('binaries').where('id', episode).first()
|
|
assert.equal(Number(moved.release_id), season)
|
|
assert.equal(moved.real_name, 'SEAL.Team.S03E18.1080p.WEB-DL-nitrato.mkv')
|
|
assert.equal(Number((await db.from('files').where('id', file.id).first()).release_id), season)
|
|
})
|
|
|
|
test('a file in a real grouping keeps it', async ({ assert }) => {
|
|
await release('Other.Set', [{ name: 'Other.Show.S01E01.mkv', size: 5_000_000, md5_16k: 'e'.repeat(32) }])
|
|
const now = new Date()
|
|
const [nzb] = await db
|
|
.table('releases')
|
|
.insert({ release_key: 'n'.repeat(40), name: 'Qz8r2KdLm3Zw91PqA7x', source: 'nzb', groups: '[]', first_seen_at: now, last_seen_at: now })
|
|
.returning('id')
|
|
const id = await binary('nzbfile', { size: 5_000_000, md5_16k: 'e'.repeat(32), release_id: nzb.id })
|
|
await NameService.resolve([id])
|
|
assert.equal(Number((await db.from('binaries').where('id', id).first()).release_id), Number(nzb.id))
|
|
})
|
|
|
|
test('names equal-sized volumes exactly by their first-16k fingerprint', async ({ assert }) => {
|
|
const releaseId = await release('Some.Movie', [
|
|
{ name: 'Some.Movie.part1.rar', size: 50_000_000, md5_16k: 'a'.repeat(32) },
|
|
{ name: 'Some.Movie.part2.rar', size: 50_000_000, md5_16k: 'b'.repeat(32) },
|
|
])
|
|
const one = await binary('one', { size: 50_000_000, md5_16k: 'b'.repeat(32) })
|
|
const two = await binary('two', { size: 50_000_000, md5_16k: 'a'.repeat(32) })
|
|
const stranger = await binary('three', { size: 50_000_000, md5_16k: 'c'.repeat(32) })
|
|
await NameService.resolve([one, two, stranger])
|
|
|
|
const rows = await db.from('binaries').whereIn('id', [one, two, stranger]).orderBy('id')
|
|
assert.deepEqual(rows.map((r) => [r.real_name, r.release_id && Number(r.release_id)]), [
|
|
['Some.Movie.part2.rar', releaseId],
|
|
['Some.Movie.part1.rar', releaseId],
|
|
[null, null],
|
|
])
|
|
})
|
|
|
|
test('without a fingerprint, names by size only when the size is unique in the release', async ({ assert }) => {
|
|
const releaseId = await release('Other', [
|
|
{ name: 'Other.mkv', size: 700_000_000, md5_16k: 'd'.repeat(32) },
|
|
{ name: 'Other.part1.rar', size: 10_000_000, md5_16k: 'e'.repeat(32) },
|
|
{ name: 'Other.part2.rar', size: 10_000_000, md5_16k: 'f'.repeat(32) },
|
|
])
|
|
const video = await binary('video', { size: 700_000_000, release_id: releaseId })
|
|
const volume = await binary('volume', { size: 10_000_000, release_id: releaseId })
|
|
await NameService.resolve([video, volume])
|
|
assert.equal((await db.from('binaries').where('id', video).first()).real_name, 'Other.mkv')
|
|
assert.isNull((await db.from('binaries').where('id', volume).first()).real_name)
|
|
})
|
|
})
|