public void AddToOneToManyRelationWithOldRelatedObject()
{
DomainObjectCollection preloadedOrderItemsOfOrder1 = _order1.OrderItems;
preloadedOrderItemsOfOrder1.EnsureDataComplete();
OrderItem newOrderItem = DomainObjectIDs.OrderItem3.GetObject <OrderItem>();
Order oldOrderOfNewOrderItem = newOrderItem.Order;
oldOrderOfNewOrderItem.EnsureDataAvailable();
_mockRepository.BackToRecord(_extension);
var newOrderItemEventReceiver = _mockRepository.StrictMock <DomainObjectMockEventReceiver> (newOrderItem);
var oldOrderOfNewOrderItemEventReceiver = _mockRepository.StrictMock <DomainObjectMockEventReceiver> (oldOrderOfNewOrderItem);
using (_mockRepository.Ordered())
{
_extension.RelationReading(
TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), ValueAccess.Current);
_extension.RelationRead(null, null, null, (ReadOnlyDomainObjectCollectionAdapter <DomainObject>)null, ValueAccess.Current);
LastCall.Constraints(
Is.Same(TestableClientTransaction),
Is.Same(_order1),
Is.Equal(GetEndPointDefinition(typeof(Order), "OrderItems")),
Property.Value("Count", preloadedOrderItemsOfOrder1.Count) & new ContainsConstraint(preloadedOrderItemsOfOrder1),
Is.Equal(ValueAccess.Current));
_extension.RelationChanging(
TestableClientTransaction, newOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), oldOrderOfNewOrderItem, _order1);
newOrderItemEventReceiver.RelationChanging(GetEndPointDefinition(typeof(OrderItem), "Order"), oldOrderOfNewOrderItem, _order1);
_extension.RelationChanging(
TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), null, newOrderItem);
_order1EventReceiver.RelationChanging(GetEndPointDefinition(typeof(Order), "OrderItems"), null, newOrderItem);
_extension.RelationChanging(
TestableClientTransaction, oldOrderOfNewOrderItem, GetEndPointDefinition(typeof(Order), "OrderItems"), newOrderItem, null);
oldOrderOfNewOrderItemEventReceiver.RelationChanging(GetEndPointDefinition(typeof(Order), "OrderItems"), newOrderItem, null);
oldOrderOfNewOrderItemEventReceiver.RelationChanged(GetEndPointDefinition(typeof(Order), "OrderItems"), newOrderItem, null);
_extension.RelationChanged(
TestableClientTransaction, oldOrderOfNewOrderItem, GetEndPointDefinition(typeof(Order), "OrderItems"), newOrderItem, null);
_order1EventReceiver.RelationChanged(GetEndPointDefinition(typeof(Order), "OrderItems"), null, newOrderItem);
_extension.RelationChanged(TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), null, newOrderItem);
newOrderItemEventReceiver.RelationChanged(GetEndPointDefinition(typeof(OrderItem), "Order"), oldOrderOfNewOrderItem, _order1);
_extension.RelationChanged(TestableClientTransaction, newOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), oldOrderOfNewOrderItem, _order1);
}
_mockRepository.ReplayAll();
_order1.OrderItems.Add(newOrderItem);
_mockRepository.VerifyAll();
}
public void ReplaceInOneToManyRelation()
{
Assert.Greater(_order1.OrderItems.Count, 0);
OrderItem oldOrderItem = _order1.OrderItems[0];
DomainObjectCollection preloadedOrderItems = _order1.OrderItems;
OrderItem newOrderItem = OrderItem.NewObject();
_mockRepository.BackToRecord(_extension);
var oldOrderItemEventReceiver = _mockRepository.StrictMock <DomainObjectMockEventReceiver> (oldOrderItem);
var newOrderItemEventReceiver = _mockRepository.StrictMock <DomainObjectMockEventReceiver> (newOrderItem);
using (_mockRepository.Ordered())
{
_extension.RelationReading(
TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), ValueAccess.Current);
_extension.RelationRead(null, null, null, (ReadOnlyDomainObjectCollectionAdapter <DomainObject>)null, ValueAccess.Current);
LastCall.Constraints(
Is.Same(TestableClientTransaction),
Is.Same(_order1),
Is.Equal(GetEndPointDefinition(typeof(Order), "OrderItems")),
Property.Value("Count", preloadedOrderItems.Count) & new ContainsConstraint(preloadedOrderItems),
Is.Equal(ValueAccess.Current));
_extension.RelationChanging(
TestableClientTransaction, oldOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), _order1, null);
oldOrderItemEventReceiver.RelationChanging(GetEndPointDefinition(typeof(OrderItem), "Order"), _order1, null);
_extension.RelationChanging(
TestableClientTransaction, newOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), null, _order1);
newOrderItemEventReceiver.RelationChanging(GetEndPointDefinition(typeof(OrderItem), "Order"), null, _order1);
_extension.RelationChanging(
TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), oldOrderItem, newOrderItem);
_order1EventReceiver.RelationChanging(GetEndPointDefinition(typeof(Order), "OrderItems"), oldOrderItem, newOrderItem);
_order1EventReceiver.RelationChanged(GetEndPointDefinition(typeof(Order), "OrderItems"), oldOrderItem, newOrderItem);
_extension.RelationChanged(TestableClientTransaction, _order1, GetEndPointDefinition(typeof(Order), "OrderItems"), oldOrderItem, newOrderItem);
newOrderItemEventReceiver.RelationChanged(GetEndPointDefinition(typeof(OrderItem), "Order"), null, _order1);
_extension.RelationChanged(TestableClientTransaction, newOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), null, _order1);
oldOrderItemEventReceiver.RelationChanged(GetEndPointDefinition(typeof(OrderItem), "Order"), _order1, null);
_extension.RelationChanged(TestableClientTransaction, oldOrderItem, GetEndPointDefinition(typeof(OrderItem), "Order"), _order1, null);
}
_mockRepository.ReplayAll();
_order1.OrderItems[0] = newOrderItem;
_mockRepository.VerifyAll();
}
protected override void beforeEach()
{
suite = new Suite("the suite");
test = new Test("test 1");
suite.AddTest(test);
Services.Inject(suite);
driver = MockRepository.GenerateMock <ITestLineDriver>();
MockFor <ISuiteView>().Expect(x => x.AddTest(test, null)).Constraints(Is.Equal(test), Is.Anything()).Return(
driver);
ClassUnderTest.Activate(null);
}
private IControlFactory SetupControlFactoryMockWithExpectationWithDelegate(
MockRepository mockRepository, string message, string title,
MessageBoxIcon messageBoxIcon, DialogResult dialogResultToReturn,
ConfirmationDelegate confirmationDelegate)
{
IControlFactory controlFactory = mockRepository.StrictMock <IControlFactory>();
controlFactory.Expect(
factory => factory.ShowMessageBox(null, null, MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Asterisk, null))
.Return(dialogResultToReturn).Constraints(
Is.Equal(message), Is.Equal(title), Is.Equal(MessageBoxButtons.YesNo),
Is.Equal(messageBoxIcon), Is.Anything())
.WhenCalled(invocation => confirmationDelegate(dialogResultToReturn == DialogResult.Yes));
return(controlFactory);
}
public void run_the_tests()
{
ClassUnderTest.RunAllTests();
MockFor <IFileSystem>().AssertWasCalled(x => x.DeleteFolder(setup.ResultsFolder));
MockFor <IFileSystem>().AssertWasCalled(x => x.CreateFolder(setup.ResultsFolder));
MockFor <IResultsSummary>().AssertWasCalled(x => x.Start(null, DateTime.Now),
o =>
{
o.Constraints(Is.Equal("All Tests in the directory"),
Is.TypeOf <DateTime>());
});
MockFor <ITestRunner>().AssertWasCalled(x => x.RunTests(tests, ClassUnderTest));
MockFor <IResultsSummary>().AssertWasCalled(x => x.WriteFile(setup.ResultsFile));
}
public void Test_DeleteBusinessObject_ConfirmationMessage()
{
//---------------Set up test pack-------------------
MockRepository mockRepository = new MockRepository();
string boToString = TestUtil.GetRandomString();
string expectedMessage = string.Format("Are you certain you want to delete the object '{0}'", boToString);
IConfirmer confirmer = CreateMockConfirmerWithExpectation(mockRepository,
Is.Equal(expectedMessage), false);
IBusinessObject boToDelete = new MockBOWithToString(boToString);
ConfirmingBusinessObjectDeletor confirmingBusinessObjectDeletor = new ConfirmingBusinessObjectDeletor(confirmer);
mockRepository.ReplayAll();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
confirmingBusinessObjectDeletor.DeleteBusinessObject(boToDelete);
//---------------Test Result -----------------------
mockRepository.VerifyAll();
}
public void Test_DeleteBusinessObject_CustomConfirmationMessage()
{
//---------------Set up test pack-------------------
MockRepository mockRepository = new MockRepository();
string expectedMessage = TestUtil.GetRandomString();
IConfirmer confirmer = CreateMockConfirmerWithExpectation(mockRepository,
Is.Equal(expectedMessage), false);
IBusinessObject boToDelete = mockRepository.StrictMock <IBusinessObject>();
ConfirmingBusinessObjectDeletor confirmingBusinessObjectDeletor =
new ConfirmingBusinessObjectDeletor(confirmer, t => expectedMessage);
mockRepository.ReplayAll();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
confirmingBusinessObjectDeletor.DeleteBusinessObject(boToDelete);
//---------------Test Result -----------------------
mockRepository.VerifyAll();
}
protected override void beforeEach()
{
//NOTE: I'm told that the following 4 lines are the result of making things 'easier to mock'
var context =
new RequestContext(
new HttpContextWrapper(new HttpContext(new HttpRequest("foo.txt", "http://test", ""),
new HttpResponse(Console.Out))),
new RouteData());
behaviorId = Guid.NewGuid();
Services.Inject(behaviorId);
captured = new CaptureArg();
MockFor <IBehaviorFactory>()
.Expect(x => x.BuildBehavior(null, behaviorId))
.Constraints(captured, Is.Equal(behaviorId))
.Return(MockFor <IActionBehavior>());
handler = ClassUnderTest.GetHttpHandler(context);
}
protected override void beforeEach()
{
suite = StoryTeller.Testing.DataMother.BuildHierarchy(@"
t1,Success
t2,Success
t3,Success
");
test1 = suite.FindTest("t1");
test2 = suite.FindTest("t2");
test3 = suite.FindTest("t3");
Services.Inject(suite);
driver1 = MockRepository.GenerateMock <ITestLineDriver>();
driver2 = MockRepository.GenerateMock <ITestLineDriver>();
driver3 = MockRepository.GenerateMock <ITestLineDriver>();
MockFor <ISuiteView>().Expect(x => x.AddTest(null, null)).Constraints(Is.Equal(test1), Is.Anything()).Return(
driver1);
MockFor <ISuiteView>().Expect(x => x.AddTest(null, null)).Constraints(Is.Equal(test2), Is.Anything()).Return(
driver2);
MockFor <ISuiteView>().Expect(x => x.AddTest(null, null)).Constraints(Is.Equal(test3), Is.Anything()).Return(
driver3);
MockFor <ITestService>().Expect(x => x.GetStatus(test1)).Return(TestState.Queued);
MockFor <ITestExplorer>().Expect(x => x.IconFor(test1)).Return(Icon.Pending);
MockFor <ITestService>().Expect(x => x.GetStatus(test2)).Return(TestState.NotQueued);
MockFor <ITestExplorer>().Expect(x => x.IconFor(test2)).Return(Icon.Success);
MockFor <ITestService>().Expect(x => x.GetStatus(test3)).Return(TestState.NotQueued);
MockFor <ITestExplorer>().Expect(x => x.IconFor(test3)).Return(Icon.Failed);
ClassUnderTest.Activate(null);
}
/// <summary>
/// Creates a new <see cref="PublicFieldIs"/> instance, specifying a disambiguating
/// <paramref name="declaringType"/> for the public field.
/// </summary>
/// <param name="declaringType">The type that declares the public field, used to disambiguate between public fields.</param>
/// <param name="publicFieldName">Name of the public field.</param>
/// <param name="expectedValue">Expected value.</param>
public PublicFieldIs(Type declaringType, string publicFieldName, object expectedValue)
: base(declaringType, publicFieldName, Is.Equal(expectedValue))
{
}
/// <summary>
/// Creates a new <see cref="PublicFieldIs"/> instance.
/// </summary>
/// <param name="publicFieldName">Name of the public field.</param>
/// <param name="expectedValue">Expected value.</param>
public PublicFieldIs(string publicFieldName, object expectedValue)
: base(publicFieldName, Is.Equal(expectedValue))
{
}
/// <summary>
/// Creates a new <see cref="PropertyIs"/> instance, specifying a disambiguating
/// <paramref name="declaringType"/> for the property.
/// </summary>
/// <param name="declaringType">The type that declares the property, used to disambiguate between properties.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="expectedValue">Expected value.</param>
public PropertyIs(Type declaringType, string propertyName, object expectedValue)
: base(declaringType, propertyName, Is.Equal(expectedValue))
{
}
/// <summary>
/// Creates a new <see cref="PropertyIs"/> instance.
/// </summary>
/// <param name="propertyName">Name of the property.</param>
/// <param name="expectedValue">Expected value.</param>
public PropertyIs(string propertyName, object expectedValue)
: base(propertyName, Is.Equal(expectedValue))
{
}
/// <summary>
/// Evaluate an equal constraint for <see cref="IComparable"/>.
/// </summary>
/// <param name="obj">The object the parameter should equal to</param>
public T Equal(object obj)
{
obj = ConvertObjectTypeToMatch(obj);
ArgManager.AddInArgument(Is.Equal(obj));
return(default(T));
}
public void should_direct_the_status_bar_to_show_the_recycle_was_finished_and_failed()
{
MockFor <IStatusView>().AssertWasCalled(x => x.MarkCycleTime(DateTime.Now, false), x => x.Constraints(Is.TypeOf <DateTime>(), Is.Equal(false)));
}