public void EnsureDataAvailable_Many_NotLoadedYet()
{
TestableClientTransaction.EnsureDataAvailable(new[] { NotLoadedObject1.ID, NotLoadedObject2.ID });
ListenerMock.AssertWasCalled(mock => mock.ObjectsLoading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <ObjectID> > .List.Equivalent(new[] { NotLoadedObject1.ID, NotLoadedObject2.ID })));
}
public void EnsureDataAvailable_Many_AlreadyLoaded()
{
CheckLoaded(LoadedObject1);
CheckLoaded(LoadedObject2);
TestableClientTransaction.EnsureDataAvailable(new[] { LoadedObject1.ID, LoadedObject2.ID });
ListenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(Arg <ClientTransaction> .Is.Anything, Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
}
protected void ExpectCommitValidateEvents(params DomainObject[] domainObjects)
{
using (_mockRepository.Ordered())
{
ListenerMock
.Expect(mock => mock.TransactionCommitValidate(Arg.Is(_transaction), ArgIsPersistableDataSet(domainObjects)))
.WhenCalled(mi => Assert.That(_transaction.HasChanged(), Is.True, "CommitValidate: last event before actual commit."));
ExtensionMock
.Expect(mock => mock.CommitValidate(Arg.Is(_transaction), ArgIsPersistableDataSet(domainObjects)));
}
}
public void TryEnsureDataAvailable_AlreadyLoaded()
{
CheckLoaded(LoadedObject1);
var result = TestableClientTransaction.TryEnsureDataAvailable(LoadedObject1.ID);
ListenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
CheckLoaded(LoadedObject1);
Assert.That(result, Is.True);
}
public void EnsureDataAvailable_NotLoadedYet()
{
CheckNotLoaded(NotLoadedObject1);
TestableClientTransaction.EnsureDataAvailable(NotLoadedObject1.ID);
ListenerMock.AssertWasCalled(mock => mock.ObjectsLoading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <ObjectID> > .List.ContainsAll(new[] { NotLoadedObject1.ID })));
ListenerMock.AssertWasCalled(mock => mock.ObjectsLoaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.ContainsAll(new[] { NotLoadedObject1 })));
CheckLoaded(NotLoadedObject1);
}
public void EnsureDataAvailable_Many_SomeLoadedSomeNot()
{
TestableClientTransaction.EnsureDataAvailable(new[] { NotLoadedObject1.ID, NotLoadedObject2.ID, LoadedObject1.ID });
ListenerMock.AssertWasCalled(mock => mock.ObjectsLoading(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <ObjectID> > .List.Equivalent(new[] { NotLoadedObject1.ID, NotLoadedObject2.ID })));
ListenerMock.AssertWasCalled(mock => mock.ObjectsLoaded(
Arg.Is(TestableClientTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(new[] { NotLoadedObject1, NotLoadedObject2 })));
ListenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .List.ContainsAll(new[] { LoadedObject1.ID })));
}
protected AllMethodOptions ExpectCommittedEventsWithCustomOptions(params Tuple <DomainObject, DomainObjectMockEventReceiver>[] domainObjectsAndMocks)
{
using (_mockRepository.Ordered())
{
var domainObjectOptions = new List <IMethodOptions <RhinoMocksExtensions.VoidType> > (domainObjectsAndMocks.Length);
using (_mockRepository.Unordered())
{
domainObjectOptions.AddRange(domainObjectsAndMocks.Select(t => t.Item2.Expect(mock => mock.Committed())));
}
var domainObjects = domainObjectsAndMocks.Select(t => t.Item1).ToArray();
var transactionOptions = TransactionMockEventReceiver.Expect(mock => mock.Committed(domainObjects));
var extensionOptions = ExtensionMock.Expect(mock => mock.Committed(Arg.Is(_transaction), ArgIsDomainObjectSet(domainObjects)));
ListenerMock.Expect(mock => mock.TransactionCommitted(Arg.Is(_transaction), ArgIsDomainObjectSet(domainObjects)));
return(new AllMethodOptions(extensionOptions, transactionOptions, domainObjectOptions.ToArray()));
}
}
public void EntityRemovedCallbackShouldBeCalledWithComponents2()
{
var entityManager = new EntityManager();
var systemRoot = new SystemRoot <EntityManager>(entityManager);
var group = entityManager.GetComponentGroup(typeof(Component1), typeof(Component2));
var listenerMock = new ListenerMock();
// group.SubscribeOnEntityAdded(listenerMock);
// group.SubscribeOnEntityRemoved (listenerMock);
group.SubscribeOnEntityRemoving(listenerMock);
// group.component
var e = entityManager.CreateEntity();
entityManager.AddComponent(e, new Component1());
entityManager.AddComponent(e, new Component2());
// Assert.That (listenerMock.addedCalls, Is.EqualTo (1));
// listenerMock.RemovedEvent += delegate (Entity e1) {
// Assert.True(entityManager.HasComponent<Component1>(e1));
// Assert.True(entityManager.HasComponent<Component2>(e1));
// };
listenerMock.RemovingEvent += delegate(Entity e1) {
Assert.True(entityManager.HasComponent <Component1>(e1));
Assert.True(entityManager.HasComponent <Component2>(e1));
};
entityManager.RemoveComponent <Component1>(e);
// entityManager.RemoveComponentImmediate<Component1>(e);
systemRoot.Update();
Assert.That(listenerMock.removingCalls, Is.EqualTo(1));
}
public void EntityAddedToGroupShouldNotBeCalledIfDifferentComponent()
{
// Use the Assert class to test conditions.
var entityManager = new EntityManager();
var group = entityManager.GetComponentGroup(typeof(Component1), typeof(Component2));
var listenerMock = new ListenerMock();
group.SubscribeOnEntityAdded(listenerMock);
var e = entityManager.CreateEntity();
Assert.That(listenerMock.addedCalls, Is.EqualTo(0));
entityManager.AddComponent(e, new Component1());
Assert.That(listenerMock.addedCalls, Is.EqualTo(0));
entityManager.AddComponent(e, new Component2());
Assert.That(listenerMock.addedCalls, Is.EqualTo(1));
entityManager.AddComponent(e, new Component3());
Assert.That(listenerMock.addedCalls, Is.EqualTo(1));
}
public void Expect_ProcessResponse_to_be_invoked()
{
ListenerMock.Verify((l) => l.ProcessResponse(It.IsAny <SipResponseEvent>()), Times.Exactly(2));
}
public void Expect_ProcessTimeOut_to_be_invoked()
{
ListenerMock.Verify((l) => l.ProcessTimeOut(It.IsAny <SipTimeOutEvent>()), Times.Exactly(1));
}
public void Expect_ProcessResponse_not_to_be_invoked()
{
//its invoked 1 time to go into completed state.
ListenerMock.Verify((l) => l.ProcessResponse(It.IsAny <SipResponseEvent>()), Times.Exactly(1));
}
