mirror of
https://github.com/OrchardCMS/Orchard.git
synced 2025-07-16 04:49:26 +08:00
612 lines
26 KiB
C#
612 lines
26 KiB
C#
using System.Linq;
|
|
using Autofac;
|
|
using Moq;
|
|
using NHibernate;
|
|
using NUnit.Framework;
|
|
using Orchard.Caching;
|
|
using Orchard.ContentManagement.MetaData;
|
|
using Orchard.Data;
|
|
using Orchard.ContentManagement;
|
|
using Orchard.ContentManagement.Handlers;
|
|
using Orchard.ContentManagement.Records;
|
|
using Orchard.DisplayManagement;
|
|
using Orchard.DisplayManagement.Descriptors;
|
|
using Orchard.Environment.Extensions;
|
|
using Orchard.Tests.ContentManagement.Handlers;
|
|
using Orchard.Tests.ContentManagement.Records;
|
|
using Orchard.Tests.ContentManagement.Models;
|
|
using Orchard.DisplayManagement.Implementation;
|
|
using Orchard.Tests.Stubs;
|
|
using NHibernate.Impl;
|
|
using Orchard.UI.PageClass;
|
|
using System.Collections.Generic;
|
|
|
|
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(EpsilonRecord),
|
|
typeof(ContentItemVersionRecord),
|
|
typeof(ContentItemRecord),
|
|
typeof(ContentTypeRecord));
|
|
}
|
|
|
|
[SetUp]
|
|
public void Init() {
|
|
var builder = new ContainerBuilder();
|
|
|
|
builder.RegisterModule(new ContentModule());
|
|
builder.RegisterType<DefaultContentManager>().As<IContentManager>().SingleInstance();
|
|
builder.RegisterType<StubCacheManager>().As<ICacheManager>();
|
|
builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>();
|
|
builder.RegisterInstance(new Mock<IContentDefinitionManager>().Object);
|
|
builder.RegisterInstance(new Mock<IContentDisplay>().Object);
|
|
|
|
builder.RegisterType<AlphaPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<BetaPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<GammaPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<DeltaPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<EpsilonPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<FlavoredPartHandler>().As<IContentHandler>();
|
|
builder.RegisterType<StyledHandler>().As<IContentHandler>();
|
|
builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>();
|
|
builder.RegisterType<ShapeTableLocator>().As<IShapeTableLocator>();
|
|
builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>();
|
|
|
|
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
|
|
|
|
builder.RegisterType<StubExtensionManager>().As<IExtensionManager>();
|
|
builder.RegisterInstance(new Mock<IPageClassBuilder>().Object);
|
|
builder.RegisterType<DefaultContentDisplay>().As<IContentDisplay>();
|
|
|
|
_session = _sessionFactory.OpenSession();
|
|
builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>();
|
|
|
|
_session.Delete(string.Format("from {0}", typeof(GammaRecord).FullName));
|
|
_session.Delete(string.Format("from {0}", typeof(DeltaRecord).FullName));
|
|
_session.Delete(string.Format("from {0}", typeof(EpsilonRecord).FullName));
|
|
_session.Delete(string.Format("from {0}", typeof(ContentItemVersionRecord).FullName));
|
|
_session.Delete(string.Format("from {0}", typeof(ContentItemRecord).FullName));
|
|
_session.Delete(string.Format("from {0}", typeof(ContentTypeRecord).FullName));
|
|
_session.Flush();
|
|
_session.Clear();
|
|
|
|
_container = builder.Build();
|
|
_manager = _container.Resolve<IContentManager>();
|
|
|
|
}
|
|
|
|
private List<IContent> AddSampleData() {
|
|
var items = new List<IContent> {
|
|
_manager.Create<AlphaPart>("alpha", init => { }),
|
|
_manager.Create<BetaPart>("beta", init => { }),
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "the frap value"; }),
|
|
_manager.Create<DeltaPart>("delta", init => { init.Record.Quux = "the quux value"; })
|
|
};
|
|
|
|
_session.Flush();
|
|
|
|
return items;
|
|
}
|
|
|
|
[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<AlphaPart>()), Is.EqualTo(1));
|
|
Assert.That(allItems.Count(x => x.Has<BetaPart>()), Is.EqualTo(1));
|
|
Assert.That(allItems.Count(x => x.Has<GammaPart>()), Is.EqualTo(1));
|
|
Assert.That(allItems.Count(x => x.Has<DeltaPart>()), 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<AlphaPart>()), Is.EqualTo(1));
|
|
Assert.That(alphaBeta.Count(x => x.Has<BetaPart>()), Is.EqualTo(1));
|
|
Assert.That(alphaBeta.Count(x => x.Has<GammaPart>()), Is.EqualTo(0));
|
|
Assert.That(alphaBeta.Count(x => x.Has<DeltaPart>()), 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<AlphaPart>()), Is.EqualTo(0));
|
|
Assert.That(gammaDelta.Count(x => x.Has<BetaPart>()), Is.EqualTo(0));
|
|
Assert.That(gammaDelta.Count(x => x.Has<GammaPart>()), Is.EqualTo(1));
|
|
Assert.That(gammaDelta.Count(x => x.Has<DeltaPart>()), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void NoItemIsReturnedIfNoItemsSpecified() {
|
|
AddSampleData();
|
|
|
|
var items = _manager.Query().ForContentItems(new int[] { }).List();
|
|
|
|
Assert.That(items.Count(), Is.EqualTo(0));
|
|
}
|
|
|
|
[Test]
|
|
public void ItemsSpecifiedAreReturnedWhenSpecified() {
|
|
var samples = AddSampleData();
|
|
|
|
|
|
var betaGamma = _manager.Query().ForContentItems(new int[] { samples[1].ContentItem.Id, samples[2].ContentItem.Id }).List();
|
|
|
|
Assert.That(betaGamma.Count(), Is.EqualTo(2));
|
|
Assert.That(betaGamma.Count(x => x.Has<AlphaPart>()), Is.EqualTo(0));
|
|
Assert.That(betaGamma.Count(x => x.Has<BetaPart>()), Is.EqualTo(1));
|
|
Assert.That(betaGamma.Count(x => x.Has<GammaPart>()), Is.EqualTo(1));
|
|
Assert.That(betaGamma.Count(x => x.Has<DeltaPart>()), Is.EqualTo(0));
|
|
|
|
var alphaDelta = _manager.Query()
|
|
.ForContentItems(new int[] { samples[0].ContentItem.Id, samples[3].ContentItem.Id })
|
|
.List();
|
|
|
|
Assert.That(alphaDelta.Count(), Is.EqualTo(2));
|
|
Assert.That(alphaDelta.Count(x => x.Has<AlphaPart>()), Is.EqualTo(1));
|
|
Assert.That(alphaDelta.Count(x => x.Has<BetaPart>()), Is.EqualTo(0));
|
|
Assert.That(alphaDelta.Count(x => x.Has<GammaPart>()), Is.EqualTo(0));
|
|
Assert.That(alphaDelta.Count(x => x.Has<DeltaPart>()), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void ItemsSpecifiedCanBeFiltered() {
|
|
AddSampleData();
|
|
var oneId = _manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; }).ContentItem.Id;
|
|
var twoId = _manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; }).ContentItem.Id;
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
var fourId = _manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; }).ContentItem.Id;
|
|
_session.Flush();
|
|
|
|
|
|
var two = _manager.Query()
|
|
.ForContentItems(new int[] { oneId, twoId, fourId })
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.List();
|
|
|
|
Assert.That(two.Count(), Is.EqualTo(1));
|
|
Assert.That(two.Count(x => x.Has<GammaPart>()), Is.EqualTo(1));
|
|
Assert.That(two.Count(x => x.Get<GammaPart>().Record.Frap == "two"), Is.EqualTo(1));
|
|
|
|
var none = _manager.Query()
|
|
.ForContentItems(new int[] { oneId, twoId, fourId })
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.List();
|
|
|
|
Assert.That(none.Count(), Is.EqualTo(0));
|
|
}
|
|
|
|
[Test]
|
|
public void WherePredicateRestrictsResults() {
|
|
AddSampleData();
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
|
|
var twoOrFour = _manager.Query<GammaPart, GammaRecord>()
|
|
.Where(x => x.Frap == "one" || x.Frap == "four")
|
|
.List();
|
|
|
|
Assert.That(twoOrFour.Count(), Is.EqualTo(2));
|
|
Assert.That(twoOrFour.Count(x => x.Has<GammaPart>()), Is.EqualTo(2));
|
|
Assert.That(twoOrFour.Count(x => x.Get<GammaPart>().Record.Frap == "one"), Is.EqualTo(1));
|
|
Assert.That(twoOrFour.Count(x => x.Get<GammaPart>().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<GammaPart>().Single().Record.Frap, Is.EqualTo("the frap value"));
|
|
Assert.That(deltas.AsPart<DeltaPart>().Single().Record.Quux, Is.EqualTo("the quux value"));
|
|
}
|
|
|
|
[Test]
|
|
public void OrderMaySortOnJoinedRecord() {
|
|
AddSampleData();
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
_session.Clear();
|
|
|
|
var ascending = _manager.Query("gamma")
|
|
.OrderBy<GammaRecord>(x => x.Frap)
|
|
.List<GammaPart>().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<GammaPart, 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<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
|
|
var reverseById = _manager.Query()
|
|
.OrderByDescending<GammaRecord>(x => x.Id)
|
|
.List();
|
|
|
|
var subset = _manager.Query()
|
|
.OrderByDescending<GammaRecord>(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));
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void CountReturnsNumber() {
|
|
AddSampleData();
|
|
|
|
var count = _manager.Query()
|
|
.Count();
|
|
|
|
Assert.That(count, Is.EqualTo(4));
|
|
}
|
|
|
|
[Test]
|
|
public void QueryShouldJoinVersionedRecords() {
|
|
AddSampleData();
|
|
_manager.Create<GammaPart>("gamma", init => {
|
|
init.Record.Frap = "one";
|
|
init.As<EpsilonPart>().Record.Quad = "1";
|
|
});
|
|
_manager.Create<GammaPart>("gamma", init => {
|
|
init.Record.Frap = "two";
|
|
init.As<EpsilonPart>().Record.Quad = "2";
|
|
});
|
|
_manager.Create<GammaPart>("gamma", init => {
|
|
init.Record.Frap = "three";
|
|
init.As<EpsilonPart>().Record.Quad = "3";
|
|
});
|
|
_manager.Create<GammaPart>("gamma", init => {
|
|
init.Record.Frap = "four";
|
|
init.As<EpsilonPart>().Record.Quad = "4";
|
|
});
|
|
_session.Flush();
|
|
_session.Clear();
|
|
|
|
var results = _manager.Query<EpsilonPart, EpsilonRecord>()
|
|
.Where(x => x.Quad == "2" || x.Quad == "3")
|
|
.OrderByDescending(x => x.Quad)
|
|
.List();
|
|
|
|
Assert.That(results.Count(), Is.EqualTo(2));
|
|
Assert.That(results.First().Record, Has.Property("Quad").EqualTo("3"));
|
|
Assert.That(results.Last().Record, Has.Property("Quad").EqualTo("2"));
|
|
}
|
|
|
|
|
|
private void AddGammaVersions() {
|
|
var gamma1 = _manager.Create<ContentItem>("gamma", init => {
|
|
init.As<GammaPart>().Record.Frap = "one";
|
|
init.As<EpsilonPart>().Record.Quad = "v1";
|
|
});
|
|
_session.Flush();
|
|
_session.Clear();
|
|
|
|
var gamma2 = _manager.Get(gamma1.Id, VersionOptions.DraftRequired);
|
|
gamma2.As<GammaPart>().Record.Frap = "two";
|
|
gamma2.As<EpsilonPart>().Record.Quad = "v2";
|
|
_session.Flush();
|
|
_session.Clear();
|
|
|
|
var gamma3 = _manager.Create<ContentItem>("gamma", init => {
|
|
init.As<GammaPart>().Record.Frap = "three";
|
|
init.As<EpsilonPart>().Record.Quad = "v3";
|
|
});
|
|
_session.Flush();
|
|
_session.Clear();
|
|
}
|
|
|
|
[Test]
|
|
public void QueryShouldOnlyReturnPublishedByDefault() {
|
|
AddGammaVersions();
|
|
|
|
var list1 = _manager.Query<GammaPart>()
|
|
.Where<EpsilonRecord>(x => x.Quad == "v1")
|
|
.List();
|
|
|
|
var list2 = _manager.Query<GammaPart>()
|
|
.Where<EpsilonRecord>(x => x.Quad == "v2")
|
|
.List();
|
|
|
|
var list3 = _manager.Query<GammaPart>()
|
|
.Where<EpsilonRecord>(x => x.Quad == "v3")
|
|
.List();
|
|
|
|
var listOne = _manager.Query<GammaPart>()
|
|
.Where<GammaRecord>(x => x.Frap == "one")
|
|
.List();
|
|
|
|
var listTwo = _manager.Query<GammaPart>()
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.List();
|
|
|
|
var listThree = _manager.Query<GammaPart>()
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.List();
|
|
|
|
Assert.That(list1.Count(), Is.EqualTo(1));
|
|
Assert.That(list2.Count(), Is.EqualTo(0));
|
|
Assert.That(list3.Count(), Is.EqualTo(1));
|
|
Assert.That(listOne.Count(), Is.EqualTo(0));
|
|
Assert.That(listTwo.Count(), Is.EqualTo(1));
|
|
Assert.That(listThree.Count(), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void QueryForLatestShouldNotReturnEarlierVersions() {
|
|
AddGammaVersions();
|
|
|
|
var list1 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v1")
|
|
.List();
|
|
|
|
var count1 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v1")
|
|
.Count();
|
|
|
|
var list2 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v2")
|
|
.List();
|
|
|
|
var count2 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v2")
|
|
.Count();
|
|
|
|
var list3 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v3")
|
|
.List();
|
|
|
|
var count3 = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v3")
|
|
.Count();
|
|
|
|
var listOne = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "one")
|
|
.List();
|
|
|
|
var countOne = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "one")
|
|
.Count();
|
|
|
|
var listTwo = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.List();
|
|
|
|
var countTwo = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.Count();
|
|
|
|
var listThree = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.List();
|
|
|
|
var countThree = _manager.Query<GammaPart>(VersionOptions.Latest)
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.Count();
|
|
|
|
Assert.That(list1.Count(), Is.EqualTo(0));
|
|
Assert.That(count1, Is.EqualTo(0));
|
|
Assert.That(list2.Count(), Is.EqualTo(1));
|
|
Assert.That(count2, Is.EqualTo(1));
|
|
Assert.That(list3.Count(), Is.EqualTo(1));
|
|
Assert.That(count3, Is.EqualTo(1));
|
|
Assert.That(listOne.Count(), Is.EqualTo(0));
|
|
Assert.That(countOne, Is.EqualTo(0));
|
|
Assert.That(listTwo.Count(), Is.EqualTo(1));
|
|
Assert.That(countTwo, Is.EqualTo(1));
|
|
Assert.That(listThree.Count(), Is.EqualTo(1));
|
|
Assert.That(countThree, Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void QueryForDraftShouldOnlyReturnLatestThatIsNotPublished() {
|
|
AddGammaVersions();
|
|
|
|
var list1 = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v1")
|
|
.List();
|
|
|
|
var list2 = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v2")
|
|
.List();
|
|
|
|
var list3 = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v3")
|
|
.List();
|
|
|
|
var listOne = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<GammaRecord>(x => x.Frap == "one")
|
|
.List();
|
|
|
|
var listTwo = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.List();
|
|
|
|
var listThree = _manager.Query<GammaPart>(VersionOptions.Draft)
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.List();
|
|
|
|
Assert.That(list1.Count(), Is.EqualTo(0));
|
|
Assert.That(list2.Count(), Is.EqualTo(1));
|
|
Assert.That(list3.Count(), Is.EqualTo(0));
|
|
Assert.That(listOne.Count(), Is.EqualTo(0));
|
|
Assert.That(listTwo.Count(), Is.EqualTo(1));
|
|
Assert.That(listThree.Count(), Is.EqualTo(0));
|
|
}
|
|
|
|
[Test]
|
|
public void QueryForAllShouldReturnMultipleQualifiedVersions() {
|
|
AddGammaVersions();
|
|
|
|
var list1 = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v1")
|
|
.List();
|
|
|
|
var list2 = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v2")
|
|
.List();
|
|
|
|
var list3 = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<EpsilonRecord>(x => x.Quad == "v3")
|
|
.List();
|
|
|
|
var listOne = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<GammaRecord>(x => x.Frap == "one")
|
|
.List();
|
|
|
|
var listTwo = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<GammaRecord>(x => x.Frap == "two")
|
|
.List();
|
|
|
|
var listThree = _manager.Query<GammaPart>(VersionOptions.AllVersions)
|
|
.Where<GammaRecord>(x => x.Frap == "three")
|
|
.List();
|
|
|
|
Assert.That(list1.Count(), Is.EqualTo(1));
|
|
Assert.That(list2.Count(), Is.EqualTo(1));
|
|
Assert.That(list3.Count(), Is.EqualTo(1));
|
|
Assert.That(listOne.Count(), Is.EqualTo(0));
|
|
Assert.That(listTwo.Count(), Is.EqualTo(2));
|
|
Assert.That(listThree.Count(), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void StartsWithExtensionShouldBeUsed() {
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
|
|
var result = _manager.Query<GammaPart, GammaRecord>()
|
|
.Where(x => x.Frap.StartsWith("t"))
|
|
.List();
|
|
|
|
Assert.That(result.Count(), Is.EqualTo(2));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "two"), Is.EqualTo(1));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "three"), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void EndsWithExtensionShouldBeUsed() {
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
|
|
var result = _manager.Query<GammaPart, GammaRecord>()
|
|
.Where(x => x.Frap.EndsWith("e"))
|
|
.List();
|
|
|
|
Assert.That(result.Count(), Is.EqualTo(2));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "one"), Is.EqualTo(1));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "three"), Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void ContainsExtensionShouldBeUsed() {
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "one"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "two"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "three"; });
|
|
_manager.Create<GammaPart>("gamma", init => { init.Record.Frap = "four"; });
|
|
_session.Flush();
|
|
|
|
var result = _manager.Query<GammaPart, GammaRecord>()
|
|
.Where(x => x.Frap.Contains("o"))
|
|
.List();
|
|
|
|
Assert.That(result.Count(), Is.EqualTo(3));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "one"), Is.EqualTo(1));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "two"), Is.EqualTo(1));
|
|
Assert.That(result.Count(x => x.Get<GammaPart>().Record.Frap == "four"), Is.EqualTo(1));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|