public void TypedEntity_SingleOrDefault_ByAttributeValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) == "not-on-red-herring");
// Assert
var singleOrDefault = query.SingleOrDefault();
Assert.IsNotNull(singleOrDefault);
Assert.AreEqual(newGuid, (Guid)singleOrDefault.Id.Value);
// Now do another query which should return two, and ensure SingleOrDefault chucks an error our way
var queryToFail = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <string>(AttributeAlias1ForQuerying) == "my-test-value1");
// Assert
try
{
var resultToFail = queryToFail.SingleOrDefault();
Assert.Fail("SingleOrDefault did not throw an error; result could should have been 2");
}
catch (InvalidOperationException)
{
/* Do nothing */
}
}
}
public TemplateEditorController(IBackOfficeRequestContext requestContext) : base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter<IFileStore>(new Uri("storage://templates"));
}
public void WhenSourceIsAccessed_LazyRelation_CallsRepository_WithBothSourceAndDestinationId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
var lazyRelation = new LazyRelation<TypedEntity>(uow.Repositories, FixedRelationTypes.DefaultRelationType, int1, int2, 0);
IReadonlyRelation<IRelatableEntity, IRelatableEntity> blah = lazyRelation;
IRelationById blah2 = lazyRelation;
Assert.False(lazyRelation.IsLoaded);
var source = lazyRelation.Source;
Assert.True(lazyRelation.IsLoaded);
var dest = lazyRelation.Destination;
Assert.NotNull(source);
Assert.NotNull(dest);
}
}
public void TypedEntity_Count_WithAndAlsoBinary_ByAttributeValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext
.Query().Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) == "not-on-red-herring" &&
x.Attribute <string>(AttributeAlias1ForQuerying) == "my-test-value1");
// Assert
Assert.AreEqual(1, query.Count());
}
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext
.Query()
.InIds(entity.Id)
.Where(x => (x.Attribute <string>(AttributeAlias2ForQuerying) == "not-on-red-herring" && x.Attribute <string>(AttributeAlias1ForQuerying) == "my-test-value1") &&
x.Attribute <string>(AttributeAlias1ForQuerying) == "my-test-value1");
// Assert
Assert.AreEqual(1, query.Count());
}
}
public void WhenListQueryHasSkipOrTake_ItemsAreSkipped()
{
const int totalExpected = 15;
for (int i = 0; i < totalExpected; i++)
{
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
}
using (var uow = GroupUnitFactory.Create())
{
var count = uow.Repositories.Query().Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring");
Assert.That(count.ToList().Count, Is.EqualTo(totalExpected));
count = uow.Repositories.Query().Skip(5).Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring");
Assert.That(count.ToList().Count, Is.EqualTo(totalExpected - 5));
count = uow.Repositories.Query().Skip(5).Take(6).Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring");
Assert.That(count.ToList().Count, Is.EqualTo(6));
count = uow.Repositories.Query().OrderByDescending(x => x.UtcCreated).Take(5);
Assert.That(count.ToList().Count, Is.EqualTo(5));
}
}
public void WhenGetIsCalled_WithMultipleIds_MultipleItemsAreReturned(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
HiveId int3 = HiveId.ConvertIntToGuid(3);
// Act & Assert
using (var uow = groupUnitFactory.Create<IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
// TODO: This looks like a poor test since Get with multiple ids is actually just mocked to return three
// but the purpose of this test is to establish that when running with multiple providers, some of which
// are passthrough, only the correct number of items should be returned
var items = uow.Repositories.Get<TypedEntity>(true, int1, int2, int3);
Assert.That(items.Count(), Is.EqualTo(3 * numbProviderCount), "item count wrong");
// Assert that the correct number of relations are returned too including passthrough providers being filtered for
var parents = uow.Repositories.GetParentRelations(HiveId.Empty);
Assert.That(parents.Count(), Is.EqualTo(GroupedProviderMockHelper.MockRelationCount * numbProviderCount), "parents count wrong");
}
}
public void WhenListQueryHasOrder_ResultsAreOrdered()
{
const int totalExpected = 15;
for (int i = 0; i < totalExpected; i++)
{
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
}
using (var uow = GroupUnitFactory.Create())
{
var dbResults = uow.Repositories
.Query()
.Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring")
.OrderByDescending(x => x.UtcModified)
.Take(5)
.ToList();
var inMemResults = uow.Repositories
.Query()
.Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring")
.ToList()
.OrderByDescending(x => x.UtcModified)
.Take(5)
.ToList();
for (int i = 0; i < dbResults.Count; i++)
{
var item = dbResults[i];
var inMemItem = inMemResults[i];
Assert.That(inMemItem.Id, Is.EqualTo(item.Id));
}
//Ascending
dbResults = uow.Repositories
.Query()
.Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring")
.OrderBy(x => x.UtcModified)
.Take(5)
.ToList();
inMemResults = uow.Repositories
.Query()
.Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) != "not-on-red-herring")
.ToList()
.OrderBy(x => x.UtcModified)
.Take(5)
.ToList();
for (int i = 0; i < dbResults.Count; i++)
{
var item = dbResults[i];
var inMemItem = inMemResults[i];
Assert.That(inMemItem.Id, Is.EqualTo(item.Id));
}
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_ItsRelationProxies_HaveAbsoluteId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var item = uow.Repositories.Get <TypedEntity>(HiveId.Empty);
AssertIdsOfRelationProxiesForEntity(item, idRoot);
var items = uow.Repositories.GetAll <TypedEntity>();
Assert.True(items.Any());
foreach (var typedEntity in items)
{
AssertIdsOfRelationProxiesForEntity(typedEntity, idRoot);
}
}
}
public TemplateEditorController(IBackOfficeRequestContext requestContext) : base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter <IFileStore>(new Uri("storage://templates"));
}
public void WhenGetIsCalled_WithMultipleIds_MultipleItemsAreReturned(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
HiveId int3 = HiveId.ConvertIntToGuid(3);
// Act & Assert
using (var uow = groupUnitFactory.Create <IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
// TODO: This looks like a poor test since Get with multiple ids is actually just mocked to return three
// but the purpose of this test is to establish that when running with multiple providers, some of which
// are passthrough, only the correct number of items should be returned
var items = uow.Repositories.Get <TypedEntity>(true, int1, int2, int3);
Assert.That(items.Count(), Is.EqualTo(3 * numbProviderCount), "item count wrong");
// Assert that the correct number of relations are returned too including passthrough providers being filtered for
var parents = uow.Repositories.GetParentRelations(HiveId.Empty);
Assert.That(parents.Count(), Is.EqualTo(GroupedProviderMockHelper.MockRelationCount * numbProviderCount), "parents count wrong");
}
}
public void WhenSourceIsAccessed_LazyRelation_CallsRepository_WithBothSourceAndDestinationId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
var lazyRelation = new LazyRelation <TypedEntity>(uow.Repositories, FixedRelationTypes.DefaultRelationType, int1, int2, 0);
IReadonlyRelation <IRelatableEntity, IRelatableEntity> blah = lazyRelation;
IRelationById blah2 = lazyRelation;
Assert.False(lazyRelation.IsLoaded);
var source = lazyRelation.Source;
Assert.True(lazyRelation.IsLoaded);
var dest = lazyRelation.Destination;
Assert.NotNull(source);
Assert.NotNull(dest);
}
}
public void TypedEntity_ByAttributeValue_Equals_WithBoolean()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <bool>(HiveModelCreationHelper.BoolDefAlias) == true);
// Assert
var items = query.ToList();
Assert.IsNotNull(items);
Assert.AreEqual(1, items.Count);
var firstItem = items.First();
Assert.AreEqual(newGuid, (Guid)firstItem.Id.Value);
// Query for the opposite (the red-herring node)
var query_opposite = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <bool>(HiveModelCreationHelper.BoolDefAlias) == false);
// Assert again
var items_opposite = query_opposite.ToList();
Assert.IsNotNull(items_opposite);
Assert.AreEqual(1, items_opposite.Count);
Assert.AreEqual(newGuidRedHerring, (Guid)items_opposite.First().Id.Value);
}
}
public void CountUsesSpecifiedRevision()
{
// Arrange
LogHelper.TraceIfEnabled(typeof(QueryExtensions), "In CountUsesSpecifiedRevision");
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var twoRevisionsOfOneEntity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
AddRevision(twoRevisionsOfOneEntity, FixedStatusTypes.Published);
AddRevision(twoRevisionsOfOneEntity, FixedStatusTypes.Published);
var revisionStatusType = new RevisionStatusType("custom", "custom for test");
var oneRevisionOfAnEntity = CreateEntityForTest(Guid.NewGuid(), Guid.NewGuid(), ProviderSetup);
AddRevision(oneRevisionOfAnEntity, revisionStatusType);
var anotherRevisionOfSameType = CreateEntityForTest(Guid.NewGuid(), Guid.NewGuid(), ProviderSetup);
AddRevision(anotherRevisionOfSameType, revisionStatusType);
// Act
using (var uow = GroupUnitFactory.Create())
{
var countOfCustomType = uow.Repositories.OfRevisionType(revisionStatusType.Alias).Count();
var countOfPublished = uow.Repositories.OfRevisionType(FixedStatusTypes.Published).Count();
// Assert
Assert.That(countOfCustomType, Is.EqualTo(2));
Assert.That(countOfPublished, Is.EqualTo(1));
Thread.Sleep(500); // Let profiler catch up
}
}
public StylesheetEditorController(IBackOfficeRequestContext requestContext)
: base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter <IFileStore>(new Uri("storage://stylesheets"));
}
//BUG: Well, not sure if this is a bug or not really but there's currently only 1 way to get the root HiveId for an IO
// entity and thats to get Hive to return the entity based on a '/' Id.
public static HiveId GetRootNodeId(this GroupUnitFactory <IFileStore> factory)
{
using (var uow = factory.Create())
{
var e = uow.Repositories.Get <File>(new HiveId("/"));
return(e.Id);
}
}
public MacroPartialsEditorController(IBackOfficeRequestContext requestContext)
: base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter<IFileStore>(new Uri("storage://macro-partials"));
}
public DictionaryEditorController(IBackOfficeRequestContext requestContext)
: base(requestContext)
{
_hive = BackOfficeRequestContext.Application.Hive.GetWriter(new Uri("dictionary://"));
_readonlyHive = BackOfficeRequestContext.Application.Hive.GetReader <IContentStore>();
Mandate.That(_hive != null, x => new NullReferenceException("Could not find hive provider for route dictionary://"));
}
public StylesheetEditorController(IBackOfficeRequestContext requestContext)
: base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter<IFileStore>(new Uri("storage://stylesheets"));
}
public void Setup()
{
_frameworkContext = new FakeFrameworkContext();
_unitScopedCache = new DictionaryScopedCache();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 1, _frameworkContext);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
_groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(_frameworkContext), _frameworkContext, () => _unitScopedCache);
}
public MacroPartialsEditorController(IBackOfficeRequestContext requestContext)
: base(requestContext)
{
_hive = BackOfficeRequestContext
.Application
.Hive
.GetWriter <IFileStore>(new Uri("storage://macro-partials"));
}
public void Setup()
{
_frameworkContext = new FakeFrameworkContext();
_unitScopedCache = new DictionaryScopedCache();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 1, _frameworkContext);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
_groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(_frameworkContext), _frameworkContext, () => _unitScopedCache);
}
public UploadEditorModel(UploadPreValueModel preValueModel, IBackOfficeRequestContext backOfficeRequestContext,
HiveId contentId, string propertyAlias)
: base(preValueModel)
{
_backOfficeRequestContext = backOfficeRequestContext;
_hive = _backOfficeRequestContext.Application.Hive.GetWriter <IFileStore>(new Uri("storage://file-uploader"));
_contentId = contentId;
_propertyAlias = propertyAlias;
}
private void AddRevision(TypedEntity entity, RevisionStatusType revisionStatusType)
{
using (var uow = GroupUnitFactory.Create())
{
// Make a new revision that is published
var revision = new Revision <TypedEntity>(entity);
revision.MetaData.StatusType = revisionStatusType;
uow.Repositories.Revisions.AddOrUpdate(revision);
uow.Complete();
}
}
public void UserGroup_ByName_IncludingInferredSchemaType_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
var userGroup = new UserGroup()
{
Name = "Anonymous", Id = new HiveId(newGuid)
};
using (var uow = ProviderSetup.UnitFactory.Create())
{
uow.EntityRepository.AddOrUpdate(new SystemRoot());
uow.EntityRepository.AddOrUpdate(Framework.Security.Model.FixedEntities.UserGroupVirtualRoot);
uow.EntityRepository.AddOrUpdate(userGroup);
uow.Complete();
}
// Act
using (var uow = GroupUnitFactory.Create())
{
var checkSchemaExists = uow.Repositories.Schemas.Get <EntitySchema>(new UserGroupSchema().Id);
Assert.NotNull(checkSchemaExists);
var genericQuery = uow.Repositories.QueryContext.Query <TypedEntity>()
.Where(x => x.Attribute <string>(NodeNameAttributeDefinition.AliasValue) == "Anonymous")
.ToList()
.Select(x => x.Id);
// Assert
Assert.AreEqual(1, genericQuery.Count());
var queryAll = uow.Repositories.QueryContext.Query <UserGroup>().ToList();
Assert.That(queryAll.Count(), Is.EqualTo(1));
var queryAll2 = uow.Repositories.Query <UserGroup>().ToList();
Assert.That(queryAll2.Count(), Is.EqualTo(1));
var query = uow.Repositories.QueryContext.Query <UserGroup>()
.Where(x => x.Name == "Anonymous").ToList();
// Assert
Assert.AreEqual(1, query.Count());
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
Assert.AreEqual(new UserGroupSchema().Alias, item.EntitySchema.Alias);
}
}
protected void TestSetup()
{
_helper = new NhibernateTestSetupHelper();
//_helper = new NhibernateTestSetupHelper(useNhProf:true);
//_helper = new NhibernateTestSetupHelper(@"Data Source=c:\temp\test.s3db;Version=3;",
// SupportedNHDrivers.SqlLite,
// "call",
// true,
// useNhProf: true);
//_helper = new NhibernateTestSetupHelper(@"data source=.\sqlexpress2008;initial catalog=v5units;user id=rebel;password=rebel", SupportedNHDrivers.MsSql2008, "call", true, useNhProf: true);
//_helper = new NhibernateTestSetupHelper(@"data source=C:\Users\Alex\Documents\My Web Sites\Rebel.Cms.Web.UI-Site\App_Data\Test2.sdf", SupportedNHDrivers.MsSqlCe4, "call", true, useNhProf: true);
_groupUnitFactory = new GroupUnitFactory(_helper.ProviderSetup, new Uri("content://"), FakeHiveCmsManager.CreateFakeRepositoryContext(_helper.FakeFrameworkContext));
}
protected void TestSetup()
{
_helper = new NhibernateTestSetupHelper();
//_helper = new NhibernateTestSetupHelper(useNhProf:true);
//_helper = new NhibernateTestSetupHelper(@"Data Source=c:\temp\test.s3db;Version=3;",
// SupportedNHDrivers.SqlLite,
// "call",
// true,
// useNhProf: true);
//_helper = new NhibernateTestSetupHelper(@"data source=.\sqlexpress2008;initial catalog=v5units;user id=rebel;password=rebel", SupportedNHDrivers.MsSql2008, "call", true, useNhProf: true);
//_helper = new NhibernateTestSetupHelper(@"data source=C:\Users\Alex\Documents\My Web Sites\Rebel.Cms.Web.UI-Site\App_Data\Test2.sdf", SupportedNHDrivers.MsSqlCe4, "call", true, useNhProf: true);
_groupUnitFactory = new GroupUnitFactory(_helper.ProviderSetup, new Uri("content://"), FakeHiveCmsManager.CreateFakeRepositoryContext(_helper.FakeFrameworkContext));
}
public void WhenEntitiesAreQueried_ResultsArePutInScopedCache()
{
// Arrange
var permission = new Lazy <Permission, PermissionMetadata>(() => new ViewPermission(), new PermissionMetadata(new Dictionary <string, object>()));
var userGroup = CoreCmsData.RequiredCoreUserGroups(Enumerable.Repeat(permission, 1)).FirstOrDefault(x => x.Name == "Administrator");
Assert.NotNull(userGroup);
using (var uow = GroupUnitFactory.Create())
{
uow.Repositories.AddOrUpdate(new SystemRoot());
uow.Repositories.AddOrUpdate(Framework.Security.Model.FixedEntities.UserGroupVirtualRoot);
uow.Repositories.AddOrUpdate(userGroup);
uow.Complete();
}
// Assert - check single result
using (var uow = GroupUnitFactory.Create())
{
// Cause the task to be fired
Expression <Func <UserGroup, bool> > expression = x => x.Name == "Administrator";
var getAdminByName = uow.Repositories.Query <UserGroup>().FirstOrDefault(expression);
Assert.NotNull(getAdminByName);
// Generate what should be an exact-same QueryDescription for the above query, to check the cache
var executor = new Executor(uow.Repositories.QueryableDataSource, Queryable <UserGroup> .GetBinderFromAssembly());
var queryable = new Queryable <UserGroup>(executor);
queryable.FirstOrDefault(expression);
var description = executor.LastGeneratedDescription;
// Assert the task has been fired
Assert.That(uow.UnitScopedCache.GetOrCreate(new QueryDescriptionCacheKey(description), () => null), Is.Not.Null);
}
// Assert - check many results
using (var uow = GroupUnitFactory.Create())
{
// Cause the task to be fired
Expression <Func <UserGroup, bool> > expression = x => x.Name == "Administrator";
var getAdminByName = uow.Repositories.Query <UserGroup>().Where(expression).ToList();
Assert.NotNull(getAdminByName.FirstOrDefault());
// Generate what should be an exact-same QueryDescription for the above query, to check the cache
var executor = new Executor(uow.Repositories.QueryableDataSource, Queryable <UserGroup> .GetBinderFromAssembly());
var queryable = new Queryable <UserGroup>(executor);
queryable.Where(expression).ToList();
var description = executor.LastGeneratedDescription;
// Assert the task has been fired
Assert.That(uow.UnitScopedCache.GetOrCreate(new QueryDescriptionCacheKey(description), () => null), Is.Not.Null);
}
}
/// <summary>
/// Uploads the specified file.
/// </summary>
/// <param name="file">The file.</param>
/// <param name="docTypeId">The doc type id.</param>
/// <param name="parentId">The parent id.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public ContentResult Upload(HttpPostedFileBase file, HiveId?docTypeId, HiveId?parentId, string name)
{
GroupUnitFactory Hive = BackOfficeRequestContext.Application.Hive.GetWriter(new Uri("media://"));
using (var uow = Hive.Create <IContentStore>())
{
var schema = uow.Repositories.Schemas.Get <EntitySchema>(docTypeId.Value);
if (schema == null)
{
throw new ArgumentException(string.Format("No schema found for id: {0} on action Create", docTypeId));
}
//create the new content item
var contentViewModel = CreateNewContentEntity(schema, name, parentId.Value);
contentViewModel.UtcPublishedDate = DateTimeOffset.UtcNow;
var entity = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <Revision <TypedEntity> >(contentViewModel);
var toPublish = entity.CopyToNewRevision(FixedStatusTypes.Published);
var fileID = StoreFile(file);
//need to get alias of upload prop
var docType =
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <EntitySchema, DocumentTypeEditorModel>(schema);
string uploadAlias = docType.Properties.Where(p => p.DataType.PropertyEditor.Id.ToString().ToUpper() == CorePluginConstants.FileUploadPropertyEditorId).First().Alias;
toPublish.Item.Attributes[uploadAlias].Values["Value"] = fileID;
uow.Repositories.Revisions.AddOrUpdate(toPublish);
uow.Complete();
//need to return json as a string, since otherwise we'll be promted to download a file
string json = new
{
mediaId = toPublish.Item.Id,
title = name
}.ToJsonString();
return(Content(json));
}
}
public void TypedEntity_Count_ByAttributeValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
// The mocked entities have attributes with alias-1 and my-test-value1, and we've added two of them in SetupTestData
var query = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <string>(AttributeAlias1ForQuerying) == "my-test-value1");
// Assert
Assert.AreEqual(2, query.Count());
}
}
public void WhenExecutingCount_WithoutRevisionSpecified_OnlyPublishedResultsAreIncluded()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
AddRevision(entity, FixedStatusTypes.Published);
// Act
using (var uow = GroupUnitFactory.Create())
{
var result = uow.Repositories.Count(x => x.Id == (HiveId)newGuid);
// Assert
Assert.That(result, Is.EqualTo(1));
}
}
public void TypedEntity_ById_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Id == (HiveId)newGuid);
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void TypedEntity_ByAttributeSubValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.InnerAttribute <string>(NodeNameAttributeDefinition.AliasValue, "UrlName") == "my-test-route");
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void TypedEntity_ByAttributeValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) == "not-on-red-herring");
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void Temp_TypedEntity_WithDynamicQuery()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var dynQuery = DynamicMemberMetadata.GetAsPredicate(DynamicAttributeAliasForQuerying + " == @0", "my-new-value");
var query = uow.Repositories.OfRevisionType("created").Where(dynQuery).Cast <TypedEntity>();
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void WhenProviderIsMatched_IdIsRemappedToMappingGroup_OnReturn(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create <IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get <TypedEntity>(HiveId.Empty);
Assert.NotNull(singleItem);
Assert.NotNull(singleItem.Id.ProviderGroupRoot);
Assert.AreEqual(singleItem.Id.ProviderGroupRoot, idRoot);
Assert.NotNull(singleItem.Id.ProviderId);
Assert.True(singleItem.Id.ToString(HiveIdFormatStyle.AsUri).StartsWith(idRoot.ToString()), "Was: " + singleItem.Id.ToFriendlyString());
var items = uow.Repositories.GetAll <TypedEntity>();
var itemShouldBeCount = allItemCount * numbProviderCount;
Assert.AreEqual(itemShouldBeCount, items.Count());
foreach (var typedEntity in items)
{
AssertEntityIdIsRooted(idRoot, ((IReferenceByHiveId)typedEntity).Id);
}
AssertRelationsIdsHaveRoot(uow.Repositories.GetParentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetDescendentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetChildRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetAncestorRelations(HiveId.Empty), idRoot);
}
}
public void TypedEntity_ByEntitSchemaAlias_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.EntitySchema.Alias == SchemaAliasForQuerying);
// Assert
Assert.AreEqual(1, query.Count());
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
Assert.AreEqual("schema-alias1", item.EntitySchema.Alias);
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_AllObjects_HaveProviderId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get <TypedEntity>(HiveId.Empty);
var allDependentItems = singleItem.GetAllIdentifiableItems().ToArray();
Assert.IsTrue(allDependentItems.Any());
Assert.That(allDependentItems.Select(x => x.Id).Distinct().Count(), Is.GreaterThan(1));
foreach (var referenceByHiveId in allDependentItems)
{
AssertEntityIdIsRooted(idRoot, referenceByHiveId.Id);
}
}
}
internal void ResetHiveReference()
{
_hive = null;
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_AllObjects_HaveProviderId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
var allDependentItems = singleItem.GetAllIdentifiableItems().ToArray();
Assert.IsTrue(allDependentItems.Any());
Assert.That(allDependentItems.Select(x => x.Id).Distinct().Count(), Is.GreaterThan(1));
foreach (var referenceByHiveId in allDependentItems)
{
AssertEntityIdIsRooted(idRoot, referenceByHiveId.Id);
}
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_ItsRelationProxies_HaveAbsoluteId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var item = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
AssertIdsOfRelationProxiesForEntity(item, idRoot);
var items = uow.Repositories.GetAll<TypedEntity>();
Assert.True(items.Any());
foreach (var typedEntity in items)
{
AssertIdsOfRelationProxiesForEntity(typedEntity, idRoot);
}
}
}
public void WhenProviderIsMatched_IdIsRemappedToMappingGroup_OnReturn(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create<IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
Assert.NotNull(singleItem);
Assert.NotNull(singleItem.Id.ProviderGroupRoot);
Assert.AreEqual(singleItem.Id.ProviderGroupRoot, idRoot);
Assert.NotNull(singleItem.Id.ProviderId);
Assert.True(singleItem.Id.ToString(HiveIdFormatStyle.AsUri).StartsWith(idRoot.ToString()), "Was: " + singleItem.Id.ToFriendlyString());
var items = uow.Repositories.GetAll<TypedEntity>();
var itemShouldBeCount = allItemCount * numbProviderCount;
Assert.AreEqual(itemShouldBeCount, items.Count());
foreach (var typedEntity in items)
{
AssertEntityIdIsRooted(idRoot, ((IReferenceByHiveId)typedEntity).Id);
}
AssertRelationsIdsHaveRoot(uow.Repositories.GetParentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetDescendentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetChildRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetAncestorRelations(HiveId.Empty), idRoot);
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "T:System.Web.Security.MembershipProvider" /> class.
/// </summary>
public BackOfficeMembershipProvider()
{
_appContext = DependencyResolver.Current.GetService<IUmbracoApplicationContext>();
_hive = _appContext.Hive.GetWriter<ISecurityStore>(new Uri("security://users"));
}
protected void TestSetup()
{
_helper = new ExamineTestSetupHelper();
_groupUnitFactory = new GroupUnitFactory(_helper.ProviderSetup, new Uri("content://"), FakeHiveCmsManager.CreateFakeRepositoryContext(_helper.FrameworkContext));
}
public void CompositeEntity_ReSaves()
{
// Arrange
var childSchema = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
CompositeEntitySchema merged = null;
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, childSchema.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(childSchema.Id);
}
List<TypedAttribute> attribs;
var entity = MockCompositeEntity(merged, out attribs);
AssignFakeIdsIfPassthrough(ProviderSetup.ProviderMetadata, entity);
Assert.That(entity.Attributes.Count, Is.EqualTo(attribs.Count));
var firstRevision = new Revision<TypedEntity>(entity);
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.Revisions.AddOrUpdate(firstRevision);
uow.Complete();
}
PostWriteCallback.Invoke();
// Edit the data and resave
var secondRevision = firstRevision.CopyToNewRevision(FixedStatusTypes.Published);
secondRevision.Item.Attributes.Last().DynamicValue = "changed";
secondRevision.Item.Attributes.ForEach(x => x.Id = HiveId.Empty);
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.Revisions.AddOrUpdate(secondRevision);
uow.Complete();
}
PostWriteCallback.Invoke();
// Load the data again to ensure these attributes are still "inherited"
using (var uow = groupUnitFactory.Create())
{
var reloaded = uow.Repositories.Get<TypedEntity>(entity.Id);
Assert.That(reloaded.EntitySchema.Id.Value, Is.EqualTo(childSchema.Id.Value));
Assert.That(reloaded.Attributes.Count, Is.EqualTo(attribs.Count));
Assert.That(reloaded.Attributes.Select(x => x.AttributeDefinition), Has.Some.TypeOf<InheritedAttributeDefinition>());
}
}
public void GetCompositeSchema_ReturnsOnlyUniqueAttributeDefinitions()
{
// Arrange
var schema3 = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
// Assert
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, schema3.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
var merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(schema3.Id);
var defs = merged.AttributeDefinitions.Select(x => x.Alias).ToArray();
var inheritedDefs = merged.InheritedAttributeDefinitions.Select(x => x.Alias).ToArray();
Assert.That(defs, Is.Unique);
Assert.That(inheritedDefs, Is.Unique);
Assert.That(defs.Length, Is.GreaterThan(0));
Assert.That(inheritedDefs.Length, Is.GreaterThan(0));
Assert.That(inheritedDefs, Is.Not.SubsetOf(defs));
Assert.That(defs, Is.Not.SubsetOf(inheritedDefs));
}
}
public void GetComposite_Returns_Composite_Schema()
{
// Arrange
var schema3 = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
// Assert
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, schema3.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
var merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(schema3.Id);
Assert.IsTrue(merged.Id.Value == schema3.Id.Value);
Assert.AreEqual(2, merged.AttributeGroups.Count);
Assert.AreEqual(2, merged.AttributeDefinitions.Count);
Assert.AreEqual(4, merged.InheritedAttributeGroups.Count);
Assert.AreEqual(3, merged.InheritedAttributeDefinitions.Count);
Assert.AreEqual("<test />", merged.XmlConfiguration.ToString());
Assert.That(merged.AllAttributeGroups.Count(), Is.EqualTo(merged.AttributeGroups.Count + merged.InheritedAttributeGroups.Count));
Assert.That(merged.AllAttributeDefinitions.Count(), Is.EqualTo(merged.AttributeDefinitions.Count + merged.InheritedAttributeDefinitions.Count));
Assert.IsTrue(merged.InheritedAttributeGroups.Any(x => x.Alias == "empty-group"));
}
}
public void BeforeTest()
{
_setup = new MembershipWrapperTestSetupHelper();
_groupUnitFactory = new GroupUnitFactory(_setup.ProviderSetup, new Uri("content://"), FakeHiveCmsManager.CreateFakeRepositoryContext(_setup.FrameworkContext));
}
public void GetCompositeEntity_Returns_Correct_Attributes()
{
// Arrange
var childSchema = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
CompositeEntitySchema merged = null;
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, childSchema.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(childSchema.Id);
}
List<TypedAttribute> attribs;
var entity = MockCompositeEntity(merged, out attribs);
AssignFakeIdsIfPassthrough(ProviderSetup.ProviderMetadata, entity);
Assert.That(entity.Attributes.Count, Is.EqualTo(attribs.Count));
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.AddOrUpdate(entity);
uow.Complete();
}
PostWriteCallback.Invoke();
using (var uow = groupUnitFactory.Create())
{
var reloaded = uow.Repositories.Get<TypedEntity>(entity.Id);
Assert.That(reloaded.EntitySchema.Id.Value, Is.EqualTo(childSchema.Id.Value));
Assert.That(reloaded.Attributes.Count, Is.EqualTo(attribs.Count));
}
}
