public void QueryWithSingleAndPredicate() { var query = (from o in QueryFactory.CreateLinqQuery <Order>() select o).Single(i => i.OrderNumber == 5); Assert.That(query, Is.EqualTo(DomainObjectIDs.Order5.GetObject <TestDomainBase> ())); }
public void EagerFetching_FetchAfterMultipleFromsWithoutSelectClauseInCallChain() { var query = (from o1 in QueryFactory.CreateLinqQuery <Order> () from o2 in QueryFactory.CreateLinqQuery <Order> () where o1.OrderNumber < 6 select o1).Distinct().FetchMany(x => x.OrderItems); CheckQueryResult(query, DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.Order4, DomainObjectIDs.Order5, DomainObjectIDs.Order2); CheckDataContainersRegistered(DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.Order4, DomainObjectIDs.Order5, DomainObjectIDs.Order2); CheckDataContainersRegistered( DomainObjectIDs.OrderItem1, DomainObjectIDs.OrderItem2, DomainObjectIDs.OrderItem3, DomainObjectIDs.OrderItem4, DomainObjectIDs.OrderItem5, DomainObjectIDs.OrderItem6); CheckCollectionRelationRegistered(DomainObjectIDs.Order1, "OrderItems", false, DomainObjectIDs.OrderItem1, DomainObjectIDs.OrderItem2); CheckCollectionRelationRegistered(DomainObjectIDs.Order3, "OrderItems", false, DomainObjectIDs.OrderItem3); CheckCollectionRelationRegistered(DomainObjectIDs.Order4, "OrderItems", false, DomainObjectIDs.OrderItem4); CheckCollectionRelationRegistered(DomainObjectIDs.Order5, "OrderItems", false, DomainObjectIDs.OrderItem5); CheckCollectionRelationRegistered(DomainObjectIDs.Order2, "OrderItems", false, DomainObjectIDs.OrderItem6); }
public List <AccessControlList> FindAccessControlLists() { var findAllAclsQuery = from acl in QueryFactory.CreateLinqQuery <AccessControlList> () select acl; return(findAllAclsQuery.ToList()); }
public void EagerFetching_MultipleFetches_OnSameLevel() { var query = (from o in QueryFactory.CreateLinqQuery <Order> () where o.OrderNumber == 1 select o) .Distinct() .FetchMany(o => o.OrderItems) .FetchOne(o => o.Customer).ThenFetchMany(c => c.Orders).ThenFetchOne(c => c.OrderTicket) .FetchOne(o => o.Customer).ThenFetchMany(c => c.Orders).ThenFetchMany(c => c.OrderItems) .FetchMany(o => o.OrderItems); CheckQueryResult(query, DomainObjectIDs.Order1); CheckDataContainersRegistered( DomainObjectIDs.Order1, // the original order DomainObjectIDs.Customer1, // the customer DomainObjectIDs.Order1, DomainObjectIDs.Order2, // the customer's orders DomainObjectIDs.OrderTicket1, DomainObjectIDs.OrderTicket2, // the customer's orders' tickets DomainObjectIDs.OrderItem1, DomainObjectIDs.OrderItem2, DomainObjectIDs.OrderItem6 // the customer's orders' items ); CheckObjectRelationRegistered(DomainObjectIDs.Order1, "Customer", DomainObjectIDs.Customer1); CheckCollectionRelationRegistered(DomainObjectIDs.Customer1, "Orders", true, DomainObjectIDs.Order1, DomainObjectIDs.Order2); CheckObjectRelationRegistered(DomainObjectIDs.Order1, "OrderTicket", DomainObjectIDs.OrderTicket1); CheckObjectRelationRegistered(DomainObjectIDs.OrderTicket1, "Order", DomainObjectIDs.Order1); CheckObjectRelationRegistered(DomainObjectIDs.Order2, "OrderTicket", DomainObjectIDs.OrderTicket2); CheckObjectRelationRegistered(DomainObjectIDs.OrderTicket2, "Order", DomainObjectIDs.Order2); CheckCollectionRelationRegistered(DomainObjectIDs.Order1, "OrderItems", false, DomainObjectIDs.OrderItem1, DomainObjectIDs.OrderItem2); CheckObjectRelationRegistered(DomainObjectIDs.OrderItem1, "Order", DomainObjectIDs.Order1); CheckObjectRelationRegistered(DomainObjectIDs.OrderItem2, "Order", DomainObjectIDs.Order1); CheckCollectionRelationRegistered(DomainObjectIDs.Order2, "OrderItems", false, DomainObjectIDs.OrderItem6); }
public void GroupBy_WithSubqueryKey() { var query = (from o in QueryFactory.CreateLinqQuery <Order> () group o by QueryFactory.CreateLinqQuery <OrderItem> ().Where(oi => oi.Order == o).Select(oi => oi.Product).Count()).Select(g => g.Key); Assert.That(query.Count(), Is.EqualTo(3)); }
public void Search_WithResultSizeConstraint() { var searchService = new TestableSecurityManagerSearchServiceBase(QueryFactory.CreateLinqQuery <User>()); var actual = searchService.Search(null, _property, CreateSecurityManagerSearchArguments(3)); Assert.That(actual.Length, Is.EqualTo(3)); }
private ILookup <ObjectID, StatefulAccessControlListData> LoadStatefulAccessControlLists() { var result = GetOrCreateQuery( MethodInfo.GetCurrentMethod(), () => from acl in QueryFactory.CreateLinqQuery <StatefulAccessControlList>() from sc in acl.GetStateCombinationsForQuery() from usage in sc.GetStateUsagesForQuery().DefaultIfEmpty() from propertyReference in acl.GetClassForQuery().GetStatePropertyReferencesForQuery().DefaultIfEmpty() select new { Class = acl.GetClassForQuery().ID, StateCombination = sc.ID.GetHandle <StateCombination>(), Acl = acl.ID.GetHandle <StatefulAccessControlList>(), StatePropertyID = propertyReference.StateProperty.ID, StatePropertyName = propertyReference.StateProperty.Name, StateValue = usage.StateDefinition.Name }); using (CreateStopwatchScopeForQueryExecution("stateful ACLs")) { return(result.GroupBy( row => new { row.Class, row.Acl, row.StateCombination }, row => row.StatePropertyID != null ? new State( row.StatePropertyID.GetHandle <StatePropertyDefinition>(), row.StatePropertyName, row.StateValue) : null) .ToLookup(g => g.Key.Class, g => new StatefulAccessControlListData(g.Key.Acl, g.Where(s => s != null)))); } }
public void GroupBy_EntityKey() { var query1 = from o in QueryFactory.CreateLinqQuery <Order> () where o.ID != DomainObjectIDs.InvalidOrder group o by o.Customer into ordersByCustomer select ordersByCustomer.Key; CheckQueryResult(query1, DomainObjectIDs.Customer1, DomainObjectIDs.Customer3, DomainObjectIDs.Customer4, DomainObjectIDs.Customer5); var query2 = from o in QueryFactory.CreateLinqQuery <Order> () group o by o.OrderTicket into ordersByOrderTicket where ordersByOrderTicket.Key != null select ordersByOrderTicket.Key.FileName; Assert.That(query2.Count(), Is.EqualTo(6)); var query3 = from r in QueryFactory.CreateLinqQuery <Order> () from c in r.OrderItems group c.ID by r into cooksByRestaurant from cook in cooksByRestaurant select new { cooksByRestaurant.Key.DeliveryDate, CookID = cook }; Assert.That(query3.Count(), Is.GreaterThan(0)); }
private static void TestSimpleLinqQueryWithCustomProjection_MappingInitialization() { using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { QueryFactory.CreateLinqQuery <Tenant>().Select(p => new { Value = p.ID, Key = p.UniqueIdentifier }).ToList(); } }
private static void TestComplexLinqQuery() { using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope()) { using (StopwatchScope.CreateScope("Complex query took {elapsed:ms} ms")) { var result = from acl in QueryFactory.CreateLinqQuery <StatefulAccessControlList>() from sc in acl.GetStateCombinationsForQuery() from usage in sc.GetStateUsagesForQuery().DefaultIfEmpty() from propertyReference in acl.GetClassForQuery().GetStatePropertyReferencesForQuery().DefaultIfEmpty() select new { Class = acl.GetClassForQuery().ID, Acl = acl.ID.GetHandle <StatefulAccessControlList>(), HasState = propertyReference != null, StatePropertyID = propertyReference.StateProperty.ID.Value, StatePropertyClassID = propertyReference.StateProperty.ID.ClassID, StatePropertyName = propertyReference.StateProperty.Name, StateValue = usage.StateDefinition.Name }; result.Count(); } } }
public void LinqCustomQuery_CallsFilterCustomQueryResult() { var listenerMock = MockRepository.GenerateMock <IClientTransactionListener>(); listenerMock .Expect( mock => mock.FilterCustomQueryResult( Arg.Is(TestableClientTransaction), Arg <IQuery> .Is.Anything, Arg <IEnumerable <int> > .List.Equal(new[] { 1, 2, 3, 4, 5 }))) .Return(new[] { 1, 2, 3 }); TestableClientTransaction.AddListener(listenerMock); try { var query = from o in QueryFactory.CreateLinqQuery <Order>() where o.OrderNumber <= 5 orderby o.OrderNumber select o.OrderNumber; var result = query.ToArray(); listenerMock.VerifyAllExpectations(); Assert.That(result, Is.EqualTo(new[] { 1, 2, 3 })); } finally { TestableClientTransaction.RemoveListener(listenerMock); } }
private void Step1() { QueryFactory.CreateLinqQuery <SecurableClassDefinition>() .Where(cd => cd == CurrentObject).Select(cd => cd) .FetchDetails() .ToArray(); }
public void SequenceOfObjectIDs_ConstructedInMemory() { var result = (from o in QueryFactory.CreateLinqQuery <Order>() where o.OrderNumber < 3 select new ObjectID(o.ID.ClassID, o.ID.Value)).ToArray(); Assert.That(result, Is.EquivalentTo(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order2 })); }
public void FilterQueryResult_RaisedInAllHierarchyLevels() { using (ExtensionStrictMock.GetMockRepository().Ordered()) { ExtensionStrictMock .Expect( mock => mock.FilterQueryResult( Arg.Is(ReadOnlyRootTransaction), Arg <QueryResult <DomainObject> > .Matches(qr => qr.ToArray().SequenceEqual(new[] { _order1 })))) .Return(new QueryResult <DomainObject> (_queryStub, new[] { _order3 })) .WhenCalled(mi => Assert.That(ReadOnlyRootTransaction.IsWriteable, Is.False)); ExtensionStrictMock .Expect( mock => mock.FilterQueryResult( Arg.Is(ReadOnlyMiddleTransaction), Arg <QueryResult <DomainObject> > .Matches(qr => qr.ToArray().SequenceEqual(new[] { _order3 })))) .Return(new QueryResult <DomainObject> (_queryStub, new[] { _order4 })) .WhenCalled(mi => Assert.That(ReadOnlyMiddleTransaction.IsWriteable, Is.False)); ExtensionStrictMock .Expect( mock => mock.FilterQueryResult( Arg.Is(WriteableSubTransaction), Arg <QueryResult <DomainObject> > .Matches(qr => qr.ToArray().SequenceEqual(new[] { _order4 })))) .Return(new QueryResult <DomainObject> (_queryStub, new[] { _order5 })) .WhenCalled(mi => Assert.That(WriteableSubTransaction.IsWriteable, Is.True)); } var result = ExecuteInWriteableSubTransaction(() => QueryFactory.CreateLinqQuery <Order>().Where(obj => obj.ID == _order1.ID).ToList()); ExtensionStrictMock.VerifyAllExpectations(); Assert.That(result, Is.EqualTo(new[] { _order5 })); }
public void QueryWithSubQuery_InMainFrom() { var orders = from c in (from ci in QueryFactory.CreateLinqQuery <Computer> () select ci) select c; CheckQueryResult(orders, DomainObjectIDs.Computer1, DomainObjectIDs.Computer2, DomainObjectIDs.Computer3, DomainObjectIDs.Computer4, DomainObjectIDs.Computer5); }
public void QueryWithAll_InSubquery() { var query1 = from o in QueryFactory.CreateLinqQuery <Order>() where o.OrderItems.All(oi => oi.Position == 1) select o; CheckQueryResult( query1, DomainObjectIDs.Order3, DomainObjectIDs.Order4, DomainObjectIDs.Order5, DomainObjectIDs.Order2, DomainObjectIDs.InvalidOrder, DomainObjectIDs.OrderWithoutOrderItems); // ReSharper disable UseMethodAny.0 var query2 = from c in QueryFactory.CreateLinqQuery <Customer>() where c.Orders.All(o => o.OrderItems.Count() > 0) select c; // ReSharper restore UseMethodAny.0 CheckQueryResult( query2, DomainObjectIDs.Customer1, DomainObjectIDs.Customer2, DomainObjectIDs.Customer3, DomainObjectIDs.Customer4); }
public void Compare_NotEqual() { IQueryable <TestDomainObject> expected = from d in QueryFactory.CreateLinqQuery <TestDomainObject>() where d.Value == 1 select d; IQueryable <TestDomainObject> actual = from d in QueryFactory.CreateLinqQuery <TestDomainObject>() where d.Value == 0 select d; _queryableComparer.Compare(expected, actual); }
public void GroupBy_UseGroupInFromExpression() { var query = from o in QueryFactory.CreateLinqQuery <Order> () group o.ID by o.OrderNumber into orderByOrderNo from id in orderByOrderNo select new { orderByOrderNo.Key, OrderID = id }; Assert.That(query.Count(), Is.EqualTo(7)); var query2 = from o in QueryFactory.CreateLinqQuery <Order>() group o by o.OrderNumber into orderByOrderNo from o in orderByOrderNo where o != null select new { orderByOrderNo.Key, Order = o }; Assert.That(query2.Count(), Is.EqualTo(7)); var query3 = from o in QueryFactory.CreateLinqQuery <Order>() group o.OrderNumber by o.OrderNumber into orderByOrderNo from o in ( from so in orderByOrderNo select so).Distinct() select new { orderByOrderNo.Key, Order = o }; Assert.That(query3.Count(), Is.EqualTo(7)); }
public void QueryWithCount() { var number = (from o in QueryFactory.CreateLinqQuery <Order>() select o).Count(); Assert.That(7, Is.EqualTo(number)); }
public void ExtensibleEnums_InWhereClause() { var query1 = from cwadt in QueryFactory.CreateLinqQuery <ClassWithAllDataTypes> () where cwadt.ExtensibleEnumProperty == Color.Values.Red() select cwadt; var result1 = query1.ToArray(); Assert.That(result1, Is.EqualTo(new[] { DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> () })); var query2 = from cwadt in QueryFactory.CreateLinqQuery <ClassWithAllDataTypes> () where cwadt.ExtensibleEnumProperty.Equals(Color.Values.Red()) select cwadt; var result2 = query2.ToArray(); Assert.That(result2, Is.EqualTo(new[] { DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> () })); var query3 = from cwadt in QueryFactory.CreateLinqQuery <ClassWithAllDataTypes> () where new[] { Color.Values.Red(), Color.Values.Blue() }.Contains(cwadt.ExtensibleEnumProperty) select cwadt; var result3 = query3.ToArray(); Assert.That( result3, Is.EquivalentTo( new[] { DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (), DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> () })); }
public void CreateLinqQuery_WithoutParserAndExecutor() { var factoryMock = MockRepository.GenerateStrictMock <ILinqProviderComponentFactory> (); var serviceLocator = DefaultServiceLocator.Create(); serviceLocator.RegisterSingle <ILinqProviderComponentFactory> (() => factoryMock); using (new ServiceLocatorScope(serviceLocator)) { var fakeExecutor = MockRepository.GenerateStub <IQueryExecutor> (); var fakeQueryParser = MockRepository.GenerateStub <IQueryParser> (); var fakeResult = MockRepository.GenerateStub <IQueryable <Order> > (); factoryMock .Expect(mock => mock.CreateQueryExecutor(TestDomainStorageProviderDefinition)) .Return(fakeExecutor); factoryMock .Expect(mock => mock.CreateQueryParser()) .Return(fakeQueryParser); factoryMock .Expect(mock => mock.CreateQueryable <Order> (fakeQueryParser, fakeExecutor)) .Return(fakeResult); var result = QueryFactory.CreateLinqQuery <Order> (); factoryMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); } }
public void BaseObjects_MemberAccessInSameClass_SingleTableInheritance() { var company = (from c in QueryFactory.CreateLinqQuery <Company> () where c.IndustrialSector.ID == DomainObjectIDs.IndustrialSector2 && c.Name == "Firma 2" select c); CheckQueryResult(company, DomainObjectIDs.Company2); }
public void BaseObjects_PropertyAccessInSameClass_SingleTableInheritance() { var company = (from c in QueryFactory.CreateLinqQuery <Company> () where c.Name == "Firma 2" select c); CheckQueryResult(company, DomainObjectIDs.Company2); }
public void ConcreteObjects_MemberAccessInBaseClass_SingleTableInheritance() { var customers = (from c in QueryFactory.CreateLinqQuery <Customer> () where c.IndustrialSector.ID == DomainObjectIDs.IndustrialSector2 select c); CheckQueryResult(customers, DomainObjectIDs.Customer3, DomainObjectIDs.Customer2); }
public void ConcreteObjects_PropertyAccessInBaseClass_SingleTableInheritance() { var customer = (from c in QueryFactory.CreateLinqQuery <Customer>() where c.Name == "Kunde 3" select c); CheckQueryResult(customer, DomainObjectIDs.Customer3); }
public void ConcreteObjects_PropertyAccessInBaseClass_ClassAboveInheritanceHierarchy() { var storageClass = (from f in QueryFactory.CreateLinqQuery <StorageGroupClass> () where f.AboveInheritanceIdentifier == "AboveInheritanceName1" select f); CheckQueryResult(storageClass, DomainObjectIDs.StorageGroupClass1); }
public void BaseObjects_MemberAccessInSameClass_ConcreteTableInheritance() { var fsi = (from f in QueryFactory.CreateLinqQuery <TIFileSystemItem> () where f.ParentFolder.ID == _concreteObjectIDs.FolderRoot select f); CheckQueryResult(fsi, _concreteObjectIDs.FileRoot, _concreteObjectIDs.Folder1); }
public void BaseObjects_PropertyAccessInSameClass_ConcreteTableInheritance() { var fsi = (from f in QueryFactory.CreateLinqQuery <TIFileSystemItem> () where f.Name == "Datei im Root" select f); CheckQueryResult(fsi, _concreteObjectIDs.FileRoot); }
public void ConcreteObjects_PropertyAccessInSameClass_ConcreteTableInheritance() { var fsi = (from f in QueryFactory.CreateLinqQuery <TIFile> () where f.Size == 512 select f); CheckQueryResult(fsi, _concreteObjectIDs.File1); }
public void QueryWithFirst_AndInterface() { var queryResult = (from o in QueryFactory.CreateLinqQuery <Order> () orderby o.OrderNumber select(IOrder) o).First(); Assert.That(queryResult, Is.EqualTo(DomainObjectIDs.Order1.GetObject <Order> ())); }