public void ChangedComittedQueriedObjectsCanBeUsedInParentTransaction()
{
IQueryResult queriedObjects;
Customer queriedObject;
Order newOrder;
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
queriedObjects = ClientTransactionScope.CurrentTransaction.QueryManager.GetCollection(query);
queriedObject = (Customer)queriedObjects.ToArray() [0];
newOrder = Order.NewObject();
newOrder.Official = Official.NewObject();
newOrder.OrderTicket = OrderTicket.NewObject();
newOrder.OrderItems.Add(OrderItem.NewObject());
queriedObject.Orders.Insert(0, newOrder);
queriedObject.CustomerSince = null;
ClientTransactionScope.CurrentTransaction.Commit();
}
Assert.That(queriedObjects, Is.Not.Null);
Assert.That(queriedObjects.Count, Is.EqualTo(1));
Assert.That(queriedObjects.ToArray()[0].ID, Is.EqualTo(DomainObjectIDs.Customer1));
Assert.That(queriedObject.CustomerSince, Is.Null);
Assert.That(queriedObject.Orders[0], Is.SameAs(newOrder));
}
public override void SetUp()
{
base.SetUp();
_persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy> ();
_objectLoaderMock = MockRepository.GenerateStrictMock <IObjectLoader> ();
_transactionEventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_queryManager = new QueryManager(
_persistenceStrategyMock,
_objectLoaderMock,
_transactionEventSinkWithMock);
_collectionQuery = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
_scalarQuery = QueryFactory.CreateQueryFromConfiguration("OrderNoSumByCustomerNameQuery");
_customQuery = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
_fakeOrder1 = DomainObjectMother.CreateFakeObject <Order> ();
_fakeOrder2 = DomainObjectMother.CreateFakeObject <Order>();
_loadedObjectDataStub1 = MockRepository.GenerateStub <ILoadedObjectData> ();
_loadedObjectDataStub2 = MockRepository.GenerateStub <ILoadedObjectData> ();
_rowConversion = qrr => qrr.GetRawValue(0);
}
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 DuringIteration_QueryStaysActive()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
var result = QueryManager.GetCustom(query, QueryResultRowTestHelper.ExtractRawValues);
using (var iterator = result.GetEnumerator())
{
iterator.MoveNext();
_persistenceExtensionMock
.AssertWasCalled(mock => mock.ConnectionOpened(Arg <Guid> .Is.Anything));
_persistenceExtensionMock
.AssertWasCalled(
mock =>
mock.QueryExecuting(
Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <string> .Is.Anything, Arg <IDictionary <string, object> > .Is.Anything));
_persistenceExtensionMock
.AssertWasCalled(mock => mock.QueryExecuted(Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <TimeSpan> .Is.Anything));
_persistenceExtensionMock.AssertWasNotCalled(
mock => mock.QueryCompleted(Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <TimeSpan> .Is.Anything, Arg <int> .Is.Anything));
_persistenceExtensionMock.AssertWasNotCalled(mock => mock.ConnectionClosed(Arg <Guid> .Is.Anything));
}
_persistenceExtensionMock.AssertWasCalled(
mock => mock.QueryCompleted(Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <TimeSpan> .Is.Anything, Arg <int> .Is.Anything));
_persistenceExtensionMock.AssertWasCalled(mock => mock.ConnectionClosed(Arg <Guid> .Is.Anything));
}
public void CollectionQuery_WithObjectList_WorksWhenUnassignableCollectionType()
{
var query = QueryFactory.CreateQueryFromConfiguration("QueryWithSpecificCollectionType");
var result = QueryManager.GetCollection <Order> (query);
Assert.That(result.Count, Is.GreaterThan(0));
}
public void CollectionQuery_WithObjectList_ThrowsWhenInvalidT()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
QueryManager.GetCollection <Order> (query);
}
public void ParameterWithTextReplacement()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderNoSumForMultipleCustomers");
query.Parameters.Add("{companyNames}", "'Kunde 1', 'Kunde 3'", QueryParameterType.Text);
Assert.That(Provider.ExecuteScalarQuery(query), Is.EqualTo(6));
}
public void BulkUpdateQuery()
{
var query = QueryFactory.CreateQueryFromConfiguration("BulkUpdateQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer1.Value);
Assert.That(Provider.ExecuteScalarQuery(query), Is.EqualTo(2));
}
public void ScalarQueryWithParameter()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderNoSumByCustomerNameQuery");
query.Parameters.Add("@customerName", "Kunde 1");
Assert.That(Provider.ExecuteScalarQuery(query), Is.EqualTo(3));
}
public void SearchViaReferencePropertyWithoutIdentity()
{
Assert.That(_property.SupportsSearchAvailableObjects, Is.True);
IBusinessObject[] results = _property.SearchAvailableObjects(_referencingBusinessObject, new DefaultSearchArguments(_stubbedQueryID));
Assert.That(
results,
Is.EqualTo(ClientTransaction.Current.QueryManager.GetCollection(QueryFactory.CreateQueryFromConfiguration(_stubbedQueryID)).ToArray()));
}
public void FromXmlFile()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
var result = QueryManager.GetCustom(query, QueryResultRowTestHelper.ExtractRawValues);
Assert.That(result.Count(), Is.EqualTo(2));
}
public void GetStoredProcedureResult()
{
var orders = (OrderCollection)QueryManager.GetCollection(QueryFactory.CreateQueryFromConfiguration("StoredProcedureQuery")).ToCustomCollection();
Assert.IsNotNull(orders, "OrderCollection is null");
Assert.AreEqual(2, orders.Count, "Order count");
Assert.AreEqual(DomainObjectIDs.Order1, orders[0].ID, "Order1");
Assert.AreEqual(DomainObjectIDs.Order3, orders[1].ID, "Order3");
}
public void ScalarQueryInSubTransaction()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var query = QueryFactory.CreateQueryFromConfiguration("QueryWithoutParameter");
Assert.That(ClientTransactionScope.CurrentTransaction.QueryManager.GetScalar(query), Is.EqualTo(42));
}
}
public void ObjectIDParameter()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer1);
var orderContainerIDs = Provider.ExecuteCollectionQuery(query).Select(dc => dc.ID);
Assert.That(orderContainerIDs.ToArray(), Is.EquivalentTo(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order2 }));
}
public void CustomQueryInSubTransaction()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
var result = ClientTransactionScope.CurrentTransaction.QueryManager.GetCustom(query, qrr => qrr.GetRawValue(0));
CollectionAssert.AreEquivalent(new[] { "üäöfedcba", "abcdeföäü" }, result);
}
}
public void ExecuteCollectionQuery()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer1.Value);
var orderContainerIDs = Provider.ExecuteCollectionQuery(query).Select(dc => dc.ID).ToArray();
Assert.That(orderContainerIDs.Contains(DomainObjectIDs.Order1), Is.True);
Assert.That(orderContainerIDs.Contains(DomainObjectIDs.Order2), Is.True);
}
public void Query()
{
var query = (Query)QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer1);
var deserializedQuery = (Query)SerializeAndDeserialize(query);
AreEqual(query, deserializedQuery);
Assert.That(deserializedQuery.Definition, Is.SameAs(DomainObjectsConfiguration.Current.Query.QueryDefinitions["OrderQuery"]));
}
public void GetStoredProcedureResultWithParameter()
{
var query = QueryFactory.CreateQueryFromConfiguration("StoredProcedureQueryWithParameter");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer1.Value);
var orders = (OrderCollection)QueryManager.GetCollection(query).ToCustomCollection();
Assert.IsNotNull(orders, "OrderCollection is null");
Assert.AreEqual(2, orders.Count, "Order count");
Assert.AreEqual(DomainObjectIDs.Order1, orders[0].ID, "Order1");
Assert.AreEqual(DomainObjectIDs.Order2, orders[1].ID, "Order2");
}
public void CreateQueryFromConfiguration_FromID()
{
var definition = DomainObjectsConfiguration.Current.Query.QueryDefinitions[0];
IQuery query = QueryFactory.CreateQueryFromConfiguration(definition.ID);
Assert.That(query.CollectionType, Is.EqualTo(definition.CollectionType));
Assert.That(query.ID, Is.EqualTo(definition.ID));
Assert.That(query.Parameters, Is.Empty);
Assert.That(query.QueryType, Is.EqualTo(definition.QueryType));
Assert.That(query.Statement, Is.EqualTo(definition.Statement));
Assert.That(query.StorageProviderDefinition, Is.SameAs(definition.StorageProviderDefinition));
}
public void CollectionQuery_WithObjectList()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
var customers = QueryManager.GetCollection <Customer> (query).ToObjectList();
Assert.That(customers, Is.Not.Null);
Assert.That(customers.Count, Is.EqualTo(1));
Assert.That(customers[0].ID, Is.EqualTo(DomainObjectIDs.Customer1));
Assert.That(query.CollectionType.IsAssignableFrom(customers.GetType()), Is.True);
}
public void CollectionQuery()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
var customers = QueryManager.GetCollection(query);
Assert.That(customers, Is.Not.Null);
Assert.That(customers.Count, Is.EqualTo(1));
Assert.That(customers.ToArray()[0].ID, Is.EqualTo(DomainObjectIDs.Customer1));
Assert.That(customers.ToArray()[0].GetPublicDomainObjectType(), Is.EqualTo(typeof(Customer)));
}
public void InitializeWithQueryID()
{
var parameters = new QueryParameterCollection();
var query = (Query)QueryFactory.CreateQueryFromConfiguration("OrderQuery", parameters);
QueryDefinition definition = DomainObjectsConfiguration.Current.Query.QueryDefinitions["OrderQuery"];
Assert.That(query.Definition, Is.SameAs(definition));
Assert.That(query.ID, Is.EqualTo(definition.ID));
Assert.That(query.CollectionType, Is.EqualTo(definition.CollectionType));
Assert.That(query.QueryType, Is.EqualTo(definition.QueryType));
Assert.That(query.Statement, Is.EqualTo(definition.Statement));
Assert.That(query.StorageProviderDefinition, Is.EqualTo(definition.StorageProviderDefinition));
Assert.That(query.Parameters, Is.SameAs(parameters));
}
public IQuery CreateQuery()
{
var query = QueryFactory.CreateQueryFromConfiguration("QueryWithAllDataTypes");
query.Parameters.Add("@stringProperty", StringProperty);
query.Parameters.Add("@bytePropertyFrom", BytePropertyFrom);
query.Parameters.Add("@bytePropertyTo", BytePropertyTo);
query.Parameters.Add("@enumProperty", EnumProperty);
query.Parameters.Add("@extensibleEnumProperty", ExtensibleEnumProperty);
query.Parameters.Add("@datePropertyFrom", DatePropertyFrom);
query.Parameters.Add("@datePropertyTo", DatePropertyTo);
query.Parameters.Add("@dateTimePropertyFrom", DateTimePropertyFrom);
query.Parameters.Add("@dateTimePropertyTo", DateTimePropertyTo);
return(query);
}
public void QueryInSubtransaction_CausesObjectsInSubtransactionToBeLoaded()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderQuery");
query.Parameters.Add("@customerID", DomainObjectIDs.Customer4);
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
var finalResult = ClientTransaction.Current.QueryManager.GetCollection(query);
var loadedObjects = finalResult.ToArray();
Assert.That(loadedObjects.Length, Is.EqualTo(2));
Assert.That(loadedObjects[0].State, Is.EqualTo(StateType.Unchanged));
Assert.That(loadedObjects[1].State, Is.EqualTo(StateType.Unchanged));
}
}
public void ObjectIDOfDifferentStorageProvider()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderByOfficialQuery");
query.Parameters.Add("@officialID", DomainObjectIDs.Official1);
var orderContainerIDs = Provider.ExecuteCollectionQuery(query).Select(dc => dc.ID);
Assert.That(orderContainerIDs.ToArray(), Is.EquivalentTo(
new[] {
DomainObjectIDs.Order1,
DomainObjectIDs.Order3,
DomainObjectIDs.Order4,
DomainObjectIDs.Order5,
DomainObjectIDs.Order2
}));
}
public void QueryingEnlists()
{
DomainObjectIDs.Order1.GetObject <Order> (); // ensure Order1 already exists in transaction
var orders = (OrderCollection)QueryManager.GetCollection(QueryFactory.CreateQueryFromConfiguration("StoredProcedureQuery")).ToCustomCollection();
Assert.AreEqual(2, orders.Count, "Order count");
foreach (Order order in orders)
{
Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
}
int orderNumberSum = orders.Sum(order => order.OrderNumber);
Assert.That(orderNumberSum, Is.EqualTo(DomainObjectIDs.Order1.GetObject <Order> ().OrderNumber + DomainObjectIDs.Order3.GetObject <Order> ().OrderNumber));
}
public void CompleteIteration_CompletelyExecutesQuery()
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomQuery");
QueryManager.GetCustom(query, QueryResultRowTestHelper.ExtractRawValues).ToList();
_persistenceExtensionMock
.AssertWasCalled(mock => mock.ConnectionOpened(Arg <Guid> .Is.Anything));
_persistenceExtensionMock
.AssertWasCalled(
mock => mock.QueryExecuting(
Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <string> .Is.Anything, Arg <IDictionary <string, object> > .Is.Anything));
_persistenceExtensionMock
.AssertWasCalled(mock => mock.QueryExecuted(Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <TimeSpan> .Is.Anything));
_persistenceExtensionMock.AssertWasCalled(
mock => mock.QueryCompleted(Arg <Guid> .Is.Anything, Arg <Guid> .Is.Anything, Arg <TimeSpan> .Is.Anything, Arg <int> .Is.Anything));
_persistenceExtensionMock.AssertWasCalled(mock => mock.ConnectionClosed(Arg <Guid> .Is.Anything));
}
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 ObjectQueryWithObjectListInSubTransaction()
{
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var query = QueryFactory.CreateQueryFromConfiguration("CustomerTypeQuery");
query.Parameters.Add("@customerType", Customer.CustomerType.Standard);
var queriedObjects = ClientTransactionScope.CurrentTransaction.QueryManager.GetCollection <Customer> (query);
var array = queriedObjects.ToArray();
Customer queriedObject = array[0];
Assert.That(queriedObjects, Is.Not.Null);
Assert.That(queriedObjects.Count, Is.EqualTo(1));
Assert.That(array[0].ID, Is.EqualTo(DomainObjectIDs.Customer1));
Assert.That(queriedObject.CustomerSince, Is.EqualTo(new DateTime(2000, 1, 1)));
Assert.That(queriedObject.Orders[0], Is.SameAs(DomainObjectIDs.Order1.GetObject <Order> ()));
}
}
public void CollectionQuery_WithObjectList_WorksWhenAssignableCollectionType()
{
var query = QueryFactory.CreateQueryFromConfiguration("OrderByOfficialQuery");
query.Parameters.Add("@officialID", DomainObjectIDs.Official1);
var orders = QueryManager.GetCollection <Order> (query).ToCustomCollection();
Assert.That(orders.Count, Is.EqualTo(5));
Assert.That(orders, Is.EquivalentTo(new object[]
{
DomainObjectIDs.Order1.GetObject <Order> (),
DomainObjectIDs.Order3.GetObject <Order> (),
DomainObjectIDs.Order2.GetObject <Order> (),
DomainObjectIDs.Order4.GetObject <Order> (),
DomainObjectIDs.Order5.GetObject <Order> (),
}));
Assert.That(query.CollectionType.IsAssignableFrom(orders.GetType()), Is.True);
}
