Providing a query builder off of the IContentManager interface.

--HG--
extra : convert_revision : svn%3A5ff7c347-ad56-4c35-b696-ccb81de16e03/trunk%4042269

src/Orchard.Tests/DataUtility.cs

@@ -13,10 +13,11 @@ using Orchard.Data;
 namespace Orchard.Tests {
     public static class DataUtility {
         public static ISessionFactory CreateSessionFactory(string fileName, params Type[] types) {
-            
-            var persistenceModel = AutoMap.Source(new Types(types))
-                .Alterations(alt => AddAlterations(alt, types))
-                .Conventions.AddFromAssemblyOf<DataModule>();
+
+            //var persistenceModel = AutoMap.Source(new Types(types))
+            //    .Alterations(alt => AddAlterations(alt, types))
+            //    .Conventions.AddFromAssemblyOf<DataModule>();
+            var persistenceModel = HackSessionLocator.CreatePersistenceModel(types);
 
             return Fluently.Configure()
                 .Database(SQLiteConfiguration.Standard.UsingFile(fileName).ShowSql())
@@ -25,9 +26,10 @@ namespace Orchard.Tests {
                 .BuildSessionFactory();
         }
 
-        private static void AddAlterations(AutoMappingAlterationCollection alterations, Type[] types) {
+        private static void AddAlterations(AutoMappingAlterationCollection alterations, IEnumerable<Type> types) {
             foreach (var assembly in types.Select(t => t.Assembly).Distinct()) {
                 alterations.Add(new AutoMappingOverrideAlteration(assembly));
+                alterations.AddFromAssembly(assembly);
             }
             alterations.AddFromAssemblyOf<DataModule>();
         }

src/Orchard.Tests/Environment/DefaultCompositionStrategyTests.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Orchard.Environment;
+using Orchard.Packages;
+using Orchard.Tests.Models.Records;
+using Orchard.Tests.Models.Stubs;
+
+namespace Orchard.Tests.Environment {
+    [TestFixture]
+    public class DefaultCompositionStrategyTests {
+        [Test]
+        public void ExpectedRecordsShouldComeBack() {
+            var packageManager = new Moq.Mock<IPackageManager>();
+            packageManager.Setup(x => x.ActivePackages()).Returns(new[] {
+                                                                            new PackageEntry
+                                                                            {ExportedTypes = new[] {typeof (GammaRecord), typeof (DeltaRecord), typeof (Delta)}}
+                                                                        });
+            var strategy = new DefaultCompositionStrategy(packageManager.Object);
+            var recordTypes = strategy.GetRecordTypes();
+
+            Assert.That(recordTypes.Count(), Is.Not.EqualTo(0));
+            Assert.That(recordTypes, Has.Some.EqualTo(typeof(DeltaRecord)));
+            Assert.That(recordTypes, Has.Some.EqualTo(typeof(GammaRecord)));
+            Assert.That(recordTypes, Has.None.EqualTo(typeof(Delta)));
+        }
+    }
+}

src/Orchard.Tests/Environment/DefaultOrchardHostTests.cs

@@ -80,6 +80,10 @@ namespace Orchard.Tests.Environment {
             public IEnumerable<Type> GetDependencyTypes() {
                 return Enumerable.Empty<Type>();
             }
+
+            public IEnumerable<Type> GetRecordTypes() {
+                return Enumerable.Empty<Type>();
+            }
         }
 
         [Test]

src/Orchard.Tests/Models/ContentQueryTests.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Modules;
+using NHibernate;
+using NUnit.Framework;
+using Orchard.Data;
+using Orchard.Models;
+using Orchard.Models.Driver;
+using Orchard.Models.Records;
+using Orchard.Tests.Models.Records;
+using Orchard.Tests.Models.Stubs;
+
+namespace Orchard.Tests.Models {
+    [TestFixture]
+    public class ContentQueryTests {
+        private IContainer _container;
+        private IContentManager _manager;
+        private ISessionFactory _sessionFactory;
+        private ISession _session;
+
+        [TestFixtureSetUp]
+        public void InitFixture() {
+            var databaseFileName = System.IO.Path.GetTempFileName();
+            _sessionFactory = DataUtility.CreateSessionFactory(
+                databaseFileName,
+                typeof(GammaRecord),
+                typeof(DeltaRecord),
+                typeof(ContentItemRecord),
+                typeof(ContentTypeRecord));
+        }
+
+        [TestFixtureTearDown]
+        public void TermFixture() {
+
+        }
+
+
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterModule(new ImplicitCollectionSupportModule());
+            builder.RegisterModule(new ContentModule());
+            builder.Register<DefaultContentManager>().As<IContentManager>();
+            builder.Register<AlphaProvider>().As<IContentProvider>();
+            builder.Register<BetaProvider>().As<IContentProvider>();
+            builder.Register<GammaProvider>().As<IContentProvider>();
+            builder.Register<DeltaProvider>().As<IContentProvider>();
+            builder.Register<FlavoredProvider>().As<IContentProvider>();
+            builder.Register<StyledProvider>().As<IContentProvider>();
+
+            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
+
+            _session = _sessionFactory.OpenSession();
+            builder.Register(new DefaultModelManagerTests.TestSessionLocator(_session)).As<ISessionLocator>();
+
+            _session.Delete("from GammaRecord");
+            _session.Delete("from DeltaRecord");
+            _session.Delete("from ContentItemRecord");
+            _session.Delete("from ContentTypeRecord");
+            _session.Flush();
+            _session.Clear();
+
+            _container = builder.Build();
+            _manager = _container.Resolve<IContentManager>();
+
+        }
+
+        private void AddSampleData() {
+            _manager.Create<Alpha>("alpha", init => { });
+            _manager.Create<Beta>("beta", init => { });
+            _manager.Create<Gamma>("gamma", init => { init.Record.Frap = "the frap value"; });
+            _manager.Create<Delta>("delta", init => { init.Record.Quux = "the quux value"; });
+            _session.Flush();
+        }
+
+        [Test]
+        public void QueryInstanceIsDifferentEachTimeYouCreateOne() {
+            var contentManager1 = _container.Resolve<IContentManager>();
+            var query1a = contentManager1.Query();
+            var query1b = contentManager1.Query();
+
+            var contentManager2 = _container.Resolve<IContentManager>();
+            var query2a = contentManager2.Query();
+            var query2b = contentManager2.Query();
+
+            Assert.That(contentManager1, Is.SameAs(contentManager2));
+            Assert.That(query1a, Is.SameAs(query1a));
+
+            Assert.That(query1a, Is.Not.SameAs(query1b));
+            Assert.That(query1a, Is.Not.SameAs(query2a));
+            Assert.That(query1a, Is.Not.SameAs(query2b));
+
+            Assert.That(query1b, Is.Not.SameAs(query2a));
+            Assert.That(query1b, Is.Not.SameAs(query2b));
+
+            Assert.That(query2a, Is.Not.SameAs(query2b));
+        }
+
+        [Test]
+        public void ContentManagerPropertyIsSet() {
+            var contentManager = _container.Resolve<IContentManager>();
+            var query = contentManager.Query();
+            Assert.That(query.ContentManager, Is.SameAs(contentManager));
+
+            var mockManager = new Moq.Mock<IContentManager>().Object;
+            var anotherQuery = _container.Resolve<IContentQuery>(TypedParameter.From(mockManager));
+            Assert.That(anotherQuery, Is.Not.SameAs(query));
+            Assert.That(anotherQuery.ContentManager, Is.SameAs(mockManager));
+        }
+
+        [Test]
+        public void AllItemsAreReturnedByDefault() {
+            AddSampleData();
+            
+            var allItems = _manager.Query().Select();
+
+            Assert.That(allItems.Count(), Is.EqualTo(4));
+            Assert.That(allItems.Count(x => x.Has<Alpha>()), Is.EqualTo(1));
+            Assert.That(allItems.Count(x => x.Has<Beta>()), Is.EqualTo(1));
+            Assert.That(allItems.Count(x => x.Has<Gamma>()), Is.EqualTo(1));
+            Assert.That(allItems.Count(x => x.Has<Delta>()), Is.EqualTo(1));
+        }
+        
+        [Test]
+        public void SpecificTypeIsReturnedWhenSpecified() {
+            AddSampleData();
+
+            var alphaBeta = _manager.Query().ForType("alpha", "beta").Select();
+
+            Assert.That(alphaBeta.Count(), Is.EqualTo(2));
+            Assert.That(alphaBeta.Count(x => x.Has<Alpha>()), Is.EqualTo(1));
+            Assert.That(alphaBeta.Count(x => x.Has<Beta>()), Is.EqualTo(1));
+            Assert.That(alphaBeta.Count(x => x.Has<Gamma>()), Is.EqualTo(0));
+            Assert.That(alphaBeta.Count(x => x.Has<Delta>()), Is.EqualTo(0));
+
+            var gammaDelta = _manager.Query().ForType("gamma", "delta").Select();
+
+            Assert.That(gammaDelta.Count(), Is.EqualTo(2));
+            Assert.That(gammaDelta.Count(x => x.Has<Alpha>()), Is.EqualTo(0));
+            Assert.That(gammaDelta.Count(x => x.Has<Beta>()), Is.EqualTo(0));
+            Assert.That(gammaDelta.Count(x => x.Has<Gamma>()), Is.EqualTo(1));
+            Assert.That(gammaDelta.Count(x => x.Has<Delta>()), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void WherePredicateRestrictsResults() {
+            AddSampleData();
+            _manager.Create<Gamma>("gamma", init => { init.Record.Frap = "one"; });
+            _manager.Create<Gamma>("gamma", init => { init.Record.Frap = "two"; });
+            _manager.Create<Gamma>("gamma", init => { init.Record.Frap = "three"; });
+            _manager.Create<Gamma>("gamma", init => { init.Record.Frap = "four"; });
+            _session.Flush();
+            var twoOrFour = _manager.Query().Where<GammaRecord>(x => x.Frap == "one" || x.Frap == "four").Select();
+
+            Assert.That(twoOrFour.Count(), Is.EqualTo(2));
+            Assert.That(twoOrFour.Count(x => x.Has<Gamma>()), Is.EqualTo(2));
+            Assert.That(twoOrFour.Count(x => x.Get<Gamma>().Record.Frap == "one"), Is.EqualTo(1));
+            Assert.That(twoOrFour.Count(x => x.Get<Gamma>().Record.Frap == "four"), Is.EqualTo(1));
+        }
+
+
+        [Test]
+        public void EmptyWherePredicateRequiresRecord() {
+            AddSampleData();
+            var gammas = _manager.Query().Where<GammaRecord>().Select();
+            var deltas = _manager.Query().Where<DeltaRecord>().Select();
+
+            Assert.That(gammas.Count(), Is.EqualTo(1));
+            Assert.That(deltas.Count(), Is.EqualTo(1));
+            Assert.That(gammas.AsPart<Gamma>().Single().Record.Frap, Is.EqualTo("the frap value"));
+            Assert.That(deltas.AsPart<Delta>().Single().Record.Quux, Is.EqualTo("the quux value"));
+        }
+
+    }
+}
+
+
+

src/Orchard.Tests/Models/DefaultModelManagerTests.cs

@@ -8,6 +8,7 @@ using Orchard.Data;
 using Orchard.Models;
 using Orchard.Models.Driver;
 using Orchard.Models.Records;
+using Orchard.Tests.Models.Records;
 using Orchard.Tests.Models.Stubs;
 
 namespace Orchard.Tests.Models {

src/Orchard.Tests/Models/Records/DeltaRecord.cs

@@ -0,0 +1,7 @@
+using Orchard.Models.Records;
+
+namespace Orchard.Tests.Models.Records {
+    public class DeltaRecord : ContentPartRecord {
+        public virtual string Quux { get; set; }
+    }
+}

src/Orchard.Tests/Models/Records/GammaRecord.cs

@@ -0,0 +1,7 @@
+using Orchard.Models.Records;
+
+namespace Orchard.Tests.Models.Records {
+    public class GammaRecord : ContentPartRecord {
+        public virtual string Frap { get; set; }
+    }
+}

src/Orchard.Tests/Models/Stubs/Delta.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.Data;
+using Orchard.Models;
+using Orchard.Models.Driver;
+using Orchard.Tests.Models.Records;
+
+namespace Orchard.Tests.Models.Stubs {
+    public class Delta : ContentPart<DeltaRecord> {
+    }
+
+
+    public class DeltaProvider : ContentProvider {
+        public DeltaProvider(IRepository<DeltaRecord> repository) {
+            Filters.Add(new ActivatingFilter<Delta>(x => x == "delta"));
+            Filters.Add(new StorageFilter<DeltaRecord>(repository));
+        }
+    }
+}

src/Orchard.Tests/Models/Stubs/Gamma.cs

@@ -1,21 +1,48 @@
-using Orchard.Data;
+using System.Linq;
+using FluentNHibernate.Automapping;
+using FluentNHibernate.Automapping.Alterations;
+using Orchard.Data;
 using Orchard.Models;
 using Orchard.Models.Driver;
-using Orchard.Models.Records;
+using Orchard.Tests.Models.Records;
 
 namespace Orchard.Tests.Models.Stubs {
     public class Gamma : ContentPart<GammaRecord> {
     }
 
-    public class GammaRecord : ContentPartRecord {
-        public virtual string Frap { get; set; }
-    }
-
 
     public class GammaProvider : ContentProvider {
-        public GammaProvider(IRepository<GammaRecord> repository){
+        public GammaProvider(IRepository<GammaRecord> repository) {
             Filters.Add(new ActivatingFilter<Gamma>(x => x == "gamma"));
             Filters.Add(new StorageFilter<GammaRecord>(repository));
         }
     }
+
+
+    //public class ContentItemRecordAlteration : IAutoMappingAlteration {
+    //    public void Alter(AutoPersistenceModel model) {
+    //        model.OverrideAll(mapping => {
+    //                              var genericArguments = mapping.GetType().GetGenericArguments();
+    //                              if (!genericArguments.Single().IsSubclassOf(typeof (ContentPartRecord))) {
+    //                                  return;
+    //                              }
+    //                          });
+
+    //        model.Override<ContentItemRecord>(mapping => mapping.HasOne(record => (GammaRecord)record["GammaRecord"]).Access.NoOp().Fetch.Select());
+
+
+    //    }
+
+    //    interface IAlteration {
+    //        void Override(object mapping);
+    //    }
+
+    //    class Alteration<T> : IAlteration where T : ContentPartRecord {
+    //        public void Override(object mappingObj) {
+    //            var mapping = (AutoMapping<T>)mappingObj;
+    //            mapping.Id(x => x.Id).GeneratedBy.Foreign("ContentItem");
+    //            mapping.HasOne(x => x.ContentItem).Constrained();
+    //        }
+    //    }
+    //}
 }

src/Orchard.Tests/Orchard.Tests.csproj

@@ -100,11 +100,13 @@
     <Compile Include="DataUtility.cs" />
     <Compile Include="Data\RepositoryTests.cs" />
     <Compile Include="Data\StubLocator.cs" />
+    <Compile Include="Environment\DefaultCompositionStrategyTests.cs" />
     <Compile Include="Environment\DefaultOrchardHostTests.cs" />
     <Compile Include="Environment\DefaultOrchardShellTests.cs" />
     <Compile Include="Environment\OrchardStarterTests.cs" />
     <Compile Include="Localization\NullLocalizerTests.cs" />
     <Compile Include="Logging\LoggingModuleTests.cs" />
+    <Compile Include="Models\ContentQueryTests.cs" />
     <Compile Include="Models\DefaultModelManagerTests.cs" />
     <Compile Include="Models\Drivers\ModelBuilderTests.cs" />
     <Compile Include="Models\Drivers\ModelDriverTests.cs" />
@@ -112,9 +114,12 @@
     <Compile Include="Models\Stubs\AlphaProvider.cs" />
     <Compile Include="Models\Stubs\Beta.cs" />
     <Compile Include="Models\Stubs\BetaProvider.cs" />
+    <Compile Include="Models\Stubs\Delta.cs" />
+    <Compile Include="Models\Records\DeltaRecord.cs" />
     <Compile Include="Models\Stubs\Flavored.cs" />
     <Compile Include="Models\Stubs\FlavoredProvider.cs" />
     <Compile Include="Models\Stubs\Gamma.cs" />
+    <Compile Include="Models\Records\GammaRecord.cs" />
     <Compile Include="Models\Stubs\Styled.cs" />
     <Compile Include="Models\Stubs\StyledProvider.cs" />
     <Compile Include="Mvc\ModelBinders\KeyedListModelBinderTests.cs" />