CollectionHumanizeTests.cs

public class SomeClass
{
    public string? SomeString;
    public int SomeInt;
    public override string ToString() =>
        "ToString";
}

[UseCulture("en")]
public class CollectionHumanizeTests
{
    static readonly object?[] NullObjects = [null, null];
    static readonly int[] CollectionPair = [1, 2];
    static readonly int[] CollectionTriple = [1, 2, 3];
    static readonly string[] ThreeStrings = ["A", "B", "C"];
    static readonly int?[] NullableInts = [1, null, 3];
    static readonly string[] StringsWithEmptyItem = ["A", " ", "C"];
    static readonly string[] StringsWithWhitespace = ["A", "  B  ", "C"];

    [Fact]
    public void HumanizeReturnsOnlyNameWhenCollectionContainsOneItem()
    {
        var collection = new List<string> { "A String" };

        Assert.Equal("A String", collection.Humanize());
    }

    [Fact]
    public void HumanizeUsesSeparatorWhenMoreThanOneItemIsInCollection()
    {
        var collection = new List<string>
        {
            "A String",
            "Another String",
        };

        Assert.Equal("A String or Another String", collection.Humanize("or"));
    }

    [Fact]
    public void HumanizeDefaultsSeparatorToAnd()
    {
        var collection = new List<string>
        {
            "A String",
            "Another String",
        };

        Assert.Equal("A String and Another String", collection.Humanize());
    }

    [Fact]
    public void HumanizeUsesSpecifiedCulture() =>
        Assert.Equal("A, B and C", ThreeStrings.Humanize(new CultureInfo("en-GB")));

    [Theory]
    [MemberData(
        nameof(Humanizer.Tests.Localisation.LocaleCoverageData.CollectionFormatterExpectationTheoryData),
        MemberType = typeof(Humanizer.Tests.Localisation.LocaleCoverageData))]
    public void HumanizeUsesSpecifiedCultureForEverySupportedLocale(string localeName, string expectedTwo, string expectedThree)
    {
        var culture = new CultureInfo(localeName);

        Assert.Equal(expectedTwo, CollectionPair.Humanize(culture));
        Assert.Equal(expectedThree, CollectionTriple.Humanize(culture));
    }

    [Fact]
    public void HumanizeThrowsWhenCultureIsNull()
    {
        var exception = Assert.Throws<ArgumentNullException>(() => ThreeStrings.Humanize((CultureInfo)null!));

        Assert.Equal("culture", exception.ParamName);
    }

    [Fact]
    public void HumanizeUsesOxfordComma()
    {
        var collection = new List<string>
        {
            "A String",
            "Another String",
            "A Third String",
        };

        Assert.Equal("A String, Another String, or A Third String", collection.Humanize("or"));
    }

    readonly List<SomeClass> testCollection =
    [
        new() { SomeInt = 1, SomeString = "One" },
        new() { SomeInt = 2, SomeString = "Two" },
        new() { SomeInt = 3, SomeString = "Three" }
    ];

    [Fact]
    public void HumanizeDefaultsToToString() =>
        Assert.Equal("ToString, ToString, or ToString", testCollection.Humanize("or"));

    [Fact]
    public void HumanizeUsesStringDisplayFormatter()
    {
        var humanized = testCollection.Humanize(sc => $"SomeObject #{sc.SomeInt} - {sc.SomeString}");
        Assert.Equal("SomeObject #1 - One, SomeObject #2 - Two, and SomeObject #3 - Three", humanized);
    }

    [Fact]
    public void HumanizeUsesObjectDisplayFormatter()
    {
        var humanized = testCollection.Humanize(sc => sc.SomeInt);
        Assert.Equal("1, 2, and 3", humanized);
    }

    [Fact]
    public void HumanizeUsesStringDisplayFormatterWhenSeparatorIsProvided()
    {
        var humanized = testCollection.Humanize(sc => $"SomeObject #{sc.SomeInt} - {sc.SomeString}", "or");
        Assert.Equal("SomeObject #1 - One, SomeObject #2 - Two, or SomeObject #3 - Three", humanized);
    }

    [Fact]
    public void HumanizeUsesObjectDisplayFormatterWhenSeparatorIsProvided()
    {
        var humanized = testCollection.Humanize(sc => sc.SomeInt, "or");
        Assert.Equal("1, 2, or 3", humanized);
    }

    [Fact]
    public void HumanizeHandlesNullItemsWithoutAnException() =>
        Assert.Null(Record.Exception(() => NullObjects.Humanize()));

    [Fact]
    public void HumanizeHandlesNullStringDisplayFormatterReturnsWithoutAnException() =>
        Assert.Null(Record.Exception(() => ThreeStrings.Humanize(_ => null!)));

    [Fact]
    public void HumanizeHandlesNullObjectDisplayFormatterReturnsWithoutAnException() =>
        Assert.Null(Record.Exception(() => ThreeStrings.Humanize(_ => (object)null!)));

    [Fact]
    public void HumanizeRunsStringDisplayFormatterOnNulls() =>
        Assert.Equal("1, (null), and 3", NullableInts.Humanize(_ => _?.ToString() ?? "(null)"));

    [Fact]
    public void HumanizeRunsObjectDisplayFormatterOnNulls() =>
        Assert.Equal("1, 2, and 3", NullableInts.Humanize(_ => _ ?? 2));

    [Fact]
    public void HumanizeRemovesEmptyItemsByDefault() =>
        Assert.Equal("A and C", StringsWithEmptyItem.Humanize(DummyFormatter));

    [Fact]
    public void HumanizeTrimsItemsByDefault() =>
        Assert.Equal("A, B, and C", StringsWithWhitespace.Humanize(DummyFormatter));

    /// <summary>
    /// Use the dummy formatter to ensure tests are testing formatter output rather than input
    /// </summary>
    static readonly Func<string, string> DummyFormatter = input => input;
}