Updating some tests namespaces

--HG--
rename : src/Orchard.Tests/Models/ContentQueryTests.cs => src/Orchard.Tests/ContentManagement/ContentQueryTests.cs
rename : src/Orchard.Tests/Models/DefaultContentManagerTests.cs => src/Orchard.Tests/ContentManagement/DefaultContentManagerTests.cs
rename : src/Orchard.Tests/Models/Drivers/ContentHandlerTests.cs => src/Orchard.Tests/ContentManagement/Drivers/ContentHandlerTests.cs
rename : src/Orchard.Tests/Models/Drivers/ModelBuilderTests.cs => src/Orchard.Tests/ContentManagement/Drivers/ModelBuilderTests.cs
rename : src/Orchard.Tests/Models/PartDriverHandlerTests.cs => src/Orchard.Tests/ContentManagement/PartDriverHandlerTests.cs
rename : src/Orchard.Tests/Models/Records/DeltaRecord.cs => src/Orchard.Tests/ContentManagement/Records/DeltaRecord.cs
rename : src/Orchard.Tests/Models/Records/EpsilonRecord.cs => src/Orchard.Tests/ContentManagement/Records/EpsilonRecord.cs
rename : src/Orchard.Tests/Models/Records/GammaRecord.cs => src/Orchard.Tests/ContentManagement/Records/GammaRecord.cs
rename : src/Orchard.Tests/Models/Stubs/Alpha.cs => src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs
rename : src/Orchard.Tests/Models/Stubs/AlphaHandler.cs => src/Orchard.Tests/ContentManagement/Stubs/AlphaHandler.cs
rename : src/Orchard.Tests/Models/Stubs/Beta.cs => src/Orchard.Tests/ContentManagement/Stubs/Beta.cs
rename : src/Orchard.Tests/Models/Stubs/BetaHandler.cs => src/Orchard.Tests/ContentManagement/Stubs/BetaHandler.cs
rename : src/Orchard.Tests/Models/Stubs/Delta.cs => src/Orchard.Tests/ContentManagement/Stubs/Delta.cs
rename : src/Orchard.Tests/Models/Stubs/Epsilon.cs => src/Orchard.Tests/ContentManagement/Stubs/Epsilon.cs
rename : src/Orchard.Tests/Models/Stubs/Flavored.cs => src/Orchard.Tests/ContentManagement/Stubs/Flavored.cs
rename : src/Orchard.Tests/Models/Stubs/FlavoredHandler.cs => src/Orchard.Tests/ContentManagement/Stubs/FlavoredHandler.cs
rename : src/Orchard.Tests/Models/Stubs/Gamma.cs => src/Orchard.Tests/ContentManagement/Stubs/Gamma.cs
rename : src/Orchard.Tests/Models/Stubs/Styled.cs => src/Orchard.Tests/ContentManagement/Stubs/Styled.cs
rename : src/Orchard.Tests/Models/Stubs/StyledHandler.cs => src/Orchard.Tests/ContentManagement/Stubs/StyledHandler.cs
extra : convert_revision : svn%3A5ff7c347-ad56-4c35-b696-ccb81de16e03/trunk%4044784

src/Orchard.Tests/ContentManagement/ContentQueryTests.cs

@@ -0,0 +1,240 @@
+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.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.Records;
+using Orchard.Tests.ContentManagement.Records;
+using Orchard.Tests.ContentManagement.Models;
+
+namespace Orchard.Tests.ContentManagement {
+    [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(ContentItemVersionRecord),
+                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<AlphaHandler>().As<IContentHandler>();
+            builder.Register<BetaHandler>().As<IContentHandler>();
+            builder.Register<GammaHandler>().As<IContentHandler>();
+            builder.Register<DeltaHandler>().As<IContentHandler>();
+            builder.Register<FlavoredHandler>().As<IContentHandler>();
+            builder.Register<StyledHandler>().As<IContentHandler>();
+
+            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
+
+            _session = _sessionFactory.OpenSession();
+            builder.Register(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>();
+
+            _session.Delete("from GammaRecord");
+            _session.Delete("from DeltaRecord");
+            _session.Delete("from ContentItemVersionRecord");
+            _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().List();
+
+            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").List();
+
+            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").List();
+
+            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<Gamma, GammaRecord>()
+                .Where(x => x.Frap == "one" || x.Frap == "four")
+                .List();
+
+            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().Join<GammaRecord>().List();
+            var deltas = _manager.Query().Join<DeltaRecord>().List();
+
+            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"));
+        }
+
+        [Test]
+        public void OrderMaySortOnJoinedRecord() {
+            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();
+            _session.Clear();
+
+            var ascending = _manager.Query("gamma")
+                .OrderBy<GammaRecord, string>(x => x.Frap)
+                .List<Gamma>().ToList();
+
+            Assert.That(ascending.Count(), Is.EqualTo(5));
+            Assert.That(ascending.First().Record.Frap, Is.EqualTo("four"));
+            Assert.That(ascending.Last().Record.Frap, Is.EqualTo("two"));
+
+            _session.Clear();
+
+            var descending = _manager.Query<Gamma, GammaRecord>()
+                .OrderByDescending(x => x.Frap)
+                .List().ToList();
+
+            Assert.That(descending.Count(), Is.EqualTo(5));
+            Assert.That(descending.First().Record.Frap, Is.EqualTo("two"));
+            Assert.That(descending.Last().Record.Frap, Is.EqualTo("four"));
+        }
+
+        [Test]
+        public void SkipAndTakeProvidePagination() {
+            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 reverseById = _manager.Query()
+                .OrderByDescending<GammaRecord, int>(x => x.Id)
+                .List();
+
+            var subset = _manager.Query()
+                .OrderByDescending<GammaRecord, int>(x => x.Id)
+                .Slice(2, 3);
+
+            Assert.That(subset.Count(), Is.EqualTo(3));
+            Assert.That(subset.First().Id, Is.EqualTo(reverseById.Skip(2).First().Id));
+            Assert.That(subset.Skip(1).First().Id, Is.EqualTo(reverseById.Skip(3).First().Id));
+            Assert.That(subset.Skip(2).First().Id, Is.EqualTo(reverseById.Skip(4).First().Id));
+
+        }
+    }
+}
+
+
+

src/Orchard.Tests/ContentManagement/DefaultContentManagerTests.cs

@@ -0,0 +1,414 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Modules;
+using NHibernate;
+using NUnit.Framework;
+using Orchard.Data;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.Records;
+using Orchard.Tests.ContentManagement.Records;
+using Orchard.Tests.ContentManagement.Models;
+
+namespace Orchard.Tests.ContentManagement {
+    [TestFixture]
+    public class DefaultContentManagerTests {
+        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(ContentTypeRecord),
+                typeof(ContentItemRecord),
+                typeof(ContentItemVersionRecord),
+                typeof(GammaRecord),
+                typeof(DeltaRecord),
+                typeof(EpsilonRecord));
+        }
+
+        [TestFixtureTearDown]
+        public void TermFixture() {
+
+        }
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterModule(new ImplicitCollectionSupportModule());
+            builder.Register<DefaultContentManager>().As<IContentManager>();
+            builder.Register<AlphaHandler>().As<IContentHandler>();
+            builder.Register<BetaHandler>().As<IContentHandler>();
+            builder.Register<GammaHandler>().As<IContentHandler>();
+            builder.Register<DeltaHandler>().As<IContentHandler>();
+            builder.Register<EpsilonHandler>().As<IContentHandler>();
+            builder.Register<FlavoredHandler>().As<IContentHandler>();
+            builder.Register<StyledHandler>().As<IContentHandler>();
+
+            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
+
+            _session = _sessionFactory.OpenSession();
+            builder.Register(new TestSessionLocator(_session)).As<ISessionLocator>();
+
+            _container = builder.Build();
+            _manager = _container.Resolve<IContentManager>();
+        }
+
+        public class TestSessionLocator : ISessionLocator {
+            private readonly ISession _session;
+
+            public TestSessionLocator(ISession session) {
+                _session = session;
+            }
+
+            public ISession For(Type entityType) {
+                return _session;
+            }
+        }
+
+        [Test]
+        public void AlphaDriverShouldWeldItsPart() {
+            var foo = _manager.New("alpha");
+
+            Assert.That(foo.Is<Alpha>(), Is.True);
+            Assert.That(foo.As<Alpha>(), Is.Not.Null);
+            Assert.That(foo.Is<Beta>(), Is.False);
+            Assert.That(foo.As<Beta>(), Is.Null);
+        }
+
+        [Test]
+        public void StronglyTypedNewShouldTypeCast() {
+            var foo = _manager.New<Alpha>("alpha");
+            Assert.That(foo, Is.Not.Null);
+            Assert.That(foo.GetType(), Is.EqualTo(typeof(Alpha)));
+        }
+
+        [Test, ExpectedException(typeof(InvalidCastException))]
+        public void StronglyTypedNewShouldThrowCastExceptionIfNull() {
+            _manager.New<Beta>("alpha");
+        }
+
+        [Test]
+        public void AlphaIsFlavoredAndStyledAndBetaIsFlavoredOnly() {
+            var alpha = _manager.New<Alpha>("alpha");
+            var beta = _manager.New<Beta>("beta");
+
+            Assert.That(alpha.Is<Flavored>(), Is.True);
+            Assert.That(alpha.Is<Styled>(), Is.True);
+            Assert.That(beta.Is<Flavored>(), Is.True);
+            Assert.That(beta.Is<Styled>(), Is.False);
+        }
+
+        [Test]
+        public void GetByIdShouldDetermineTypeAndLoadParts() {
+            var modelRecord = CreateModelRecord("alpha");
+
+            var contentItem = _manager.Get(modelRecord.Id);
+            Assert.That(contentItem.ContentType, Is.EqualTo("alpha"));
+            Assert.That(contentItem.Id, Is.EqualTo(modelRecord.Id));
+        }
+
+
+        [Test]
+        public void ModelPartWithRecordShouldCallRepositoryToPopulate() {
+
+            CreateModelRecord("gamma");
+            CreateModelRecord("gamma");
+            var modelRecord = CreateModelRecord("gamma");
+
+            var model = _manager.Get(modelRecord.Id);
+
+            // create a gamma record
+            var gamma = new GammaRecord {
+                ContentItemRecord = _container.Resolve<IRepository<ContentItemRecord>>().Get(model.Id),
+                Frap = "foo"
+            };
+
+            _container.Resolve<IRepository<GammaRecord>>().Create(gamma);
+            _session.Flush();
+            _session.Clear();
+
+            // re-fetch from database
+            model = _manager.Get(modelRecord.Id);
+
+            Assert.That(model.ContentType, Is.EqualTo("gamma"));
+            Assert.That(model.Id, Is.EqualTo(modelRecord.Id));
+            Assert.That(model.Is<Gamma>(), Is.True);
+            Assert.That(model.As<Gamma>().Record, Is.Not.Null);
+            Assert.That(model.As<Gamma>().Record.ContentItemRecord.Id, Is.EqualTo(model.Id));
+
+        }
+
+        [Test]
+        public void CreateShouldMakeModelAndContentTypeRecords() {
+            var beta = _manager.New("beta");
+            _manager.Create(beta);
+
+            var modelRecord = _container.Resolve<IRepository<ContentItemRecord>>().Get(beta.Id);
+            Assert.That(modelRecord, Is.Not.Null);
+            Assert.That(modelRecord.ContentType.Name, Is.EqualTo("beta"));
+        }
+
+        [Test]
+        public void GetContentTypesShouldReturnAllTypes() {
+            var types = _manager.GetContentTypes();
+            Assert.That(types.Count(), Is.EqualTo(4));
+            Assert.That(types, Has.Some.With.Property("Name").EqualTo("alpha"));
+            Assert.That(types, Has.Some.With.Property("Name").EqualTo("beta"));
+            Assert.That(types, Has.Some.With.Property("Name").EqualTo("gamma"));
+            Assert.That(types, Has.Some.With.Property("Name").EqualTo("delta"));
+        }
+
+        private ContentItemRecord CreateModelRecord(string contentType) {
+            var contentTypeRepository = _container.Resolve<IRepository<ContentTypeRecord>>();
+            var contentItemRepository = _container.Resolve<IRepository<ContentItemRecord>>();
+            var contentItemVersionRepository = _container.Resolve<IRepository<ContentItemVersionRecord>>();
+
+            var modelRecord = new ContentItemRecord { ContentType = contentTypeRepository.Get(x => x.Name == contentType) };
+            if (modelRecord.ContentType == null) {
+                modelRecord.ContentType = new ContentTypeRecord { Name = contentType };
+                contentTypeRepository.Create(modelRecord.ContentType);
+            }
+            contentItemRepository.Create(modelRecord);
+
+            contentItemVersionRepository.Create(new ContentItemVersionRecord { ContentItemRecord = modelRecord, Latest = true, Published = true, Number = 1 });
+
+            _session.Flush();
+            _session.Clear();
+            return modelRecord;
+        }
+
+        [Test]
+        public void InitialVersionShouldBeOne() {
+            var gamma1 = _manager.Create<Gamma>("gamma");
+            Assert.That(gamma1.ContentItem.Record, Is.Not.Null);
+            Assert.That(gamma1.ContentItem.VersionRecord, Is.Not.Null);
+            Assert.That(gamma1.ContentItem.Version, Is.EqualTo(1));
+            Assert.That(gamma1.ContentItem.VersionRecord.Number, Is.EqualTo(1));
+
+            _session.Flush();
+            _session.Clear();
+            Trace.WriteLine("session flushed");
+
+            var gamma2 = _manager.Get<Gamma>(gamma1.ContentItem.Id);
+            Assert.That(gamma2.ContentItem.Record, Is.Not.Null);
+            Assert.That(gamma2.ContentItem.VersionRecord, Is.Not.Null);
+            Assert.That(gamma2.ContentItem.Version, Is.EqualTo(1));
+            Assert.That(gamma2.ContentItem.VersionRecord.Number, Is.EqualTo(1));
+
+            // asserts results are re-acquired from db
+            Assert.That(gamma1, Is.Not.SameAs(gamma2));
+            Assert.That(gamma1.Record, Is.Not.SameAs(gamma2.Record));
+            Assert.That(gamma1.ContentItem, Is.Not.SameAs(gamma2.ContentItem));
+            Assert.That(gamma1.ContentItem.Record, Is.Not.SameAs(gamma2.ContentItem.Record));
+            Assert.That(gamma1.ContentItem.VersionRecord, Is.Not.SameAs(gamma2.ContentItem.VersionRecord));
+        }
+
+        [Test]
+        public void InitialVersionCanBeSpecifiedAndIsPublished() {
+            var gamma1 = _manager.Create<Gamma>("gamma", VersionOptions.Number(4));
+
+            Assert.That(gamma1.ContentItem.Version, Is.EqualTo(4));
+            Assert.That(gamma1.ContentItem.VersionRecord.Published, Is.True);
+
+            _session.Flush();
+            _session.Clear();
+        }
+
+        [Test]
+        public void PublishedShouldBeLatestButNotDraft() {
+            var gamma1 = _manager.Create("gamma", VersionOptions.Published);
+
+            var gammaPublished = _manager.Get(gamma1.Id, VersionOptions.Published);
+            var gammaLatest = _manager.Get(gamma1.Id, VersionOptions.Latest);
+            var gammaDraft = _manager.Get(gamma1.Id, VersionOptions.Draft);
+
+            Assert.That(gammaPublished.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaLatest.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaDraft, Is.Null);
+        }
+
+        [Test]
+        public void DraftShouldBeLatestButNotPublished() {
+            var gamma1 = _manager.Create("gamma", VersionOptions.Draft);
+
+            var gammaPublished = _manager.Get(gamma1.Id, VersionOptions.Published);
+            var gammaLatest = _manager.Get(gamma1.Id, VersionOptions.Latest);
+            var gammaDraft = _manager.Get(gamma1.Id, VersionOptions.Draft);
+
+            Assert.That(gammaDraft.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaLatest.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaPublished, Is.Null);
+        }
+
+
+        [Test]
+        public void CreateDraftShouldNotCreateExtraDraftCopies() {
+            var gamma1 = _manager.Create("gamma", VersionOptions.Draft);
+            _session.Flush();
+            _session.Clear();
+
+            var gammaDraft1 = _manager.Get(gamma1.Id, VersionOptions.Draft);
+            Assert.That(gammaDraft1.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaDraft1.Record.Versions, Has.Count.EqualTo(1));
+            _session.Flush();
+            _session.Clear();
+
+            var gammaDraft2 = _manager.Get(gamma1.Id, VersionOptions.DraftRequired);
+            Assert.That(gammaDraft2.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaDraft2.Record.Versions, Has.Count.EqualTo(1));
+            _session.Flush();
+            _session.Clear();
+
+            var gammaDraft3 = _manager.Get(gamma1.Id, VersionOptions.Draft);
+            Assert.That(gammaDraft3.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaDraft3.Record.Versions, Has.Count.EqualTo(1));
+            _session.Flush();
+            _session.Clear();
+
+            var gammaDraft4 = _manager.Get(gamma1.Id, VersionOptions.DraftRequired);
+            Assert.That(gammaDraft4.VersionRecord.Id, Is.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gammaDraft4.Record.Versions, Has.Count.EqualTo(1));
+            _session.Flush();
+            _session.Clear();
+        }
+
+        [Test]
+        public void DraftRequiredShouldBuildNewVersionIfLatestIsAlreadyPublished() {
+            Trace.WriteLine("gamma1");
+            var gamma1 = _manager.Create("gamma", VersionOptions.Published);
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            Trace.WriteLine("gammaDraft1");
+            var gammaDraft1 = _manager.Get(gamma1.Id, VersionOptions.Draft);
+            Assert.That(gammaDraft1, Is.Null);
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            Trace.WriteLine("gammaDraft2");
+            var gammaDraft2 = _manager.Get(gamma1.Id, VersionOptions.DraftRequired);
+            Assert.That(gammaDraft2.VersionRecord.Id, Is.Not.EqualTo(gamma1.VersionRecord.Id));
+            Assert.That(gamma1.Version, Is.EqualTo(1));
+            Assert.That(gammaDraft2.Version, Is.EqualTo(2));
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            foreach (var x in _container.Resolve<IRepository<ContentItemVersionRecord>>().Fetch(x => true)) {
+                Trace.WriteLine(string.Format("{0}/{1} #{2} published:{3} latest:{4}",
+                    x.ContentItemRecord.Id,
+                    x.Id,
+                    x.Number,
+                    x.Published,
+                    x.Latest));
+            }
+
+            Trace.WriteLine("gammaDraft3");
+            var gammaDraft3 = _manager.Get(gamma1.Id, VersionOptions.Draft);
+            Assert.That(gammaDraft3.VersionRecord.Id, Is.EqualTo(gammaDraft2.VersionRecord.Id));
+            Assert.That(gammaDraft3.Record, Is.Not.SameAs(gammaDraft2.Record));
+            Assert.That(gammaDraft3.Record.Versions, Is.Not.SameAs(gammaDraft2.Record.Versions));
+
+            Assert.That(gammaDraft3.Record.Versions, Has.Count.EqualTo(2));
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            Trace.WriteLine("gammaDraft4");
+            var gammaDraft4 = _manager.Get(gamma1.Id, VersionOptions.DraftRequired);
+            Assert.That(gammaDraft4.VersionRecord.Id, Is.EqualTo(gammaDraft2.VersionRecord.Id));
+            Assert.That(gammaDraft4.Record.Versions, Has.Count.EqualTo(2));
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            Trace.WriteLine("gamma2");
+            var gamma2 = _manager.Get(gamma1.Id);
+            Assert.That(gamma2.Record.Versions, Has.Count.EqualTo(2));
+        }
+
+        [Test]
+        public void NonVersionedPartsAreBoundToSameRecord() {
+            Trace.WriteLine("gamma1");
+            var gamma1 = _manager.Create<Gamma>("gamma", VersionOptions.Published, init => init.Record.Frap = "version one");
+            Trace.WriteLine("gamma2");
+            var gamma2 = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.DraftRequired);
+            Assert.That(gamma1.Record.Frap, Is.EqualTo("version one"));
+            Assert.That(gamma2.Record.Frap, Is.EqualTo("version one"));
+            gamma2.Record.Frap = "version two";
+            Assert.That(gamma1.Record.Frap, Is.EqualTo("version two"));
+            Assert.That(gamma2.Record.Frap, Is.EqualTo("version two"));
+
+            Trace.WriteLine("flush");
+            _session.Flush();
+            _session.Clear();
+
+            Trace.WriteLine("gamma1B");
+            var gamma1B = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.Published);
+            Trace.WriteLine("gamma2B");
+            var gamma2B = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.Draft);
+            Assert.That(gamma1B.Record, Is.SameAs(gamma2B.Record));
+            Assert.That(gamma1B.Record.Frap, Is.EqualTo("version two"));
+            Assert.That(gamma2B.Record.Frap, Is.EqualTo("version two"));
+            Assert.That(gamma1B.ContentItem.VersionRecord.Id, Is.Not.EqualTo(gamma2B.ContentItem.VersionRecord.Id));
+
+            Assert.That(gamma1.ContentItem.Record, Is.Not.SameAs(gamma1B.ContentItem.Record));
+            Assert.That(gamma2.ContentItem.Record, Is.Not.SameAs(gamma2B.ContentItem.Record));
+            Assert.That(gamma1.ContentItem.Record, Is.SameAs(gamma2.ContentItem.Record));
+            Assert.That(gamma1B.ContentItem.Record, Is.SameAs(gamma2B.ContentItem.Record));
+            Assert.That(gamma1.ContentItem.VersionRecord, Is.Not.SameAs(gamma2.ContentItem.VersionRecord));
+            Assert.That(gamma1B.ContentItem.VersionRecord, Is.Not.SameAs(gamma2B.ContentItem.VersionRecord));
+
+            Trace.WriteLine("flush");
+            _session.Flush();
+        }
+
+        [Test]
+        public void VersionedPartsShouldBeDifferentRecordsWithClonedData() {
+            var gamma1 = _manager.Create<Gamma>("gamma", VersionOptions.Published, init => init.Record.Frap = "version one");
+            var epsilon1 = gamma1.As<Epsilon>();
+            epsilon1.Record.Quad = "epsilon one";
+
+            var gamma2 = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.DraftRequired);
+            var epsilon2 = gamma2.As<Epsilon>();
+
+            Assert.That(epsilon1.Record.Quad, Is.EqualTo("epsilon one"));
+            Assert.That(epsilon2.Record.Quad, Is.EqualTo("epsilon one"));
+            epsilon2.Record.Quad = "epsilon two";
+            Assert.That(epsilon1.Record.Quad, Is.EqualTo("epsilon one"));
+            Assert.That(epsilon2.Record.Quad, Is.EqualTo("epsilon two"));            
+
+
+            _session.Flush();
+            _session.Clear();
+
+            var gamma1B = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.Published);
+            var epsilon1B = gamma1B.As<Epsilon>();
+            var gamma2B = _manager.Get<Gamma>(gamma1.ContentItem.Id, VersionOptions.Draft);
+            var epsilon2B = gamma2B.As<Epsilon>();
+            Assert.That(gamma1B.Record, Is.SameAs(gamma2B.Record));
+            Assert.That(epsilon1B.Record, Is.Not.SameAs(epsilon2B.Record));
+            Assert.That(epsilon1B.Record.Quad, Is.EqualTo("epsilon one"));
+            Assert.That(epsilon2B.Record.Quad, Is.EqualTo("epsilon two"));
+            Assert.That(epsilon1B.ContentItem.VersionRecord.Id, Is.Not.EqualTo(epsilon2B.ContentItem.VersionRecord.Id));
+
+            Assert.That(epsilon1.ContentItem.Record, Is.Not.SameAs(epsilon1B.ContentItem.Record));
+            Assert.That(epsilon2.ContentItem.Record, Is.Not.SameAs(epsilon2B.ContentItem.Record));
+            Assert.That(epsilon1.ContentItem.Record, Is.SameAs(epsilon2.ContentItem.Record));
+            Assert.That(epsilon1B.ContentItem.Record, Is.SameAs(epsilon2B.ContentItem.Record));
+            Assert.That(epsilon1.ContentItem.VersionRecord, Is.Not.SameAs(epsilon2.ContentItem.VersionRecord));
+            Assert.That(epsilon1B.ContentItem.VersionRecord, Is.Not.SameAs(epsilon2B.ContentItem.VersionRecord));
+        }
+    }
+}
+

src/Orchard.Tests/ContentManagement/Drivers/ContentHandlerTests.cs

@@ -0,0 +1,51 @@
+using NUnit.Framework;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+
+namespace Orchard.Tests.ContentManagement.Handlers {
+
+    [TestFixture]
+    public class ContentHandlerTests {
+        [Test]
+        public void ModelDriverShouldUsePersistenceFilterToDelegateCreateAndLoad() {
+            var modelDriver = new TestModelHandler();
+
+            var contentItem = new ContentItem();
+            var part = new TestModelPart();
+            contentItem.Weld(part);
+
+            ((IContentHandler)modelDriver).Creating(new CreateContentContext { ContentItem = contentItem });
+            Assert.That(part.CreatingCalled, Is.True);
+        }
+
+        [Test]
+        public void PartShouldBeAddedBasedOnSimplePredicate() {
+            var modelDriver = new TestModelHandler();
+
+            var builder = new ContentItemBuilder("testing");
+            ((IContentHandler)modelDriver).Activating(new ActivatingContentContext { Builder = builder, ContentType = "testing" });
+            var model = builder.Build();
+            Assert.That(model.Is<TestModelPart>(), Is.True);
+            Assert.That(model.As<TestModelPart>(), Is.Not.Null);
+        }
+
+        public class TestModelPart : ContentPart {
+            public bool CreatingCalled { get; set; }
+        }
+
+
+        public class TestModelHandler : ContentHandler {
+            public TestModelHandler() {
+                Filters.Add(new ActivatingFilter<TestModelPart>(x => x == "testing"));
+                Filters.Add(new TestModelStorageFilter());
+            }
+        }
+
+        public class TestModelStorageFilter : StorageFilterBase<TestModelPart> {
+            protected override void Creating(CreateContentContext context, TestModelPart instance) {
+                instance.CreatingCalled = true;
+            }
+        }
+    }
+}
+

src/Orchard.Tests/ContentManagement/Drivers/ModelBuilderTests.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Tests.ContentManagement.Models;
+
+namespace Orchard.Tests.ContentManagement.Handlers {
+    [TestFixture]
+    public class ModelBuilderTests {
+        [Test]
+        public void BuilderShouldReturnWorkingModelWithTypeAndId() {
+            var builder = new ContentItemBuilder("foo");
+            var model = builder.Build();
+            Assert.That(model.ContentType, Is.EqualTo("foo"));
+        }
+
+        [Test]
+        public void IdShouldDefaultToZero() {
+            var builder = new ContentItemBuilder("foo");
+            var model = builder.Build();
+            Assert.That(model.Id, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void WeldShouldAddPartToModel() {
+            var builder = new ContentItemBuilder("foo");
+            builder.Weld<Alpha>();
+            var model = builder.Build();
+
+            Assert.That(model.Is<Alpha>(), Is.True);
+            Assert.That(model.As<Alpha>(), Is.Not.Null);
+            Assert.That(model.Is<Beta>(), Is.False);
+            Assert.That(model.As<Beta>(), Is.Null);
+        }
+    }
+}
+

src/Orchard.Tests/ContentManagement/PartDriverHandlerTests.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text;
+using Autofac;
+using Autofac.Builder;
+using Autofac.Modules;
+using Moq;
+using NUnit.Framework;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Drivers;
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.ViewModels;
+
+namespace Orchard.Tests.ContentManagement {
+    [TestFixture]
+    public class PartDriverHandlerTests {
+        private IContainer _container;
+
+        [SetUp]
+        public void Init() {
+            var builder = new ContainerBuilder();
+            builder.RegisterModule(new ImplicitCollectionSupportModule());
+            builder.Register<PartDriverHandler>().As<IContentHandler>();
+            _container = builder.Build();
+        }
+
+        [Test]
+        public void DriverHandlerShouldNotThrowException() {
+            var contentHandler = _container.Resolve<IContentHandler>();
+            contentHandler.BuildDisplayModel(null);
+        }
+
+        [Test]
+        public void AllDriversShouldBeCalled() {
+            var driver1 = new Mock<IPartDriver>();
+            var driver2 = new Mock<IPartDriver>();
+            _container.Build(x => {
+                x.Register(driver1.Object);
+                x.Register(driver2.Object);
+            });
+            var contentHandler = _container.Resolve<IContentHandler>();
+
+            var ctx = new BuildDisplayModelContext(new ItemDisplayModel(new ContentItem()), null);
+
+            driver1.Verify(x => x.BuildDisplayModel(ctx), Times.Never());
+            contentHandler.BuildDisplayModel(ctx);
+            driver1.Verify(x => x.BuildDisplayModel(ctx));
+        }
+
+        [Test]
+        public void TestDriverCanAddDisplay() {
+            var driver = new StubPartDriver();
+            _container.Build(x => x.Register(driver).As<IPartDriver>());
+
+            var contentHandler = _container.Resolve<IContentHandler>();
+
+            var item = new ContentItem();
+            item.Weld(new StubPart { Foo = new[] { "a", "b", "c" } });
+
+            var ctx = new BuildDisplayModelContext(new ItemDisplayModel(item), "");
+            Assert.That(ctx.DisplayModel.Displays.Count(), Is.EqualTo(0));
+            contentHandler.BuildDisplayModel(ctx);
+            Assert.That(ctx.DisplayModel.Displays.Count(), Is.EqualTo(1));
+            Assert.That(ctx.DisplayModel.Displays.Single().Prefix, Is.EqualTo("Stub"));
+
+        }
+
+        public class StubPartDriver : PartDriver<StubPart> {
+            protected override string Prefix {
+                get { return "Stub"; }
+            }
+
+            protected override DriverResult Display(StubPart part, string displayType) {
+                var viewModel = new StubViewModel { Foo = string.Join(",", part.Foo) };
+                if (displayType.StartsWith("Summary"))
+                    return PartTemplate(viewModel, "StubViewModelTerse").Location("topmeta");
+
+                return PartTemplate(viewModel).Location("topmeta");
+            }
+
+            protected override DriverResult Editor(StubPart part) {
+                var viewModel = new StubViewModel { Foo = string.Join(",", part.Foo) };
+                return PartTemplate(viewModel).Location("last", "10");
+            }
+
+            protected override DriverResult Editor(StubPart part, IUpdateModel updater) {
+                var viewModel = new StubViewModel { Foo = string.Join(",", part.Foo) };
+                updater.TryUpdateModel(viewModel, Prefix, null, null);
+                part.Foo = viewModel.Foo.Split(new[] { ',' }).Select(x => x.Trim()).ToArray();
+                return PartTemplate(viewModel).Location("last", "10");
+            }
+        }
+
+        public class StubPart : ContentPart {
+            public string[] Foo { get; set; }
+        }
+
+        public class StubViewModel {
+            [Required]
+            public string Foo { get; set; }
+        }
+    }
+
+}

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

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

src/Orchard.Tests/ContentManagement/Records/EpsilonRecord.cs

@@ -0,0 +1,7 @@
+using Orchard.ContentManagement.Records;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class EpsilonRecord : ContentPartVersionRecord {
+        public virtual string Quad { get; set; }
+    }
+}

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

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

src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs

@@ -0,0 +1,6 @@
+using Orchard.ContentManagement;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class Alpha : ContentPart {        
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/AlphaHandler.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.ViewModels;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class AlphaHandler : ContentHandler {
+        public AlphaHandler() {
+            OnGetDisplayViewModel<Alpha>((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part) { Position = "3" }));
+        }
+        public override IEnumerable<ContentType> GetContentTypes() {
+            return new[] { new ContentType { Name = "alpha" } };
+        }
+        protected override void Activating(ActivatingContentContext context) {
+            if (context.ContentType == "alpha") {
+                context.Builder.Weld<Alpha>();
+            }
+        }
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/Beta.cs

@@ -0,0 +1,6 @@
+using Orchard.ContentManagement;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class Beta : ContentPart {
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/BetaHandler.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class BetaHandler : ContentHandler {
+        public override System.Collections.Generic.IEnumerable<Orchard.ContentManagement.ContentType> GetContentTypes() {
+            return new[] { new ContentType { Name = "beta" } };
+        }
+
+        protected override void Activating(ActivatingContentContext context) {
+            if (context.ContentType == "beta") {
+                context.Builder.Weld<Beta>();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.Data;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Tests.ContentManagement.Records;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class Delta : ContentPart<DeltaRecord> {
+    }
+
+
+    public class DeltaHandler : ContentHandler {
+        public override System.Collections.Generic.IEnumerable<Orchard.ContentManagement.ContentType> GetContentTypes() {
+            return new[] { new ContentType { Name = "delta" } };
+        }
+
+        public DeltaHandler(IRepository<DeltaRecord> repository) {
+            Filters.Add(new ActivatingFilter<Delta>(x => x == "delta"));
+            Filters.Add(new StorageFilter<DeltaRecord>(repository));
+        }
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/Epsilon.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Data;
+using Orchard.Tests.ContentManagement.Records;
+
+namespace Orchard.Tests.ContentManagement.Models {
+
+
+    public class Epsilon : ContentPart<EpsilonRecord> {
+    }
+
+    public class EpsilonHandler : ContentHandler {
+
+        public EpsilonHandler(IRepository<EpsilonRecord> repository) {
+            Filters.Add(new ActivatingFilter<Epsilon>(x => x == "gamma"));
+            Filters.Add(new StorageVersionFilter<EpsilonRecord>(repository));            
+        }
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/Flavored.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.ContentManagement;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    class Flavored : ContentPart {
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/FlavoredHandler.cs

@@ -0,0 +1,15 @@
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.ViewModels;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class FlavoredHandler : ContentHandler {
+        public FlavoredHandler() {
+            OnGetDisplayViewModel<Flavored>((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part)));
+        }
+        protected override void Activating(ActivatingContentContext context) {
+            if (context.ContentType == "beta" || context.ContentType == "alpha") {
+                context.Builder.Weld<Flavored>();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+using Orchard.Data;
+using Orchard.ContentManagement;
+using Orchard.ContentManagement.Handlers;
+using Orchard.Tests.ContentManagement.Records;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class Gamma : ContentPart<GammaRecord> {
+    }
+
+
+    public class GammaHandler : ContentHandler {
+        public override System.Collections.Generic.IEnumerable<ContentType> GetContentTypes() {
+            return new[] { new ContentType { Name = "gamma" } };
+        }
+
+        public GammaHandler(IRepository<GammaRecord> repository) {
+            Filters.Add(new ActivatingFilter<Gamma>(x => x == "gamma"));
+            Filters.Add(new StorageFilter<GammaRecord>(repository));
+        }
+    }
+
+
+}

src/Orchard.Tests/ContentManagement/Stubs/Styled.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Orchard.ContentManagement;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class Styled : ContentPart {
+    }
+}

src/Orchard.Tests/ContentManagement/Stubs/StyledHandler.cs

@@ -0,0 +1,16 @@
+using Orchard.ContentManagement.Handlers;
+using Orchard.ContentManagement.ViewModels;
+
+namespace Orchard.Tests.ContentManagement.Models {
+    public class StyledHandler : ContentHandler {
+        public StyledHandler() {
+            OnGetDisplayViewModel<Styled>((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part) { Position = "10" }));
+        }
+
+        protected override void Activating(ActivatingContentContext context) {
+            if (context.ContentType == "alpha") {
+                context.Builder.Weld<Styled>();
+            }
+        }
+    }
+}