internal static IStringAssertion DoesNotEndWith(this StringAssertion source, string text)
{
source.Extend(x => AssertResult.New(!x.EndsWith(text, StringComparison.CurrentCultureIgnoreCase),
Resources.DoesNotEndWith, text));
return(source);
}
public IMixedTypeAssertion <T, U> IsEqualTo <S>(S comparedTo)
{
Extend((x, t) =>
{
if (t == typeof(U))
{
if (_newType == null)
{
return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo));
}
return(AssertResult.New(_newType.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString()));
}
else
{
if (x == null)
{
return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo));
}
return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString()));
}
});
return(this);
}
public IClassAssertion <T> PropertyValuesMatch <S>(S item, bool throwExceptionOnPropertyMismatch = false, string[] ignoreProperties = null)
{
Extend(x =>
{
return(AssertResult.New(PropertiesMatch(x, item, throwExceptionOnPropertyMismatch: throwExceptionOnPropertyMismatch, ignoreProperties: ignoreProperties), "Property values do not match"));
});
return(this);
}
public IClassAssertion <T> PropertyValuesDoNotMatch <S>(S item, bool throwExceptionOnPropertyMismatch = false, Func <string, object, object, bool> propertyChanged = null, string[] ignoreProperties = null)
{
Extend(x =>
{
return(AssertResult.New(!PropertiesMatch(x, item, throwExceptionOnPropertyMismatch: throwExceptionOnPropertyMismatch, propertyChanged: propertyChanged, ignoreProperties: ignoreProperties), "Property values match"));
});
return(this);
}
public IClassAssertion <T> PropertyValuesDoNotMatch <S>(S item, Func <string, object, object, bool> propertyChanged = null)
{
Extend(x =>
{
return(AssertResult.New(!PropertiesMatch(x, item, propertyChanged), "Property values match"));
});
return(this);
}
public IClassAssertion <T> PropertyValuesMatch <S>(S item)
{
Extend(x =>
{
return(AssertResult.New(PropertiesMatch(x, item), "Property values do not match"));
});
return(this);
}
private static IStringAssertion IsValidISBN10(this IStringAssertionU source)
{
source.Extend(x =>
{
return(AssertResult.New(ValidIsbn10(x), Resources.IsValidISBN));
});
return((IStringAssertion)source);
}
public IDictionaryAssertion <T1, T2> ContainsKey(T1 key)
{
Extend(x => {
return(AssertResult.New(x.ContainsKey(key), Resources.ContainsKey, key));
});
return(this);
}
public static IStringAssertion IsValidPersonalNumber(this IStringAssertionU source)
{
source.Extend(x =>
{
return(AssertResult.New(Luhn.IsValid(x.ToIntArray()), Resources.IsValidPersonalNumber));
});
return((IStringAssertion)source);
}
public static IStringAssertion IsNotValidImoNr(this IStringAssertionU source)
{
source.Extend(x =>
{
return(AssertResult.New(!ImoValidator.IsValid(x), Resources.IsNotValidImoNr));
});
return((IStringAssertion)source);
}
public INumberAssertion <T> IsNotWithin(T min, T max)
{
Extend(x =>
{
dynamic d = x;
return(AssertResult.New(d < min || d > max, Resources.IsNotWithin, min, max));
});
return(this);
}
internal static EnumerableAssertion ContainsMoreThan(this EnumerableAssertion source, int nElements)
{
source.Extend(x =>
{
var count = GetCount(x);
return(AssertResult.New(count > nElements, Resources.ContainsMoreThan, nElements));
});
return(source);
}
internal static EnumerableAssertion IsEmpty(this EnumerableAssertion source)
{
source.Extend(x =>
{
var c = GetCount(x);
return(AssertResult.New(c == 0, Resources.IsEmpty));
});
return(source);
}
public IDateTimeAssertion SameMinuteAs(DateTime date)
{
Extend(x =>
{
var diff = (Item - date).TotalMinutes;
return(AssertResult.New(diff >= 0 && diff <= 1.0, Resources.SameMinuteAs, date.ToString("yyyy-MM-dd HH:mm")));
});
return(this);
}
internal static StringAssertion DoesNotContainDigit(this StringAssertion source)
{
source.Extend(x =>
{
bool isValid = Regex.IsMatch(x, @"\d");
return(AssertResult.New(!isValid, Resources.DoesNotContainDigit));
});
return(source);
}
public IDateTimeAssertion SameYearAs(DateTime date)
{
Extend(x =>
{
var sameYear = x.Date.Year == date.Year;
return(AssertResult.New(sameYear, Resources.SameYearAs, date.ToString("yyyy")));
});
return(this);
}
public static IStringAssertion IsValidSocialSecurityNumber(this IStringAssertionU source)
{
source.Extend(x =>
{
var isValid = Regex.IsMatch(x, _regex);
return(AssertResult.New(isValid, Resources.IsValidSocialSecurityNumber));
});
return((IStringAssertion)source);
}
public static IStringAssertion IsValidZipCode(this IStringAssertionU source)
{
source.Extend(x =>
{
var isValid = Regex.IsMatch(x, _regex);
return(AssertResult.New(isValid, Resources.IsValidZipCode));
});
return((IStringAssertion)source);
}
public IEnumerableAssertion <T> ContainsLessThan(int nElements)
{
Extend(x =>
{
var count = x.Count();
return(AssertResult.New(count < nElements, Resources.ContainsLessThan, nElements));
});
return(this);
}
public IDateTimeAssertion IsWithin(DateTime min, DateTime max)
{
Extend(x =>
{
dynamic d = x;
return(AssertResult.New(d >= min && d <= max, Resources.IsWithin, min, max));
});
return(this);
}
public IDateTimeAssertion IsNotWithin(DateTime min, DateTime max)
{
Extend(x =>
{
dynamic d = Item;
return(AssertResult.New(d < min || d > max, Resources.IsNotWithin, min, max));
});
return(this);
}
public IDateTimeAssertion NotSameSecondAs(DateTime date)
{
Extend(x =>
{
var diff = (x - date).TotalSeconds;
return(AssertResult.New(diff < 0 || diff > 1.0, Resources.NotSameSecondAs, date.ToString("yyyy-MM-dd HH:mm:ss")));
});
return(this);
}
public IStringAssertion DoesNotMatch(string regex, RegexOptions options = RegexOptions.None)
{
Extend(x =>
{
_previousMatch = Regex.Match(x, regex, options);
return(AssertResult.New(!_previousMatch.Success, Resources.DoesNotMatch, regex));
});
return(this);
}
public static IStringAssertion IsNotValidPhoneNumber(this IStringAssertionU source)
{
source.Extend(x =>
{
var isValid = Regex.IsMatch(x, _regex);
return(AssertResult.New(!isValid, Resources.IsNotValidPhoneNumber));
});
return((IStringAssertion)source);
}
public IEnumerableAssertion <T> Contains(params T[] items)
{
Extend(x =>
{
var containsItems = items.All(y => x.Contains(y));
return(AssertResult.New(containsItems, Resources.ContainsItems, String.Join(",", items.Select(y => y.ToString()).ToArray())));
});
return(this);
}
public IDateTimeAssertion NotSameMonthAs(DateTime date)
{
Extend(x =>
{
var sameYear = x.Date.Year == date.Year;
var sameMonth = x.Date.Month == date.Month;
return(AssertResult.New(!(sameYear && sameMonth), Resources.NotSameMonthAs, date.ToString("yyyy-MM")));
});
return(this);
}
internal static IAssertion <T> IsEqualTo <T>(this Assertion <T> source, T comparedTo)
{
source.Extend(x =>
{
if (x == null)
{
return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo));
}
return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString()));
});
return(source);
}
public IClassAssertion <T> IsNotPartOf(IEnumerable <T> enumerable)
{
Extend(x =>
{
if (enumerable == null || x == null)
{
return(AssertResult.New(true, Resources.IsNotPartOf));
}
return(AssertResult.New(!enumerable.Contains(x), Resources.IsNotPartOf));
});
return(this);
}
public IClassAssertion <T> IsEqualTo <S>(S comparedTo)
{
Extend(x =>
{
if (x == null)
{
return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo));
}
return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString()));
});
return(this);
}
internal static StringAssertion IsNotValidEmail(this StringAssertion source)
{
source.Extend(x =>
{
//bool isEmail = Regex.IsMatch(x, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z");
RegexHelper helper = new RegexHelper();
var isEmail = helper.IsValidEmail(x);
return(AssertResult.New(string.IsNullOrWhiteSpace(x) || !isEmail, Resources.IsNotValidEmail));
});
return(source);
}