From 100fdaaedb89710553e659f337fe31d5659e2b1a Mon Sep 17 00:00:00 2001 From: loudej Date: Wed, 30 Dec 2009 19:16:17 +0000 Subject: [PATCH] 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 --- .../ContentManagement/ContentQueryTests.cs | 240 ++++++++++ .../DefaultContentManagerTests.cs | 414 ++++++++++++++++++ .../Drivers/ContentHandlerTests.cs | 51 +++ .../Drivers/ModelBuilderTests.cs | 40 ++ .../PartDriverHandlerTests.cs | 106 +++++ .../ContentManagement/Records/DeltaRecord.cs | 7 + .../Records/EpsilonRecord.cs | 7 + .../ContentManagement/Records/GammaRecord.cs | 7 + .../ContentManagement/Stubs/Alpha.cs | 6 + .../ContentManagement/Stubs/AlphaHandler.cs | 20 + .../ContentManagement/Stubs/Beta.cs | 6 + .../ContentManagement/Stubs/BetaHandler.cs | 20 + .../ContentManagement/Stubs/Delta.cs | 25 ++ .../ContentManagement/Stubs/Epsilon.cs | 23 + .../ContentManagement/Stubs/Flavored.cs | 10 + .../Stubs/FlavoredHandler.cs | 15 + .../ContentManagement/Stubs/Gamma.cs | 23 + .../ContentManagement/Stubs/Styled.cs | 10 + .../ContentManagement/Stubs/StyledHandler.cs | 16 + 19 files changed, 1046 insertions(+) create mode 100644 src/Orchard.Tests/ContentManagement/ContentQueryTests.cs create mode 100644 src/Orchard.Tests/ContentManagement/DefaultContentManagerTests.cs create mode 100644 src/Orchard.Tests/ContentManagement/Drivers/ContentHandlerTests.cs create mode 100644 src/Orchard.Tests/ContentManagement/Drivers/ModelBuilderTests.cs create mode 100644 src/Orchard.Tests/ContentManagement/PartDriverHandlerTests.cs create mode 100644 src/Orchard.Tests/ContentManagement/Records/DeltaRecord.cs create mode 100644 src/Orchard.Tests/ContentManagement/Records/EpsilonRecord.cs create mode 100644 src/Orchard.Tests/ContentManagement/Records/GammaRecord.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/AlphaHandler.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Beta.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/BetaHandler.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Delta.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Epsilon.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Flavored.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/FlavoredHandler.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Gamma.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/Styled.cs create mode 100644 src/Orchard.Tests/ContentManagement/Stubs/StyledHandler.cs diff --git a/src/Orchard.Tests/ContentManagement/ContentQueryTests.cs b/src/Orchard.Tests/ContentManagement/ContentQueryTests.cs new file mode 100644 index 000000000..22d0cab30 --- /dev/null +++ b/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().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + + builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)); + + _session = _sessionFactory.OpenSession(); + builder.Register(new DefaultContentManagerTests.TestSessionLocator(_session)).As(); + + _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(); + + } + + private void AddSampleData() { + _manager.Create("alpha", init => { }); + _manager.Create("beta", init => { }); + _manager.Create("gamma", init => { init.Record.Frap = "the frap value"; }); + _manager.Create("delta", init => { init.Record.Quux = "the quux value"; }); + _session.Flush(); + } + + [Test] + public void QueryInstanceIsDifferentEachTimeYouCreateOne() { + var contentManager1 = _container.Resolve(); + var query1a = contentManager1.Query(); + var query1b = contentManager1.Query(); + + var contentManager2 = _container.Resolve(); + 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(); + var query = contentManager.Query(); + Assert.That(query.ContentManager, Is.SameAs(contentManager)); + + var mockManager = new Moq.Mock().Object; + var anotherQuery = _container.Resolve(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()), Is.EqualTo(1)); + Assert.That(allItems.Count(x => x.Has()), Is.EqualTo(1)); + Assert.That(allItems.Count(x => x.Has()), Is.EqualTo(1)); + Assert.That(allItems.Count(x => x.Has()), 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()), Is.EqualTo(1)); + Assert.That(alphaBeta.Count(x => x.Has()), Is.EqualTo(1)); + Assert.That(alphaBeta.Count(x => x.Has()), Is.EqualTo(0)); + Assert.That(alphaBeta.Count(x => x.Has()), 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()), Is.EqualTo(0)); + Assert.That(gammaDelta.Count(x => x.Has()), Is.EqualTo(0)); + Assert.That(gammaDelta.Count(x => x.Has()), Is.EqualTo(1)); + Assert.That(gammaDelta.Count(x => x.Has()), Is.EqualTo(1)); + } + + [Test] + public void WherePredicateRestrictsResults() { + AddSampleData(); + _manager.Create("gamma", init => { init.Record.Frap = "one"; }); + _manager.Create("gamma", init => { init.Record.Frap = "two"; }); + _manager.Create("gamma", init => { init.Record.Frap = "three"; }); + _manager.Create("gamma", init => { init.Record.Frap = "four"; }); + _session.Flush(); + + var twoOrFour = _manager.Query() + .Where(x => x.Frap == "one" || x.Frap == "four") + .List(); + + Assert.That(twoOrFour.Count(), Is.EqualTo(2)); + Assert.That(twoOrFour.Count(x => x.Has()), Is.EqualTo(2)); + Assert.That(twoOrFour.Count(x => x.Get().Record.Frap == "one"), Is.EqualTo(1)); + Assert.That(twoOrFour.Count(x => x.Get().Record.Frap == "four"), Is.EqualTo(1)); + } + + + [Test] + public void EmptyWherePredicateRequiresRecord() { + AddSampleData(); + var gammas = _manager.Query().Join().List(); + var deltas = _manager.Query().Join().List(); + + Assert.That(gammas.Count(), Is.EqualTo(1)); + Assert.That(deltas.Count(), Is.EqualTo(1)); + Assert.That(gammas.AsPart().Single().Record.Frap, Is.EqualTo("the frap value")); + Assert.That(deltas.AsPart().Single().Record.Quux, Is.EqualTo("the quux value")); + } + + [Test] + public void OrderMaySortOnJoinedRecord() { + AddSampleData(); + _manager.Create("gamma", init => { init.Record.Frap = "one"; }); + _manager.Create("gamma", init => { init.Record.Frap = "two"; }); + _manager.Create("gamma", init => { init.Record.Frap = "three"; }); + _manager.Create("gamma", init => { init.Record.Frap = "four"; }); + _session.Flush(); + _session.Clear(); + + var ascending = _manager.Query("gamma") + .OrderBy(x => x.Frap) + .List().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() + .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", init => { init.Record.Frap = "one"; }); + _manager.Create("gamma", init => { init.Record.Frap = "two"; }); + _manager.Create("gamma", init => { init.Record.Frap = "three"; }); + _manager.Create("gamma", init => { init.Record.Frap = "four"; }); + _session.Flush(); + + var reverseById = _manager.Query() + .OrderByDescending(x => x.Id) + .List(); + + var subset = _manager.Query() + .OrderByDescending(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)); + + } + } +} + + + diff --git a/src/Orchard.Tests/ContentManagement/DefaultContentManagerTests.cs b/src/Orchard.Tests/ContentManagement/DefaultContentManagerTests.cs new file mode 100644 index 000000000..b8274cc0f --- /dev/null +++ b/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().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + builder.Register().As(); + + builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)); + + _session = _sessionFactory.OpenSession(); + builder.Register(new TestSessionLocator(_session)).As(); + + _container = builder.Build(); + _manager = _container.Resolve(); + } + + 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(), Is.True); + Assert.That(foo.As(), Is.Not.Null); + Assert.That(foo.Is(), Is.False); + Assert.That(foo.As(), Is.Null); + } + + [Test] + public void StronglyTypedNewShouldTypeCast() { + var foo = _manager.New("alpha"); + Assert.That(foo, Is.Not.Null); + Assert.That(foo.GetType(), Is.EqualTo(typeof(Alpha))); + } + + [Test, ExpectedException(typeof(InvalidCastException))] + public void StronglyTypedNewShouldThrowCastExceptionIfNull() { + _manager.New("alpha"); + } + + [Test] + public void AlphaIsFlavoredAndStyledAndBetaIsFlavoredOnly() { + var alpha = _manager.New("alpha"); + var beta = _manager.New("beta"); + + Assert.That(alpha.Is(), Is.True); + Assert.That(alpha.Is(), Is.True); + Assert.That(beta.Is(), Is.True); + Assert.That(beta.Is(), 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>().Get(model.Id), + Frap = "foo" + }; + + _container.Resolve>().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(), Is.True); + Assert.That(model.As().Record, Is.Not.Null); + Assert.That(model.As().Record.ContentItemRecord.Id, Is.EqualTo(model.Id)); + + } + + [Test] + public void CreateShouldMakeModelAndContentTypeRecords() { + var beta = _manager.New("beta"); + _manager.Create(beta); + + var modelRecord = _container.Resolve>().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>(); + var contentItemRepository = _container.Resolve>(); + var contentItemVersionRepository = _container.Resolve>(); + + 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"); + 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(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", 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>().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", VersionOptions.Published, init => init.Record.Frap = "version one"); + Trace.WriteLine("gamma2"); + var gamma2 = _manager.Get(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(gamma1.ContentItem.Id, VersionOptions.Published); + Trace.WriteLine("gamma2B"); + var gamma2B = _manager.Get(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", VersionOptions.Published, init => init.Record.Frap = "version one"); + var epsilon1 = gamma1.As(); + epsilon1.Record.Quad = "epsilon one"; + + var gamma2 = _manager.Get(gamma1.ContentItem.Id, VersionOptions.DraftRequired); + var epsilon2 = gamma2.As(); + + 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(gamma1.ContentItem.Id, VersionOptions.Published); + var epsilon1B = gamma1B.As(); + var gamma2B = _manager.Get(gamma1.ContentItem.Id, VersionOptions.Draft); + var epsilon2B = gamma2B.As(); + 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)); + } + } +} + diff --git a/src/Orchard.Tests/ContentManagement/Drivers/ContentHandlerTests.cs b/src/Orchard.Tests/ContentManagement/Drivers/ContentHandlerTests.cs new file mode 100644 index 000000000..f7c8544a7 --- /dev/null +++ b/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(), Is.True); + Assert.That(model.As(), Is.Not.Null); + } + + public class TestModelPart : ContentPart { + public bool CreatingCalled { get; set; } + } + + + public class TestModelHandler : ContentHandler { + public TestModelHandler() { + Filters.Add(new ActivatingFilter(x => x == "testing")); + Filters.Add(new TestModelStorageFilter()); + } + } + + public class TestModelStorageFilter : StorageFilterBase { + protected override void Creating(CreateContentContext context, TestModelPart instance) { + instance.CreatingCalled = true; + } + } + } +} + diff --git a/src/Orchard.Tests/ContentManagement/Drivers/ModelBuilderTests.cs b/src/Orchard.Tests/ContentManagement/Drivers/ModelBuilderTests.cs new file mode 100644 index 000000000..ea19ecc5c --- /dev/null +++ b/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(); + var model = builder.Build(); + + Assert.That(model.Is(), Is.True); + Assert.That(model.As(), Is.Not.Null); + Assert.That(model.Is(), Is.False); + Assert.That(model.As(), Is.Null); + } + } +} + diff --git a/src/Orchard.Tests/ContentManagement/PartDriverHandlerTests.cs b/src/Orchard.Tests/ContentManagement/PartDriverHandlerTests.cs new file mode 100644 index 000000000..7e454fcf5 --- /dev/null +++ b/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().As(); + _container = builder.Build(); + } + + [Test] + public void DriverHandlerShouldNotThrowException() { + var contentHandler = _container.Resolve(); + contentHandler.BuildDisplayModel(null); + } + + [Test] + public void AllDriversShouldBeCalled() { + var driver1 = new Mock(); + var driver2 = new Mock(); + _container.Build(x => { + x.Register(driver1.Object); + x.Register(driver2.Object); + }); + var contentHandler = _container.Resolve(); + + 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()); + + var contentHandler = _container.Resolve(); + + 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 { + 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; } + } + } + +} diff --git a/src/Orchard.Tests/ContentManagement/Records/DeltaRecord.cs b/src/Orchard.Tests/ContentManagement/Records/DeltaRecord.cs new file mode 100644 index 000000000..77f3cc08e --- /dev/null +++ b/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; } + } +} \ No newline at end of file diff --git a/src/Orchard.Tests/ContentManagement/Records/EpsilonRecord.cs b/src/Orchard.Tests/ContentManagement/Records/EpsilonRecord.cs new file mode 100644 index 000000000..bc680ac37 --- /dev/null +++ b/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; } + } +} \ No newline at end of file diff --git a/src/Orchard.Tests/ContentManagement/Records/GammaRecord.cs b/src/Orchard.Tests/ContentManagement/Records/GammaRecord.cs new file mode 100644 index 000000000..8adf9f495 --- /dev/null +++ b/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; } + } +} \ No newline at end of file diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs b/src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs new file mode 100644 index 000000000..f0e5f8db9 --- /dev/null +++ b/src/Orchard.Tests/ContentManagement/Stubs/Alpha.cs @@ -0,0 +1,6 @@ +using Orchard.ContentManagement; + +namespace Orchard.Tests.ContentManagement.Models { + public class Alpha : ContentPart { + } +} \ No newline at end of file diff --git a/src/Orchard.Tests/ContentManagement/Stubs/AlphaHandler.cs b/src/Orchard.Tests/ContentManagement/Stubs/AlphaHandler.cs new file mode 100644 index 000000000..d18ea1ac3 --- /dev/null +++ b/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((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part) { Position = "3" })); + } + public override IEnumerable GetContentTypes() { + return new[] { new ContentType { Name = "alpha" } }; + } + protected override void Activating(ActivatingContentContext context) { + if (context.ContentType == "alpha") { + context.Builder.Weld(); + } + } + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Beta.cs b/src/Orchard.Tests/ContentManagement/Stubs/Beta.cs new file mode 100644 index 000000000..707e75c03 --- /dev/null +++ b/src/Orchard.Tests/ContentManagement/Stubs/Beta.cs @@ -0,0 +1,6 @@ +using Orchard.ContentManagement; + +namespace Orchard.Tests.ContentManagement.Models { + public class Beta : ContentPart { + } +} \ No newline at end of file diff --git a/src/Orchard.Tests/ContentManagement/Stubs/BetaHandler.cs b/src/Orchard.Tests/ContentManagement/Stubs/BetaHandler.cs new file mode 100644 index 000000000..69d6b4ab2 --- /dev/null +++ b/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 GetContentTypes() { + return new[] { new ContentType { Name = "beta" } }; + } + + protected override void Activating(ActivatingContentContext context) { + if (context.ContentType == "beta") { + context.Builder.Weld(); + } + } + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Delta.cs b/src/Orchard.Tests/ContentManagement/Stubs/Delta.cs new file mode 100644 index 000000000..4e164aeb0 --- /dev/null +++ b/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 { + } + + + public class DeltaHandler : ContentHandler { + public override System.Collections.Generic.IEnumerable GetContentTypes() { + return new[] { new ContentType { Name = "delta" } }; + } + + public DeltaHandler(IRepository repository) { + Filters.Add(new ActivatingFilter(x => x == "delta")); + Filters.Add(new StorageFilter(repository)); + } + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Epsilon.cs b/src/Orchard.Tests/ContentManagement/Stubs/Epsilon.cs new file mode 100644 index 000000000..bd57b5c22 --- /dev/null +++ b/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 { + } + + public class EpsilonHandler : ContentHandler { + + public EpsilonHandler(IRepository repository) { + Filters.Add(new ActivatingFilter(x => x == "gamma")); + Filters.Add(new StorageVersionFilter(repository)); + } + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Flavored.cs b/src/Orchard.Tests/ContentManagement/Stubs/Flavored.cs new file mode 100644 index 000000000..7ab980c83 --- /dev/null +++ b/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 { + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/FlavoredHandler.cs b/src/Orchard.Tests/ContentManagement/Stubs/FlavoredHandler.cs new file mode 100644 index 000000000..a5665f860 --- /dev/null +++ b/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((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part))); + } + protected override void Activating(ActivatingContentContext context) { + if (context.ContentType == "beta" || context.ContentType == "alpha") { + context.Builder.Weld(); + } + } + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Gamma.cs b/src/Orchard.Tests/ContentManagement/Stubs/Gamma.cs new file mode 100644 index 000000000..29456e14f --- /dev/null +++ b/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 { + } + + + public class GammaHandler : ContentHandler { + public override System.Collections.Generic.IEnumerable GetContentTypes() { + return new[] { new ContentType { Name = "gamma" } }; + } + + public GammaHandler(IRepository repository) { + Filters.Add(new ActivatingFilter(x => x == "gamma")); + Filters.Add(new StorageFilter(repository)); + } + } + + +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/Styled.cs b/src/Orchard.Tests/ContentManagement/Stubs/Styled.cs new file mode 100644 index 000000000..f2c9658bb --- /dev/null +++ b/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 { + } +} diff --git a/src/Orchard.Tests/ContentManagement/Stubs/StyledHandler.cs b/src/Orchard.Tests/ContentManagement/Stubs/StyledHandler.cs new file mode 100644 index 000000000..5fe02ecef --- /dev/null +++ b/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((ctx, part) => ctx.AddDisplay(new TemplateViewModel(part) { Position = "10" })); + } + + protected override void Activating(ActivatingContentContext context) { + if (context.ContentType == "alpha") { + context.Builder.Weld(); + } + } + } +}