public void EquivalentTo_Matches_Same_Complex_Types()
{
var complexType = _fixture.Create <ComplexType>();
_mock.Object.DoSomething(complexType);
_mock.Verify(m => m.DoSomething(Its.EquivalentTo(complexType)));
}
public void EquivalentTo_Matches_Two_Different_Complex_Types_With_Same_Data()
{
var complexType = _fixture.Create <ComplexType>();
var expectedComplexType = complexType.Copy();
_mock.Object.DoSomething(complexType);
_mock.Verify(m => m.DoSomething(Its.EquivalentTo(expectedComplexType)));
}
protected override void DoMerge(TestModel model)
{
TestContext testContexts = model as TestContext;
if (model is TestContext)
{
Its.Merge(testContexts.Its);
}
}
public void EquivalentTo_Does_Not_Match_If_Actual_Object_Is_Null_And_Expected_Object_Has_Value()
{
var expectedComplexType = _fixture.Create <ComplexType>();
_mock.Object.DoSomething(null);
Action verify = () => _mock.Verify(m => m.DoSomething(Its.EquivalentTo(expectedComplexType)));
verify.Should().Throw <MockException>();
}
public void EquivalentTo_Does_Not_Match_Two_Complex_Types_If_Child_Property_Has_Different_Value()
{
var complexType = _fixture.Create <ComplexType>();
var expectedComplexType = complexType.Copy();
expectedComplexType.ComplexTypeProperty.IntProperty++;
_mock.Object.DoSomething(complexType);
Action verify = () => _mock.Verify(m => m.DoSomething(Its.EquivalentTo(expectedComplexType)));
verify.Should().Throw <MockException>();
}
public void EquivalentTo_Matches_Two_Complex_Types_If_Child_Property_Has_Different_Value_But_Its_Ignored()
{
var complexType = _fixture.Create <ComplexType>();
var expectedComplexType = complexType.Copy();
expectedComplexType.ComplexTypeProperty.IntProperty++;
_mock.Object.DoSomething(complexType);
_mock.Verify(m => m.DoSomething(Its.EquivalentTo(
expectedComplexType,
options => options.Excluding(c => c.ComplexTypeProperty.IntProperty)
)));
}
public void Constructor_that_takes_constructor_expression_sets_fake_object_returned_from_factory_to_FakedObject_property()
{
var foo = A.Fake <Foo>();
var serviceProviderArgument = A.Fake <IServiceProvider>();
using (Fake.CreateScope())
{
Fake.Configure(this.factory)
.CallsTo(x => x.CreateFake(typeof(Foo), Its.SameSequence(new object[] { serviceProviderArgument }), false))
.Returns(foo);
var fake = new Fake <Foo>(() => new Foo(serviceProviderArgument));
Assert.That(fake.FakedObject, Is.SameAs(foo));
}
}
public override string ToString()
{
StringBuilder st = new StringBuilder();
st.AppendLine("ORDER SUMMARY:");
st.Append("Order moment: ");
st.AppendLine(Momment.ToString("dd/MM/yyyy HH:mm:ss"));
st.Append("Order Status: " + Status);
st.Append("Client: " + Client);
st.AppendLine("Order Items:");
foreach (OrderItem Its in OrderItems)
{
st.Append(Its.Product + "," + Its.Price + ", Qunatity: " + Its.Quantity +
", SubTotal: $" + Its.SubTotal());
}
return(st.ToString());
}
public void Its_EquivalentTo_DoesNotThrowException()
{
// Given
var booMock = new Mock <IBar>();
var foo = new Foo(booMock.Object);
var fooParam = new FooParam {
Description = "test description", ReferenceNumber = 12345
};
var expectedBarParam = new BarParam {
Description = fooParam.Description, ReferenceNumber = fooParam.ReferenceNumber
};
foo.CallBoo(fooParam);
// When
booMock.Verify(b => b.ItWorked(Its.EquivalentTo(expectedBarParam)));
// Then
// No Exception thrown
}
public void Its_EquivalentTo_ThrowsException_WithMultipleSetups()
{
// Given
var booMock = new Mock <IBar>();
var foo = new Foo(booMock.Object);
var fooParam = new FooParam {
Description = "given value 1", ReferenceNumber = 12345
};
var fooParam2 = new FooParam {
Description = "given value 2", ReferenceNumber = 23456
};
var expectedBarParam = new BarParam {
Description = fooParam.Description, ReferenceNumber = fooParam.ReferenceNumber
};
var expectedBarParam2 = new BarParam {
Description = fooParam2.Description, ReferenceNumber = fooParam2.ReferenceNumber
};
var unExpectedBarParam = new BarParam {
Description = "Unexpected value"
};
booMock.Setup(b => b.ItWorked(Its.EquivalentTo(expectedBarParam, true)));
booMock.Setup(b => b.ItWorked(Its.EquivalentTo(expectedBarParam2, true)));
foo.CallBoo(fooParam);
foo.CallBoo(fooParam2);
// When
booMock.Verify(b => b.ItWorked(Its.EquivalentTo(expectedBarParam, true)), Times.Once);
booMock.Verify(b => b.ItWorked(Its.EquivalentTo(expectedBarParam2, true)), Times.Once);
// and When Then
var testException = Assert.Throws <MockException>(() =>
booMock.Verify(b => b.ItWorked(Its.EquivalentTo(unExpectedBarParam, true)), Times.Once)
);
Assert.StartsWith("Expected invocation on the mock once, but was 0 times", testException.Message.Trim());
}
public void Constructor_that_takes_arguments_for_constructor_should_set_fake_returned_from_factory_to_FakedObject_property()
{
var argumentsForConstructor = new object[] { A.Fake <IFoo>() };
var fakeReturnedFromFactory = A.Fake <AbstractTypeWithNoDefaultConstructor>(argumentsForConstructor);
using (Fake.CreateScope())
{
Fake.Configure(this.factory)
.CallsTo(x => x.CreateFake(typeof(AbstractTypeWithNoDefaultConstructor), Its.SameSequence(argumentsForConstructor), false))
.Returns(fakeReturnedFromFactory);
var fake = new Fake <AbstractTypeWithNoDefaultConstructor>(argumentsForConstructor);
Assert.That(fake.FakedObject, Is.SameAs(fakeReturnedFromFactory));
}
}
public void EquivalentTo_Matches_If_Actual_And_Expected_Are_Null()
{
_mock.Object.DoSomething(null);
_mock.Verify(m => m.DoSomething(Its.EquivalentTo <ComplexType>(null)));
}
public void Its_EquivalentTo_ThrowsAssertionExcpetion()
{
// Given
var booMock = new Mock <IBar>();
var foo = new Foo(booMock.Object);
var expectedBarParam = new BarParam {
Description = "expected description", ReferenceNumber = 12345
};
var barParam = new BarParam {
Description = "actual description", ReferenceNumber = 54321
};
foo.CallBoo(barParam);
// When
var testException = Assert.Throws <XunitException>(() =>
booMock.Verify(b => b.ItWorked(Its.EquivalentTo(expectedBarParam)))
);
// Then
var expectedStartOfException =
$"Expected member {nameof(expectedBarParam.Description)} to be {Environment.NewLine}\"{expectedBarParam.Description}\" with a length of {expectedBarParam.Description.Length}, "
+ $"but {Environment.NewLine}\"{barParam.Description}\" has a length of {barParam.Description.Length}."
+ $"{Environment.NewLine}Expected member {nameof(expectedBarParam.ReferenceNumber)} to be {expectedBarParam.ReferenceNumber}, "
+ $"but found {barParam.ReferenceNumber}.";
Assert.StartsWith(expectedStartOfException, testException.Message);
}
