public void AccessObjectInFilterQueryResult()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var extensionMock = MockRepository.GenerateMock <IClientTransactionExtension> ();
DomainObjectIDs.Order1.GetObject <Order> ();
extensionMock.Stub(stub => stub.Key).Return("stub");
extensionMock.Replay();
TestableClientTransaction.Extensions.Add(extensionMock);
try
{
extensionMock.BackToRecord();
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer3);
var newQueryResult = TestQueryFactory.CreateTestQueryResult <DomainObject> ();
extensionMock
.Expect(mock => mock.FilterQueryResult(Arg <ClientTransaction> .Is.Anything, Arg <QueryResult <DomainObject> > .Is.Anything))
.WhenCalled(mi => DomainObjectIDs.Order1.GetObject <Order> ())
.Return(newQueryResult);
extensionMock.Replay();
ClientTransaction.Current.QueryManager.GetCollection(query);
extensionMock.VerifyAllExpectations();
}
finally
{
TestableClientTransaction.Extensions.Remove("stub");
}
}
}
public void InitializeWithQueryDefinition()
{
var parameters = new QueryParameterCollection();
QueryDefinition definition = TestQueryFactory.CreateOrderQueryWithCustomCollectionType();
var query = new Query(definition, parameters);
Assert.That(query.Definition, Is.SameAs(definition));
Assert.That(query.ID, Is.EqualTo(definition.ID));
Assert.That(query.Parameters, Is.SameAs(parameters));
}
private QueryDefinitionCollection CreateExpectedQueryDefinitions()
{
QueryDefinitionCollection queries = new QueryDefinitionCollection();
queries.Add(TestQueryFactory.CreateOrderQueryWithCustomCollectionType());
queries.Add(TestQueryFactory.CreateOrderQueryDefinitionWithObjectListOfOrder());
queries.Add(TestQueryFactory.CreateCustomerTypeQueryDefinition());
queries.Add(TestQueryFactory.CreateOrderSumQueryDefinition());
return(queries);
}
public void EagerFetchQueries()
{
QueryDefinition definition = TestQueryFactory.CreateOrderQueryWithCustomCollectionType();
var query1 = new Query(definition, new QueryParameterCollection());
Assert.That(query1.EagerFetchQueries, Is.Not.Null);
Assert.That(query1.EagerFetchQueries.Count, Is.EqualTo(0));
var query2 = new Query(definition, new QueryParameterCollection());
var endPointDefinition = DomainObjectIDs.Order1.ClassDefinition.GetMandatoryRelationEndPointDefinition(typeof(Order).FullName + ".OrderItems");
query1.EagerFetchQueries.Add(endPointDefinition, query2);
Assert.That(query1.EagerFetchQueries.Count, Is.EqualTo(1));
}
public override void SetUp()
{
base.SetUp();
_query1 = QueryFactory.CreateQuery(TestQueryFactory.CreateOrderSumQueryDefinition());
_query2 = QueryFactory.CreateQuery(TestQueryFactory.CreateOrderQueryWithCustomCollectionType());
_endPointDefinition1 = DomainObjectIDs.Order1.ClassDefinition.GetMandatoryRelationEndPointDefinition(typeof(Order).FullName + ".OrderItems");
_endPointDefinition2 = DomainObjectIDs.Customer1.ClassDefinition.GetMandatoryRelationEndPointDefinition(typeof(Customer).FullName + ".Orders");
_objectEndPointDefinition = DomainObjectIDs.Order1.ClassDefinition.GetMandatoryRelationEndPointDefinition(typeof(Order).FullName + ".OrderTicket");
_collection = new EagerFetchQueryCollection();
}
public void CollectionQuery_CallsFilterQueryResult_AndAllowsGetObjectDuringFiltering()
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
listenerMock
.Expect(mock => mock.FilterQueryResult(Arg.Is(TestableClientTransaction), Arg <QueryResult <DomainObject> > .Is.Anything))
.Return(TestQueryFactory.CreateTestQueryResult <DomainObject> ())
.WhenCalled(mi => DomainObjectIDs.OrderItem1.GetObject <OrderItem>());
TestableClientTransaction.AddListener(listenerMock);
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("customerID", DomainObjectIDs.Customer1);
TestableClientTransaction.QueryManager.GetCollection(query);
listenerMock.VerifyAllExpectations();
listenerMock.BackToRecord(); // For Discarding
}
public void FilterQueryResult()
{
var queryStub = QueryFactory.CreateQuery(TestQueryFactory.CreateOrderQueryWithCustomCollectionType());
var originalResult = new QueryResult <Order> (queryStub, new Order[0]);
var newResult1 = new QueryResult <Order> (queryStub, new[] { DomainObjectIDs.Order1.GetObject <Order> () });
var newResult2 = new QueryResult <Order> (queryStub, new[] { DomainObjectIDs.Order2.GetObject <Order> () });
_extension1.Expect(mock => mock.FilterQueryResult(TestableClientTransaction, originalResult)).Return(newResult1);
_extension2.Expect(mock => mock.FilterQueryResult(TestableClientTransaction, newResult1)).Return(newResult2);
var finalResult = _collectionWithExtensions.FilterQueryResult(TestableClientTransaction, originalResult);
Assert.That(finalResult, Is.SameAs(newResult2));
_extension1.VerifyAllExpectations();
_extension2.VerifyAllExpectations();
}
public void LinqQuery_CallsFilterQueryResult()
{
var extensionKey = "LinqQuery_CallsFilterQueryResult_Key";
var extensionMock = MockRepository.GenerateMock <IClientTransactionExtension>();
extensionMock.Stub(stub => stub.Key).Return(extensionKey);
extensionMock
.Expect(mock => mock.FilterQueryResult(Arg.Is(TestableClientTransaction), Arg <QueryResult <DomainObject> > .Is.Anything))
.Return(TestQueryFactory.CreateTestQueryResult <DomainObject>());
TestableClientTransaction.Extensions.Add(extensionMock);
try
{
var query = from o in QueryFactory.CreateLinqQuery <Order>() where o.Customer.ID == DomainObjectIDs.Customer1 select o;
query.ToArray();
extensionMock.VerifyAllExpectations();
}
finally
{
TestableClientTransaction.Extensions.Remove(extensionKey);
}
}
