private static Expectation <string> BeLike(IExpectationComposer composer, string pattern, RegexOptions options, string format)
{
var regexPattern = "^" + Regex.Escape(pattern).Replace("\\?", ".").Replace("\\*", ".*").Replace("\\#", "\\d") + "$";
var regex = new Regex(regexPattern, options);
return(composer.ComposeSimple <string>(formatter => format, value => value != null && regex.IsMatch(value)));
}
/// <summary>
/// Creates expectation for comparable types to be less or equal value specified by <paramref name="value"/>, where the value cannot be null.
/// </summary>
/// <param name="composer">Composer</param>
/// <param name="value">Value</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> parameter value is null.</exception>
public static Expectation <T> BeLessOrEqual <T>(this IExpectationComposer composer, T value) where T : IComparable <T>
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(composer.ComposeSimple <T>(formatter => $"less or equal '{formatter.FormatValue(value)}'", x => x != null && x.CompareTo(value) <= 0));
}
/// <summary>
/// Creates expectation for comparable types to be greater than value specified by <paramref name="value"/>, where the value cannot be null.
/// </summary>
/// <param name="composer">Composer</param>
/// <param name="value">Value</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> parameter value is null.</exception>
public static Expectation <T> BeGreaterThan <T>(this IExpectationComposer composer, T value) where T : IComparable <T>
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(composer.ComposeSimple <T>(formatter => $"greater than '{formatter.FormatValue(value)}'", x => x != null && x.CompareTo(value) > 0));
}
/// <summary>
/// Creates expectation for comparable types to be between values specified by <paramref name="a"/> and <paramref name="b"/> parameters, where parameter values are not included.
/// The <paramref name="a"/> parameter value may be greater or lower than value of <paramref name="b"/> - both scenarios are supported.
/// None of the provided parameters can be null.
/// </summary>
/// <param name="composer">Composer</param>
/// <param name="a">Parameter A.</param>
/// <param name="b">Parameter B.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="a"/> or <paramref name="b"/> is null.</exception>
public static Expectation <T> BeBetween <T>(this IExpectationComposer composer, T a, T b) where T : IComparable <T>
{
if (a == null)
{
throw new ArgumentNullException(nameof(a));
}
if (b == null)
{
throw new ArgumentNullException(nameof(b));
}
return(composer.ComposeSimple <T>(formatter => $"between '{formatter.FormatValue(a)}' and '{formatter.FormatValue(b)}'", x => x != null && Math.Abs(x.CompareTo(a) + x.CompareTo(b)) < 2));
}
/// <summary>
/// Creates expectation for collections to contain value specified by <paramref name="value"/> parameter.
/// </summary>
/// <typeparam name="T">Expectation value type</typeparam>
/// <param name="composer">Composer</param>
/// <param name="value">Expected value</param>
public static Expectation <IEnumerable <T> > Contain <T>(this IExpectationComposer composer, T value)
{
return(composer.ComposeSimple <IEnumerable <T> >(
formatter => $"contains '{formatter.FormatValue(value)}'",
x => x != null && x.Contains(value)));
}
/// <summary>
/// Creates expectation for values to be equal one of values in <paramref name="expectedCollection"/>.
/// </summary>
/// <typeparam name="T">Expectation value type</typeparam>
/// <param name="composer">Composer</param>
/// <param name="expectedCollection">Collection of expected values</param>
public static Expectation <T> BeIn <T>(this IExpectationComposer composer, params T[] expectedCollection)
{
return(composer.ComposeSimple <T>(
formatter => $"in '{formatter.FormatValue(expectedCollection)}'",
expectedCollection.Contains));
}
/// <summary>
/// Creates expectation for values to be equal to <paramref name="expected"/> value.
/// </summary>
/// <typeparam name="T">Expectation value type</typeparam>
/// <param name="composer">Composer</param>
/// <param name="expected">Expected value</param>
public static Expectation <T> Equal <T>(this IExpectationComposer composer, T expected)
{
return(composer.ComposeSimple <T>(
formatter => $"equals '{formatter.FormatValue(expected)}'",
x => Equals(x, expected)));
}
/// <summary>
/// Creates expectation for collections to be empty.
/// </summary>
/// <param name="builder"></param>
public static Expectation <T> BeEmpty <T>(this IExpectationComposer builder) where T : IEnumerable
{
return(builder.ComposeSimple <T>(formatter => "empty", x => x != null && !x.Cast <object>().Any()));
}
/// <summary>
/// Creates expectation for values to be null.
/// </summary>
/// <param name="builder"></param>
public static Expectation <T> BeNull <T>(this IExpectationComposer builder) where T : class
{
return(builder.ComposeSimple <T>(formatter => "null", x => x == null));
}
/// <summary>
/// Creates expectation for values to be null.
/// </summary>
/// <param name="builder"></param>
public static Expectation <object> BeNull(this IExpectationComposer builder)
{
return(builder.ComposeSimple <object>(formatter => "null", x => x == null));
}
private static Expectation <string> Match(IExpectationComposer composer, string pattern, RegexOptions options, string format)
{
var regex = new Regex($"^{pattern}$", options);
return(composer.ComposeSimple(formatter => format, (string value) => value != null && regex.IsMatch(value)));
}