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 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)); }
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)); } }