GuardAgainstOutOfRangeForEnumerableLong.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Ardalis.GuardClauses;
using Xunit;

namespace GuardClauses.UnitTests;

public class GuardAgainstOutOfRangeForEnumerableLong
{
    [Theory]
    [ClassData(typeof(CorrectClassData))]
    public void DoesNothingGivenInRangeValue(IEnumerable<long> input, long rangeFrom, long rangeTo)
    {
        Guard.Against.OutOfRange(input, nameof(input), rangeFrom, rangeTo);
    }

    [Theory]
    [ClassData(typeof(IncorrectClassData))]
    public void ThrowsGivenOutOfRangeValue(IEnumerable<long> input, long rangeFrom, long rangeTo)
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => Guard.Against.OutOfRange(input, nameof(input), rangeFrom, rangeTo));
    }

    [Theory]
    [ClassData(typeof(IncorrectClassData))]
    public void ThrowsCustomExceptionWhenSuppliedGivenOutOfRangeValue(IEnumerable<long> input, long rangeFrom, long rangeTo)
    {
        Exception customException = new Exception();
        Assert.Throws<Exception>(() => Guard.Against.OutOfRange(input, nameof(input), rangeFrom, rangeTo, 
            exceptionCreator: () => customException));
    }

    [Theory]
    [ClassData(typeof(IncorrectRangeClassData))]
    public void ThrowsGivenInvalidArgumentValue(IEnumerable<long> input, long rangeFrom, long rangeTo)
    {
        Assert.Throws<ArgumentException>(() => Guard.Against.OutOfRange(input, nameof(input), rangeFrom, rangeTo));
    }

    [Theory]
    [ClassData(typeof(CorrectClassData))]
    public void ReturnsExpectedValueGivenInRangeValue(IEnumerable<long> input, long rangeFrom, long rangeTo)
    {
        var result = Guard.Against.OutOfRange(input, nameof(input), rangeFrom, rangeTo);
        Assert.Equal(input, result);
    }

    [Theory]
    [InlineData(null, "rangeFrom should be less or equal than rangeTo (Parameter 'parameterName')")]
    [InlineData("Timespan range", "Timespan range (Parameter 'parameterName')")]
    public void ErrorMessageMatchesExpectedWhenRangeIsInvalid(string? customMessage, string? expectedMessage)
    {
        var input = new long[] { 0, 1, 99 };
        long rangeFrom = 2;
        long rangeTo = 1;

        var exception = Assert.Throws<ArgumentException>(() => Guard.Against.OutOfRange(input, "parameterName", rangeFrom, rangeTo, customMessage));
        Assert.NotNull(exception);
        Assert.NotNull(exception.Message);
        Assert.Equal(expectedMessage, exception.Message);
    }

    [Theory]
    [InlineData(null, null)]
    [InlineData(null, "Please provide correct value")]
    [InlineData("SomeParameter", null)]
    [InlineData("SomeOtherParameter", "Value must be correct")]
    public void ExceptionParamNameMatchesExpectedRangeIsInvalid(string? expectedParamName, string? customMessage)
    {
        var input = new long[] { 0, 1, 99 };
        long rangeFrom = 2;
        long rangeTo = 1;

        var exception = Assert.Throws<ArgumentException>(() => Guard.Against.OutOfRange(input, expectedParamName!, rangeFrom, rangeTo, customMessage));
        Assert.NotNull(exception);
        Assert.Equal(expectedParamName, exception.ParamName);
    }

    [Theory]
    [InlineData(null, "Input parameterName had out of range item(s) (Parameter 'parameterName')")]
    [InlineData("Timespan range", "Timespan range (Parameter 'parameterName')")]
    public void ErrorMessageMatchesExpectedWhenInputIsInvalid(string? customMessage, string? expectedMessage)
    {
        var input = new long[] { 0, 1, 99 };
        long rangeFrom = 0;
        long rangeTo = 1;

        var exception = Assert.Throws<ArgumentOutOfRangeException>(() => Guard.Against.OutOfRange(input, "parameterName", rangeFrom, rangeTo, customMessage));
        Assert.NotNull(exception);
        Assert.NotNull(exception.Message);
        Assert.Equal(expectedMessage, exception.Message);
    }

    [Theory]
    [InlineData(null, null)]
    [InlineData(null, "Please provide correct value")]
    [InlineData("SomeParameter", null)]
    [InlineData("SomeOtherParameter", "Value must be correct")]
    public void ExceptionParamNameMatchesExpectedInputIsInvalid(string? expectedParamName, string? customMessage)
    {
        var input = new long[] { 0, 1, 99 };
        long rangeFrom = 0;
        long rangeTo = 1;

        var exception = Assert.Throws<ArgumentOutOfRangeException>(() => 
            Guard.Against.OutOfRange(input, expectedParamName!, rangeFrom, rangeTo, customMessage));
        Assert.NotNull(exception);
        Assert.Equal(expectedParamName, exception.ParamName);
    }

    public class CorrectClassData : IEnumerable<object[]>
    {
        public IEnumerator<object[]> GetEnumerator()
        {
            yield return new object[] { new List<long> { long.MaxValue, 1200, long.MinValue }, long.MinValue, long.MaxValue };
            yield return new object[] { new List<long> { 1100000, 2000, 120, 180000 }, 100, 1200000 };
            yield return new object[] { new List<long> { 18, 128, 108 }, 0, 200 };
        }
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }

    public class IncorrectClassData : IEnumerable<object[]>
    {
        public IEnumerator<object[]> GetEnumerator()
        {
            yield return new object[] { new List<long> { 10, 12, 1500 }, 10, 1200 };
            yield return new object[] { new List<long> { 1000, 200, 120, 180000 }, 100, 150000 };
            yield return new object[] { new List<long> { 15, 120, 158 }, 10, 110 };
        }
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }

    public class IncorrectRangeClassData : IEnumerable<object[]>
    {
        public IEnumerator<object[]> GetEnumerator()
        {
            yield return new object[] { new List<long> { 10000, 1200, 15 }, 10000, 10 };
            yield return new object[] { new List<long> { 100010, 200, 120000, 180 }, 2000000, 150 };
            yield return new object[] { new List<long> { 52000, 86, 2500000 }, 20000000, 100 };
        }
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
}