usenet-indexer/tests/functional/names.spec.ts

import { test } from '@japa/runner'
import db from '@adonisjs/lucid/services/db'
import FileStore from '#services/FileStore'
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 FileStore.insert([
      { filename: 'mOzyyxCyYUjAbCdEf12', poster: 'x', date: now.getTime(), parts: 1, size: 1, groups: '[]', segments: [], release_id: weak.id, created_at: now, updated_at: now },
    ])
    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)
  })
})