public void Asserts_Equal()
{
// Arrange
var value = Rnd.Str;
// Act
var action = () => FluentQueryHelper.AssertEqual(value, value);
// Assert
action();
}
public void Inspector_Throws_FluentQueryHelperException__Catches_And_Rethrows()
{
// Arrange
var collection = new[] { Rnd.Lng };
var inspectors = new Action <long>[] { _ => throw new EqualTypeException() };
// Act
var action = () => FluentQueryHelper.AssertCollection(collection, inspectors);
// Assert
Assert.Throws <EqualTypeException>(action);
}
public void Inspector_Throws_Exception__Catches_And_Throws_As_CollectionException()
{
// Arrange
var collection = new[] { Rnd.Lng };
var inspectors = new Action <long>[] { _ => throw new InvalidOperationException() };
// Act
var action = () => FluentQueryHelper.AssertCollection(collection, inspectors);
// Assert
Assert.Throws <CollectionException>(action);
}
public void Not_Expression__Throws_PropertyExpressionException()
{
// Arrange
// Act
var action = () => FluentQueryHelper.AssertPropertyExpression <Test, string>(Rnd.Str, Rnd.Str);
// Assert
var ex = Assert.Throws <PropertyExpressionException>(action);
Assert.Equal($"Expected a property expression but received '{typeof(string)}'.", ex.Message);
}
public async Task Asserts_ExecuteAsync()
{
// Arrange
var fluent = Create();
await fluent.ExecuteAsync(x => x.Id);
// Act
var action = (ICall c) => FluentQueryHelper.AssertExecute <TestEntity, TestId>(c, x => x.Id, false);
// Assert
fluent.AssertCalls(action);
}
public async Task Incorrect_Method__Throws_MethodNameException()
{
// Arrange
var fluent = Create();
await fluent.CountAsync();
// Act
var action = (ICall c) => FluentQueryHelper.AssertExecute <TestEntity, TestId>(c, x => x.Id, true);
// Assert
Assert.Throws <MethodNameException>(() => fluent.AssertCalls(action));
}
public async Task Incorrect_Generic_Argument__Throws_GenericArgumentException()
{
// Arrange
var fluent = Create();
await fluent.ExecuteAsync(x => x.Id);
// Act
var action = (ICall c) => FluentQueryHelper.AssertExecute <TestEntity, string>(c, nameof(TestEntity.Id), false);
// Assert
Assert.Throws <GenericArgumentException>(() => fluent.AssertCalls(action));
}
public async Task Not_Property_Expression__Throws_PropertyExpressionException()
{
// Arrange
var fluent = Create();
await fluent.ExecuteAsync <TestId>(nameof(TestEntity.Id));
// Act
var action = (ICall c) => FluentQueryHelper.AssertExecute <TestEntity, TestId>(c, x => x.Id, false);
// Assert
Assert.Throws <PropertyExpressionException>(() => fluent.AssertCalls(action));
}
public void Collection_And_Inspectors_Different_Lengths__Throws_CollectionException()
{
// Arrange
var collection = Enumerable.Repeat(Rnd.Str, Rnd.Int).ToArray();
var inspectors = Enumerable.Repeat((string _) => { }, Rnd.Int).ToArray();
// Act
var action = () => FluentQueryHelper.AssertCollection(collection, inspectors);
// Assert
Assert.Throws <CollectionException>(action);
}
public void Asserts_Equal()
{
// Arrange
var expected = nameof(Test.Foo);
Expression <Func <Test, string> > actual = x => x.Foo;
// Act
var action = () => FluentQueryHelper.AssertPropertyExpression <Test, string>(expected, actual);
// Assert
action();
}
public void Asserts_Equal()
{
// Arrange
var value = Rnd.Str;
var v0 = new { value };
var v1 = new { value };
// Act
var action = () => FluentQueryHelper.AssertEqualJson(v0, v1);
// Assert
action();
}
public void Asserts_Sort(SortOrder input)
{
// Arrange
var fluent = Create();
fluent.Sort(x => x.Id, input);
// Act
var action = (ICall c) => FluentQueryHelper.AssertSort <TestEntity, TestId>(c, x => x.Id, input);
// Assert
fluent.AssertCalls(action);
}
public void Incorrect_Method__Throws_MethodNameException()
{
// Arrange
var fluent = Create();
fluent.Maximum(Rnd.ULng);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhereNotIn <TestEntity, long>(c, x => x.Bar, new[] { Rnd.Lng, Rnd.Lng });
// Assert
Assert.Throws <MethodNameException>(() => fluent.AssertCalls(action));
}
public void Incorrect_Generic_Argument__Throws_GenericArgumentException(SortOrder input)
{
// Arrange
var fluent = Create();
fluent.Sort(x => x.Id, input);
// Act
var action = (ICall c) => FluentQueryHelper.AssertSort <TestEntity, string>(c, nameof(TestEntity.Id), input);
// Assert
Assert.Throws <GenericArgumentException>(() => fluent.AssertCalls(action));
}
public void Incorrect_Method__Throws_MethodNameException(SortOrder input)
{
// Arrange
var fluent = Create();
fluent.Skip(Rnd.ULng);
// Act
var action = (ICall c) => FluentQueryHelper.AssertSort <TestEntity, TestId>(c, x => x.Id, input);
// Assert
Assert.Throws <MethodNameException>(() => fluent.AssertCalls(action));
}
public void Incorrect_Type__Throws_EqualTypeException()
{
// Arrange
var value = Rnd.Lng;
// Act
var action = () => FluentQueryHelper.AssertEqualType(value, value.ToString());
// Assert
var ex = Assert.Throws <EqualTypeException>(action);
Assert.Equal($"Expected type '{typeof(long)}' but value was type '{typeof(string)}'.", ex.Message);
}
public async Task Asserts_ExecuteAsync__With_Transaction()
{
// Arrange
var fluent = Create();
var transaction = Substitute.For <IDbTransaction>();
await fluent.ExecuteAsync(x => x.Id, transaction);
// Act
var action = (ICall c) => FluentQueryHelper.AssertExecute <TestEntity, TestId>(c, x => x.Id, true);
// Assert
fluent.AssertCalls(action);
}
public void Asserts_WhereNotIn()
{
// Arrange
var fluent = Create();
var values = new[] { Rnd.Str, Rnd.Str };
fluent.WhereNotIn(x => x.Foo, values);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhereNotIn <TestEntity, string>(c, x => x.Foo, values);
// Assert
fluent.AssertCalls(action);
}
public void Incorrect_Generic_Argument__Throws_GenericArgumentException()
{
// Arrange
var fluent = Create();
var values = new[] { Rnd.Str, Rnd.Str };
fluent.WhereNotIn(x => x.Foo, values);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhereNotIn <TestEntity, long>(c, x => x.Bar, new[] { Rnd.Lng, Rnd.Lng });
// Assert
Assert.Throws <GenericArgumentException>(() => fluent.AssertCalls(action));
}
public void Values_Not_Equal__Throws_EqualTypeException()
{
// Arrange
var fluent = Create();
var values = new[] { Rnd.Str, Rnd.Str };
fluent.WhereNotIn(x => x.Foo, values);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhereNotIn <TestEntity, string>(c, x => x.Foo, new[] { Rnd.Str, Rnd.Str });
// Assert
Assert.Throws <EqualTypeException>(() => fluent.AssertCalls(action));
}
public void Not_Equal__Throws_EqualTypeException()
{
// Arrange
var v0 = Rnd.Str;
var v1 = Rnd.Str;
// Act
var action = () => FluentQueryHelper.AssertEqual(v0, v1);
// Assert
var ex = Assert.Throws <EqualTypeException>(action);
Assert.Equal($"Expected '{v0}' but value was '{v1}'.", ex.Message);
}
public void Not_Equal__Throws_PropertyExpressionException()
{
// Arrange
var expected = nameof(Test.Bar);
Expression <Func <Test, string> > actual = x => x.Foo;
// Act
var action = () => FluentQueryHelper.AssertPropertyExpression <Test, string>(expected, actual);
// Assert
var ex = Assert.Throws <PropertyExpressionException>(action);
Assert.Equal($"Expected property with name '{expected}' but received '{nameof(Test.Foo)}'.", ex.Message);
}
public void Same_Property_Names__Different_Values__Throws_EqualJsonException()
{
// Arrange
var v0 = new { v0 = Rnd.Str };
var v1 = new { v1 = Rnd.Str };
// Act
var action = () => FluentQueryHelper.AssertEqualJson(v0, v1);
// Assert
var ex = Assert.Throws <EqualJsonException>(action);
Assert.Equal($"Expected '{v0}' but value was '{v1}'.", ex.Message);
}
public void Clause_Not_Equal_Throws_EqualTypeException()
{
// Arrange
var fluent = Create();
var parameters = new { value = Rnd.Guid };
fluent.Where(Rnd.Str, parameters);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere(c, Rnd.Str, parameters);
// Assert
Assert.Throws <EqualTypeException>(() => fluent.AssertCalls(action));
}
public void Parameters_Not_Equal__Throws_EqualJsonException()
{
// Arrange
var fluent = Create();
var clause = Rnd.Str;
fluent.Where(clause, new { value = Rnd.Lng });
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere(c, clause, new { value = Rnd.Lng });
// Assert
Assert.Throws <EqualJsonException>(() => fluent.AssertCalls(action));
}
public void With_Property_Expression__Asserts_Where()
{
// Arrange
var fluent = Create();
var compare = Compare.Like;
var value = Rnd.Str;
fluent.Where(x => x.Foo, compare, value);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere <TestEntity, string>(c, x => x.Foo, compare, value);
// Assert
fluent.AssertCalls(action);
}
public void Incorrect_Method__Throws_MethodNameException()
{
// Arrange
var fluent = Create();
fluent.Maximum(Rnd.ULng);
// Act
var a0 = (ICall c) => FluentQueryHelper.AssertWhere <TestEntity, string>(c, x => x.Foo, Compare.Equal, Rnd.Str);
var a1 = (ICall c) => FluentQueryHelper.AssertWhere(c, Rnd.Str, Rnd.Str);
// Assert
Assert.Throws <MethodNameException>(() => fluent.AssertCalls(a0));
Assert.Throws <MethodNameException>(() => fluent.AssertCalls(a1));
}
public void With_Clause__Asserts_Where()
{
// Arrange
var fluent = Create();
var clause = Rnd.Str;
var parameters = new { value = Rnd.Lng };
fluent.Where(clause, parameters);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere(c, clause, parameters);
// Assert
fluent.AssertCalls(action);
}
public void With_Nullable_Value__Asserts_Where()
{
// Arrange
var fluent = Create();
var compare = Compare.NotEqual;
long?value = Rnd.Lng;
fluent.Where(x => x.Nll, compare, value);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere <TestEntity, long?>(c, x => x.Nll, compare, value);
// Assert
fluent.AssertCalls(action);
}
public void No_Generic_Argument__Throws_GenericArgumentException()
{
// Arrange
var fluent = Create();
var compare = Compare.Like;
var value = Rnd.Str;
fluent.Where(nameof(TestEntity.Foo), compare, value);
// Act
var action = (ICall c) => FluentQueryHelper.AssertWhere <TestEntity, string>(c, x => x.Foo, compare, value);
// Assert
Assert.Throws <GenericArgumentException>(() => fluent.AssertCalls(action));
}
