Kavita/API.Tests/Parser/ParserTest.cs

using System.Linq;
using Xunit;
using static API.Services.Tasks.Scanner.Parser.Parser;

namespace API.Tests.Parser;

public class ParserTests
{
    [Theory]
    [InlineData("Joe Shmo, Green Blue", "Joe Shmo, Green Blue")]
    [InlineData("Shmo, Joe",  "Shmo, Joe")]
    [InlineData("  Joe Shmo  ",  "Joe Shmo")]
    public void CleanAuthorTest(string input, string expected)
    {
        Assert.Equal(expected, CleanAuthor(input));
    }

    [Theory]
    [InlineData("", "")]
    [InlineData("DEAD Tube Prologue", "DEAD Tube Prologue")]
    [InlineData("DEAD Tube Prologue SP01", "DEAD Tube Prologue")]
    [InlineData("DEAD_Tube_Prologue SP01", "DEAD Tube Prologue")]
    public void CleanSpecialTitleTest(string input, string expected)
    {
        Assert.Equal(expected, CleanSpecialTitle(input));
    }

    [Theory]
    [InlineData("Beastars - SP01", true)]
    [InlineData("Beastars SP01", true)]
    [InlineData("Beastars Special 01", false)]
    [InlineData("Beastars Extra 01", false)]
    [InlineData("Batman Beyond - Return of the Joker (2001) SP01", true)]
    public void HasSpecialTest(string input, bool expected)
    {
        Assert.Equal(expected,  HasSpecialMarker(input));
    }

    [Theory]
    [InlineData("0001", "1")]
    [InlineData("1", "1")]
    [InlineData("0013", "13")]
    public void RemoveLeadingZeroesTest(string input, string expected)
    {
        Assert.Equal(expected, RemoveLeadingZeroes(input));
    }

    [Theory]
    [InlineData("1", "001")]
    [InlineData("10", "010")]
    [InlineData("100", "100")]
    public void PadZerosTest(string input, string expected)
    {
        Assert.Equal(expected, PadZeros(input));
    }

    [Theory]
    [InlineData("Hello_I_am_here", false, "Hello I am here")]
    [InlineData("Hello_I_am_here   ",  false, "Hello I am here")]
    [InlineData("[ReleaseGroup] The Title", false, "The Title")]
    [InlineData("[ReleaseGroup]_The_Title", false, "The Title")]
    [InlineData("-The Title", false, "The Title")]
    [InlineData("- The Title", false, "The Title")]
    [InlineData("[Suihei Kiki]_Kasumi_Otoko_no_Ko_[Taruby]_v1.1", false, "Kasumi Otoko no Ko v1.1")]
    [InlineData("Batman - Detective Comics - Rebirth Deluxe Edition Book 04 (2019) (digital) (Son of Ultron-Empire)", true, "Batman - Detective Comics - Rebirth Deluxe Edition")]
    [InlineData("Something - Full Color Edition", false, "Something - Full Color Edition")]
    public void CleanTitleTest(string input, bool isComic, string expected)
    {
        Assert.Equal(expected, CleanTitle(input, isComic));
    }

    [Theory]
    [InlineData("src: url(fonts/AvenirNext-UltraLight.ttf)", true)]
    [InlineData("src: url(ideal-sans-serif.woff)", true)]
    [InlineData("src: local(\"Helvetica Neue Bold\")", true)]
    [InlineData("src: url(\"/fonts/OpenSans-Regular-webfont.woff2\")", true)]
    [InlineData("src: local(\"/fonts/OpenSans-Regular-webfont.woff2\")", true)]
    [InlineData("src: url(data:application/x-font-woff", false)]
    public void FontCssRewriteMatches(string input, bool expectedMatch)
    {
        Assert.Equal(expectedMatch, FontSrcUrlRegex.Matches(input).Count > 0);
    }

    [Theory]
    [InlineData("src: url(fonts/AvenirNext-UltraLight.ttf)", new [] {"src: url(", "fonts/AvenirNext-UltraLight.ttf", ")"})]
    [InlineData("src: url(ideal-sans-serif.woff)", new [] {"src: url(", "ideal-sans-serif.woff", ")"})]
    [InlineData("src: local(\"Helvetica Neue Bold\")", new [] {"src: local(\"", "Helvetica Neue Bold", "\")"})]
    [InlineData("src: url(\"/fonts/OpenSans-Regular-webfont.woff2\")", new [] {"src: url(\"", "/fonts/OpenSans-Regular-webfont.woff2", "\")"})]
    [InlineData("src: local(\"/fonts/OpenSans-Regular-webfont.woff2\")", new [] {"src: local(\"", "/fonts/OpenSans-Regular-webfont.woff2", "\")"})]
    public void FontCssCorrectlySeparates(string input, string[] expected)
    {
        Assert.Equal(expected, FontSrcUrlRegex.Match(input).Groups.Values.Select(g => g.Value).Where((_, i) => i > 0).ToArray());
    }


    [Theory]
    [InlineData("test.cbz", true)]
    [InlineData("test.cbr", true)]
    [InlineData("test.zip", true)]
    [InlineData("test.rar", true)]
    [InlineData("test.rar.!qb", false)]
    [InlineData("[shf-ma-khs-aqs]negi_pa_vol15007.jpg", false)]
    public void IsArchiveTest(string input, bool expected)
    {
        Assert.Equal(expected, IsArchive(input));
    }

    [Theory]
    [InlineData("test.epub", true)]
    [InlineData("test.pdf", true)]
    [InlineData("test.mobi", false)]
    [InlineData("test.djvu", false)]
    [InlineData("test.zip", false)]
    [InlineData("test.rar", false)]
    [InlineData("test.epub.!qb", false)]
    [InlineData("[shf-ma-khs-aqs]negi_pa_vol15007.ebub", false)]
    public void IsBookTest(string input, bool expected)
    {
        Assert.Equal(expected, IsBook(input));
    }

    [Theory]
    [InlineData("test.epub", true)]
    [InlineData("test.EPUB", true)]
    [InlineData("test.mobi", false)]
    [InlineData("test.epub.!qb", false)]
    [InlineData("[shf-ma-khs-aqs]negi_pa_vol15007.ebub", false)]
    public void IsEpubTest(string input, bool expected)
    {
        Assert.Equal(expected, IsEpub(input));
    }

    [Theory]
    [InlineData("12-14", 12)]
    [InlineData("24", 24)]
    [InlineData("18-04", 4)]
    [InlineData("18-04.5", 4.5)]
    [InlineData("40", 40)]
    [InlineData("40a-040b", 0)]
    [InlineData("40.1_a", 0)]
    public void MinimumNumberFromRangeTest(string input, float expected)
    {
        Assert.Equal(expected, MinNumberFromRange(input));
    }

    [Theory]
    [InlineData("12-14", 14)]
    [InlineData("24", 24)]
    [InlineData("18-04", 18)]
    [InlineData("18-04.5", 18)]
    [InlineData("40", 40)]
    [InlineData("40a-040b", 0)]
    [InlineData("40.1_a", 0)]
    public void MaximumNumberFromRangeTest(string input, float expected)
    {
        Assert.Equal(expected, MaxNumberFromRange(input));
    }

    [Theory]
    [InlineData("Darker Than Black", "darkerthanblack")]
    [InlineData("Darker Than Black - Something", "darkerthanblacksomething")]
    [InlineData("Darker Than_Black", "darkerthanblack")]
    [InlineData("Citrus", "citrus")]
    [InlineData("Citrus+", "citrus+")]
    [InlineData("Again", "again")]
    [InlineData("카비타", "카비타")]
    [InlineData("06", "06")]
    [InlineData("", "")]
    public void NormalizeTest(string input, string expected)
    {
        Assert.Equal(expected, Normalize(input));
    }



    [Theory]
    [InlineData("test.jpg", true)]
    [InlineData("test.jpeg", true)]
    [InlineData("test.png", true)]
    [InlineData(".test.jpg", false)]
    [InlineData("!test.jpg", true)]
    [InlineData("test.webp", true)]
    [InlineData("test.gif", true)]
    public void IsImageTest(string filename, bool expected)
    {
        Assert.Equal(expected, IsImage(filename));
    }



    [Theory]
    [InlineData("Love Hina - Special.jpg", false)]
    [InlineData("folder.jpg", true)]
    [InlineData("DearS_v01_cover.jpg", true)]
    [InlineData("DearS_v01_covers.jpg", false)]
    [InlineData("!cover.jpg", true)]
    [InlineData("cover.jpg", true)]
    [InlineData("cover.png", true)]
    [InlineData("ch1/cover.png", true)]
    [InlineData("ch1/backcover.png", false)]
    [InlineData("backcover.png", false)]
    [InlineData("back_cover.png", false)]
    public void IsCoverImageTest(string inputPath, bool expected)
    {
        Assert.Equal(expected, IsCoverImage(inputPath));
    }

    [Theory]
    [InlineData("__MACOSX/Love Hina - Special.jpg", true)]
    [InlineData("TEST/Love Hina - Special.jpg", false)]
    [InlineData("__macosx/Love Hina/", false)]
    [InlineData("MACOSX/Love Hina/", false)]
    [InlineData("._Love Hina/Love Hina/", true)]
    [InlineData("@Recently-Snapshot/Love Hina/", true)]
    [InlineData("@recycle/Love Hina/", true)]
    [InlineData("E:/Test/__MACOSX/Love Hina/", true)]
    public void HasBlacklistedFolderInPathTest(string inputPath, bool expected)
    {
        Assert.Equal(expected, HasBlacklistedFolderInPath(inputPath));
    }

    [Theory]
    [InlineData("/manga/1/1/1", "/manga/1/1/1")]
    [InlineData("/manga/1/1/1.jpg", "/manga/1/1/1.jpg")]
    [InlineData(@"/manga/1/1\1.jpg", @"/manga/1/1/1.jpg")]
    [InlineData("/manga/1/1//1", "/manga/1/1/1")]
    [InlineData("/manga/1\\1\\1", "/manga/1/1/1")]
    [InlineData("C:/manga/1\\1\\1.jpg", "C:/manga/1/1/1.jpg")]
    public void NormalizePathTest(string inputPath, string expected)
    {
        Assert.Equal(expected, NormalizePath(inputPath));
    }
}