Flaro/server/tests/Flaro.Core.Tests/TitelschluesselTests.cs

using Flaro.Core.Library;

namespace Flaro.Core.Tests;

/// <summary>Welche Schreibweisen denselben Film meinen — und welche nicht.</summary>
public class TitelschluesselTests
{
    [TestCase("Dr. Dolittle 2", "Dr Dolittle 2")]
    [TestCase("Spider-Man", "Spider Man")]
    [TestCase("WALL·E", "WALL-E")]
    [TestCase("Amélie", "Amelie")]
    [TestCase("The Matrix", "the   matrix")]
    [TestCase("Ich einfach unverbesserlich!", "Ich einfach unverbesserlich")]
    public void Gleiche_Titel_trotz_anderer_Schreibweise(string a, string b) =>
        Assert.That(Titelschluessel.Von(a), Is.EqualTo(Titelschluessel.Von(b)), $"„{a}" + $"\" und „{b}\"");

    /// <summary>Hier endet die Toleranz — und das ist Absicht.</summary>
    ///
    /// <remarks>
    /// Ein zusammengelegter Film lässt sich nicht mehr trennen, ohne zu
    /// wissen, welche Datei wohin gehörte. Zwei Einträge für einen Film sind
    /// ärgerlich; ein Eintrag für zwei Filme ist Datenverlust.
    /// </remarks>
    [TestCase("Spider-Man", "Spiderman")]
    [TestCase("Der Pate", "Der Pate 2")]
    [TestCase("Dune", "Dune Part Two")]
    public void Verschiedene_Titel_bleiben_verschieden(string a, string b) =>
        Assert.That(Titelschluessel.Von(a), Is.Not.EqualTo(Titelschluessel.Von(b)));

    [Test]
    public void Ein_fehlendes_Jahr_passt_auf_jedes() =>
        Assert.That(Titelschluessel.Gleich("Descendants 2", null, "Descendants 2", 2017), Is.True);

    /// <summary>Die beiden „Dune" dürfen nie verschmelzen.</summary>
    [Test]
    public void Zwei_bekannte_Jahre_trennen() =>
        Assert.That(Titelschluessel.Gleich("Dune", 1984, "Dune", 2021), Is.False);

    [Test]
    public void Leeres_passt_auf_nichts()
    {
        Assert.That(Titelschluessel.Von(""), Is.Empty);
        Assert.That(Titelschluessel.Gleich("", null, "", null), Is.False,
            "Zwei namenlose Einträge sind nicht derselbe Film.");
    }
}

/// <summary>Welche Fassung eine Datei ist — 4K, Mobil, Director's Cut.</summary>
public class FassungTests
{
    [TestCase("The Matrix (1999) - Mobil.mp4", "Mobil")]
    [TestCase("The Matrix (1999) - optimiert.mp4", "Mobil")]
    [TestCase("The Matrix (1999) - 2160p.mkv", "2160p")]
    [TestCase("The Matrix (1999) {edition-Director's Cut}.mkv", "Director's Cut")]
    [TestCase("Mobil/The Matrix (1999).mp4", "Mobil")]
    [TestCase("The Matrix (1999) - Extended.mkv", "Extended")]
    public void Erkennt_die_Fassung(string pfad, string erwartet) =>
        Assert.That(FileNames.Fassung(pfad), Is.EqualTo(erwartet));

    /// <summary>Eine Veröffentlichungsgruppe ist keine Fassung.</summary>
    ///
    /// <remarks>
    /// Nähme man jedes Wort hinter dem letzten Bindestrich, hiesse eine
    /// Fassung „YIFY" oder „GRP". Lieber kein Name als ein falscher — dann
    /// greift der Rückfall über die Bildhöhe.
    /// </remarks>
    [TestCase("The Matrix (1999) - YIFY.mkv")]
    [TestCase("The Matrix (1999).mkv")]
    [TestCase("Filme/The Matrix (1999).mkv")]
    public void Raet_nicht(string pfad) => Assert.That(FileNames.Fassung(pfad), Is.Null);

    [TestCase(2160, "4K")]
    [TestCase(1080, "1080p")]
    [TestCase(720, "720p")]
    [TestCase(480, "SD")]
    [TestCase(null, null)]
    public void Bildet_die_Fassung_aus_der_Hoehe(int? hoehe, string? erwartet) =>
        Assert.That(FileNames.FassungAusHoehe(hoehe), Is.EqualTo(erwartet));

    /// <summary>Der Fassungszusatz darf nie im Titel landen.</summary>
    [Test]
    public void Die_Fassung_bleibt_aus_dem_Titel_heraus()
    {
        Assert.That(FileNames.ParseMovie("The Matrix (1999) - Mobil.mp4").Title, Is.EqualTo("The Matrix"));
        Assert.That(FileNames.ParseMovie("The Matrix (1999) - 2160p.mkv").Title, Is.EqualTo("The Matrix"));
    }

    /* ---------- Bindewörter ---------- */

    /// <summary>„Hanni und Nanni" und „Hanni &amp; Nanni" sind derselbe Titel.</summary>
    ///
    /// <remarks>
    /// <b>Der Fall, an dem ein ganzer Film verschwand.</b> Auf der Platte
    /// heisst er „Hanni und Nanni", bei TMDB „Hanni &amp; Nanni" — das
    /// Kaufmanns-Und fiel als Sonderzeichen heraus, das Wort „und" blieb
    /// stehen. Die Namensgleichheit griff deshalb nie, und gewählt wurde der
    /// erstbeste Treffer: „Hanni &amp; Nanni 3". Beide Dateien landeten auf
    /// derselben Kennung, und Teil 1 war nicht mehr zu sehen.
    /// </remarks>
    [TestCase("Hanni und Nanni", "Hanni & Nanni")]
    [TestCase("Batman and Robin", "Batman & Robin")]
    [TestCase("Tom und Jerry", "Tom & Jerry")]
    public void Bindewoerter_machen_keinen_Unterschied(string eines, string anderes)
    {
        Assert.That(Titelschluessel.Von(eines), Is.EqualTo(Titelschluessel.Von(anderes)));
    }

    /// <summary>Eine Folgennummer bleibt ein Unterschied.</summary>
    [Test]
    public void Eine_Nummer_bleibt_ein_Unterschied()
    {
        Assert.That(Titelschluessel.Von("Hanni und Nanni"),
            Is.Not.EqualTo(Titelschluessel.Von("Hanni & Nanni 3")));
    }

    /// <summary>Am Anfang gehört das Wort zum Titel.</summary>
    ///
    /// <remarks>
    /// „Und dann kam Polly" fängt mit einem Bindewort an — es wegzulassen
    /// machte daraus „dann kam Polly", und das ist ein anderer Film.
    /// </remarks>
    [TestCase("Und dann kam Polly")]
    [TestCase("And Then There Were None")]
    public void Am_Anfang_bleibt_das_Wort_stehen(string titel)
    {
        Assert.That(Titelschluessel.Von(titel), Does.StartWith(
            titel.Split(' ')[0].ToLowerInvariant()));
    }

    /// <summary>Zwei Wörter bleiben zwei Wörter.</summary>
    ///
    /// <remarks>
    /// Bei „Ich und" bliebe sonst nur „Ich" übrig — und das passt dann auf
    /// jeden Film, der so anfängt.
    /// </remarks>
    [Test]
    public void Aus_zwei_Woertern_wird_nichts_gestrichen()
    {
        Assert.That(Titelschluessel.Von("Krieg und"), Is.EqualTo("krieg und"));
    }
}