private int CreateTestData(string isoName, out ContentType ct) { var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { DocumentRepository documentRepo; LanguageRepository langRepo; ContentTypeRepository contentTypeRepo; var repo = CreateRepository(provider, out contentTypeRepo, out documentRepo, out langRepo); var lang = new Language(isoName); langRepo.Save(lang); ct = MockedContentTypes.CreateBasicContentType("test", "Test"); contentTypeRepo.Save(ct); var content = new Content("test", -1, ct) { CreatorId = 0, WriterId = 0 }; documentRepo.Save(content); scope.Complete(); return(content.Id); } }
public void Invariant_Child_Content_Published_No_Domains() { var contentType = MockedContentTypes.CreateBasicContentType(); var parent = MockedContent.CreateBasicContent(contentType); parent.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache parent.Name = "home"; parent.Path = "-1,1046"; parent.Published = true; var child = MockedContent.CreateBasicContent(contentType); child.Name = "sub1"; child.Id = 1173; // FIXME: we are using this ID only because it's built into the test XML published cache child.Path = "-1,1046,1173"; child.Published = true; var umbracoSettings = Current.Configs.Settings(); var umbContext = GetUmbracoContext("http://localhost:8000", urlProviders: new[] { new DefaultUrlProvider(umbracoSettings.RequestHandler, Logger, TestObjects.GetGlobalSettings(), new SiteDomainHelper()) }); var publishedRouter = CreatePublishedRouter(Factory, contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) })); var urls = child.GetContentUrls(publishedRouter, umbContext, GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService, Logger).ToList(); Assert.AreEqual(1, urls.Count); Assert.AreEqual("/home/sub1/", urls[0].Text); Assert.AreEqual("en-US", urls[0].Culture); Assert.IsTrue(urls[0].IsUrl); }
public async Task Content_Not_Published() { var contentType = MockedContentTypes.CreateBasicContentType(); var content = MockedContent.CreateBasicContent(contentType); content.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache content.Path = "-1,1046"; var umbContext = GetUmbracoContext("http://localhost:8000"); var publishedRouter = CreatePublishedRouter( GetUmbracoContextAccessor(umbContext), Factory, contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(LoggerFactory.CreateLogger <ContentFinderByUrl>(), GetUmbracoContextAccessor(umbContext)) })); var urls = (await content.GetContentUrlsAsync(publishedRouter, umbContext, GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService, VariationContextAccessor, LoggerFactory.CreateLogger <IContent>(), UriUtility, PublishedUrlProvider)).ToList(); Assert.AreEqual(1, urls.Count); Assert.AreEqual("content/itemNotPublished", urls[0].Text); Assert.IsFalse(urls[0].IsUrl); }
private int CreateTestData(string isoName, out ContentType ct) { var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); ContentRepository contentRepo; LanguageRepository langRepo; ContentTypeRepository contentTypeRepo; using (var repo = CreateRepository(unitOfWork, out contentTypeRepo, out contentRepo, out langRepo)) { var lang = new Language(isoName); langRepo.AddOrUpdate(lang); ct = MockedContentTypes.CreateBasicContentType("test", "Test"); contentTypeRepo.AddOrUpdate(ct); var content = new Content("test", -1, ct) { CreatorId = 0, WriterId = 0 }; contentRepo.AddOrUpdate(content); unitOfWork.Commit(); return(content.Id); } }
/// <summary> /// Creates a bunch of content/media items return relation objects for them (unsaved) /// </summary> /// <param name="count"></param> /// <returns></returns> private IEnumerable <IRelation> CreateRelations(int count) { var rs = ServiceContext.RelationService; var rtName = Guid.NewGuid().ToString(); var rt = new RelationType(rtName, rtName, false, null, null); rs.Save(rt); var ct = MockedContentTypes.CreateBasicContentType(); ServiceContext.ContentTypeService.Save(ct); var mt = MockedContentTypes.CreateImageMediaType("img"); ServiceContext.MediaTypeService.Save(mt); return(Enumerable.Range(1, count).Select(index => { var c1 = MockedContent.CreateBasicContent(ct); var c2 = MockedMedia.CreateMediaImage(mt, -1); ServiceContext.ContentService.Save(c1); ServiceContext.MediaService.Save(c2); return new Relation(c1.Id, c2.Id, rt); }).ToList()); }
private IRelation CreateAndSaveRelation(string name, string alias) { var rs = ServiceContext.RelationService; var rt = new RelationType(name, alias, false, null, null); rs.Save(rt); var ct = MockedContentTypes.CreateBasicContentType(); ServiceContext.ContentTypeService.Save(ct); var mt = MockedContentTypes.CreateImageMediaType("img"); ServiceContext.MediaTypeService.Save(mt); var c1 = MockedContent.CreateBasicContent(ct); var c2 = MockedMedia.CreateMediaImage(mt, -1); ServiceContext.ContentService.Save(c1); ServiceContext.MediaService.Save(c2); var r = new Relation(c1.Id, c2.Id, rt); ServiceContext.RelationService.Save(r); return(r); }
public void LastIn() { DoSaveForContent += OnDoThingFail; var now = DateTime.Now; var contentType = MockedContentTypes.CreateBasicContentType(); var content1 = MockedContent.CreateBasicContent(contentType); content1.Id = 123; content1.UpdateDate = now.AddMinutes(1); var content2 = MockedContent.CreateBasicContent(contentType); content2.Id = 123; content2.UpdateDate = now.AddMinutes(2); var content3 = MockedContent.CreateBasicContent(contentType); content3.Id = 123; content3.UpdateDate = now.AddMinutes(3); var scopeProvider = _testObjects.GetScopeProvider(Mock.Of <ILogger>()); using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher())) { scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content1)); scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2)); scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content3)); // events have been queued var events = scope.Events.GetEvents(EventDefinitionFilter.LastIn).ToArray(); Assert.AreEqual(1, events.Length); Assert.AreEqual(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First()); Assert.IsTrue(object.ReferenceEquals(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First())); Assert.AreEqual(content3.UpdateDate, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().UpdateDate); } }
public void GetAvailableCompositeContentTypes_Include_Indirect_Composed_Types() { var ct1 = MockedContentTypes.CreateBasicContentType("ct1", "CT1"); var ct2 = MockedContentTypes.CreateBasicContentType("ct2", "CT2"); var ct3 = MockedContentTypes.CreateBasicContentType("ct3", "CT3"); var ct4 = MockedContentTypes.CreateBasicContentType("ct4", "CT4"); ct1.Id = 1; ct2.Id = 2; ct3.Id = 3; ct4.Id = 4; ct1.AddContentType(ct3); //ct3 is direct to ct1 ct3.AddContentType(ct4); //ct4 is indirect to ct1 var service = new Mock <IContentTypeService>(); var availableTypes = service.Object.GetAvailableCompositeContentTypes( ct1, new[] { ct1, ct2, ct3 }) .Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray(); Assert.AreEqual(3, availableTypes.Count()); Assert.AreEqual(ct2.Id, availableTypes.ElementAt(0).Id); Assert.AreEqual(ct3.Id, availableTypes.ElementAt(1).Id); Assert.AreEqual(ct4.Id, availableTypes.ElementAt(2).Id); }
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia) { //Create content createdContent = new List <IContent>(); var contentType = MockedContentTypes.CreateBasicContentType("blah"); ServiceContext.ContentTypeService.Save(contentType); for (int i = 0; i < 10; i++) { var c1 = MockedContent.CreateBasicContent(contentType); ServiceContext.ContentService.Save(c1); createdContent.Add(c1); } //Create media createdMedia = new List <IMedia>(); var imageType = MockedContentTypes.CreateImageMediaType("myImage"); ServiceContext.MediaTypeService.Save(imageType); for (int i = 0; i < 10; i++) { var c1 = MockedMedia.CreateMediaImage(imageType, -1); ServiceContext.MediaService.Save(c1); createdMedia.Add(c1); } // Create members var memberType = MockedContentTypes.CreateSimpleMemberType("simple"); ServiceContext.MemberTypeService.Save(memberType); createdMembers = MockedMember.CreateSimpleMember(memberType, 10).ToList(); ServiceContext.MemberService.Save(createdMembers); var relType = ServiceContext.RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias); // Relate content to media foreach (var content in createdContent) { foreach (var media in createdMedia) { ServiceContext.RelationService.Relate(content.Id, media.Id, relType); } } // Relate members to media foreach (var member in createdMembers) { foreach (var media in createdMedia) { ServiceContext.RelationService.Relate(member.Id, media.Id, relType); } } }
public void Get_Paged_Relations_By_Relation_Type() { //Create content var createdContent = new List <IContent>(); var contentType = MockedContentTypes.CreateBasicContentType("blah"); ServiceContext.ContentTypeService.Save(contentType); for (int i = 0; i < 10; i++) { var c1 = MockedContent.CreateBasicContent(contentType); ServiceContext.ContentService.Save(c1); createdContent.Add(c1); } //Create media var createdMedia = new List <IMedia>(); var imageType = MockedContentTypes.CreateImageMediaType("myImage"); ServiceContext.MediaTypeService.Save(imageType); for (int i = 0; i < 10; i++) { var c1 = MockedMedia.CreateMediaImage(imageType, -1); ServiceContext.MediaService.Save(c1); createdMedia.Add(c1); } var relType = ServiceContext.RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias); // Relate content to media foreach (var content in createdContent) { foreach (var media in createdMedia) { ServiceContext.RelationService.Relate(content.Id, media.Id, relType); } } var paged = ServiceContext.RelationService.GetPagedByRelationTypeId(relType.Id, 0, 51, out var totalRecs).ToList(); Assert.AreEqual(100, totalRecs); Assert.AreEqual(51, paged.Count); //next page paged.AddRange(ServiceContext.RelationService.GetPagedByRelationTypeId(relType.Id, 1, 51, out totalRecs)); Assert.AreEqual(100, totalRecs); Assert.AreEqual(100, paged.Count); Assert.IsTrue(createdContent.Select(x => x.Id).ContainsAll(paged.Select(x => x.ParentId))); Assert.IsTrue(createdMedia.Select(x => x.Id).ContainsAll(paged.Select(x => x.ChildId))); }
public void Can_Move() { var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.DocumentTypeContainerGuid)) using (var repository = CreateRepository(unitOfWork)) { var container1 = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid) { Name = "blah1" }; containerRepository.AddOrUpdate(container1); unitOfWork.Commit(); var container2 = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid) { Name = "blah2", ParentId = container1.Id }; containerRepository.AddOrUpdate(container2); unitOfWork.Commit(); var contentType = (IContentType)MockedContentTypes.CreateBasicContentType("asdfasdf"); contentType.ParentId = container2.Id; repository.AddOrUpdate(contentType); unitOfWork.Commit(); //create a var contentType2 = (IContentType) new ContentType(contentType, "hello") { Name = "Blahasdfsadf" }; contentType.ParentId = contentType.Id; repository.AddOrUpdate(contentType2); unitOfWork.Commit(); var result = repository.Move(contentType, container1).ToArray(); unitOfWork.Commit(); Assert.AreEqual(2, result.Count()); //re-get contentType = repository.Get(contentType.Id); contentType2 = repository.Get(contentType2.Id); Assert.AreEqual(container1.Id, contentType.ParentId); Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType.Id).OriginalPath, contentType.Path); Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType2.Id).OriginalPath, contentType2.Path); } }
public void SupersededEvents() { DoSaveForContent += OnDoThingFail; DoDeleteForContent += OnDoThingFail; DoForTestArgs += OnDoThingFail; DoForTestArgs2 += OnDoThingFail; var contentType = MockedContentTypes.CreateBasicContentType(); var content1 = MockedContent.CreateBasicContent(contentType); content1.Id = 123; var content2 = MockedContent.CreateBasicContent(contentType); content2.Id = 456; var content3 = MockedContent.CreateBasicContent(contentType); content3.Id = 789; var scopeProvider = _testObjects.GetScopeProvider(Mock.Of <ILogger>()); using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher())) { //content1 will be filtered from the args scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(new[] { content1, content3 })); scope.Events.Dispatch(DoDeleteForContent, this, new DeleteEventArgs <IContent>(content1), "DoDeleteForContent"); scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2)); //this entire event will be filtered scope.Events.Dispatch(DoForTestArgs, this, new TestEventArgs(content1)); scope.Events.Dispatch(DoForTestArgs2, this, new TestEventArgs2(content1)); // events have been queued var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray(); Assert.AreEqual(4, events.Length); Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[0].Args.GetType()); Assert.AreEqual(1, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.Count()); Assert.AreEqual(content3.Id, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().Id); Assert.AreEqual(typeof(DeleteEventArgs <IContent>), events[1].Args.GetType()); Assert.AreEqual(content1.Id, ((DeleteEventArgs <IContent>)events[1].Args).DeletedEntities.First().Id); Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[2].Args.GetType()); Assert.AreEqual(content2.Id, ((SaveEventArgs <IContent>)events[2].Args).SavedEntities.First().Id); Assert.AreEqual(typeof(TestEventArgs2), events[3].Args.GetType()); } }
public void Can_Move() { var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var containerRepository = CreateContainerRepository((IScopeAccessor)provider, Constants.ObjectTypes.DocumentTypeContainer); var repository = CreateRepository((IScopeAccessor)provider); var container1 = new EntityContainer(Constants.ObjectTypes.DocumentType) { Name = "blah1" }; containerRepository.Save(container1); var container2 = new EntityContainer(Constants.ObjectTypes.DocumentType) { Name = "blah2", ParentId = container1.Id }; containerRepository.Save(container2); var contentType = (IContentType)MockedContentTypes.CreateBasicContentType("asdfasdf"); contentType.ParentId = container2.Id; repository.Save(contentType); //create a var contentType2 = (IContentType) new ContentType(contentType, "hello") { Name = "Blahasdfsadf" }; contentType.ParentId = contentType.Id; repository.Save(contentType2); var result = repository.Move(contentType, container1).ToArray(); Assert.AreEqual(2, result.Count()); //re-get contentType = repository.Get(contentType.Id); contentType2 = repository.Get(contentType2.Id); Assert.AreEqual(container1.Id, contentType.ParentId); Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType.Id).OriginalPath, contentType.Path); Assert.AreNotEqual(result.Single(x => x.Entity.Id == contentType2.Id).OriginalPath, contentType2.Path); } }
public async Task Invariant_Child_Content_Published_No_Domains() { var contentType = MockedContentTypes.CreateBasicContentType(); var parent = MockedContent.CreateBasicContent(contentType); parent.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache parent.Name = "home"; parent.Path = "-1,1046"; parent.Published = true; var child = MockedContent.CreateBasicContent(contentType); child.Name = "sub1"; child.Id = 1173; // FIXME: we are using this ID only because it's built into the test XML published cache child.Path = "-1,1046,1173"; child.Published = true; var umbContext = GetUmbracoContext("http://localhost:8000"); var umbracoContextAccessor = GetUmbracoContextAccessor(umbContext); var urlProvider = new DefaultUrlProvider( Microsoft.Extensions.Options.Options.Create(_requestHandlerSettings), LoggerFactory.CreateLogger <DefaultUrlProvider>(), new SiteDomainMapper(), umbracoContextAccessor, UriUtility); var publishedUrlProvider = new UrlProvider( umbracoContextAccessor, Microsoft.Extensions.Options.Options.Create(_webRoutingSettings), new UrlProviderCollection(new [] { urlProvider }), new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()), Mock.Of <IVariationContextAccessor>() ); var publishedRouter = CreatePublishedRouter( umbracoContextAccessor, Factory, contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(LoggerFactory.CreateLogger <ContentFinderByUrl>(), umbracoContextAccessor) })); var urls = (await child.GetContentUrlsAsync(publishedRouter, umbContext, GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService, VariationContextAccessor, LoggerFactory.CreateLogger <IContent>(), UriUtility, publishedUrlProvider )).ToList(); Assert.AreEqual(1, urls.Count); Assert.AreEqual("/home/sub1/", urls[0].Text); Assert.AreEqual("en-US", urls[0].Culture); Assert.IsTrue(urls[0].IsUrl); }
public void GetAvailableCompositeContentTypes_No_Overlap_By_Content_Type_And_Property_Type_Alias() { Action <string, IContentType> addPropType = (alias, ct) => { var contentCollection = new PropertyTypeCollection(true) { new PropertyType(Constants.PropertyEditors.Aliases.TextBox, ValueStorageType.Ntext) { Alias = alias, Name = "Title", Description = "", Mandatory = false, SortOrder = 1, DataTypeId = -88 } }; var pg = new PropertyGroup(contentCollection) { Name = "test", SortOrder = 1 }; ct.PropertyGroups.Add(pg); }; var ct1 = MockedContentTypes.CreateBasicContentType("ct1", "CT1", null); var ct2 = MockedContentTypes.CreateBasicContentType("ct2", "CT2", null); addPropType("title", ct2); var ct3 = MockedContentTypes.CreateBasicContentType("ct3", "CT3", null); addPropType("title", ct3); var ct4 = MockedContentTypes.CreateBasicContentType("ct4", "CT4", null); var ct5 = MockedContentTypes.CreateBasicContentType("ct5", "CT5", null); addPropType("blah", ct5); ct1.Id = 1; ct2.Id = 2; ct3.Id = 3; ct4.Id = 4; ct5.Id = 4; var service = new Mock <IContentTypeService>(); var availableTypes = service.Object.GetAvailableCompositeContentTypes( ct1, new[] { ct1, ct2, ct3, ct4, ct5 }, new[] { ct2.Alias }, new[] { "blah" }) .Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray(); Assert.AreEqual(1, availableTypes.Count()); Assert.AreEqual(ct4.Id, availableTypes.ElementAt(0).Id); }
public void GetAvailableCompositeContentTypes_No_Results_If_Already_A_Composition_By_Parent() { var ct1 = MockedContentTypes.CreateBasicContentType("ct1", "CT1"); var ct2 = MockedContentTypes.CreateBasicContentType("ct2", "CT2", ct1); var ct3 = MockedContentTypes.CreateBasicContentType("ct3", "CT3"); ct1.Id = 1; ct2.Id = 2; ct3.Id = 3; var service = new Mock <IContentTypeService>(); var availableTypes = service.Object.GetAvailableCompositeContentTypes( ct1, new[] { ct1, ct2, ct3 }).Results; Assert.AreEqual(0, availableTypes.Count()); }
public void Cannot_Add_Duplicate_Property_Aliases() { var contentType = MockedContentTypes.CreateBasicContentType(); contentType.PropertyGroups.Add(new PropertyGroup(new PropertyTypeCollection(false, new[] { new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar) { Alias = "myPropertyType" } }))); Assert.Throws <InvalidOperationException>(() => contentType.PropertyTypeCollection.Add( new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar) { Alias = "myPropertyType" })); }
public void LatestEntities() { DoSaveForContent += OnDoThingFail; var now = DateTime.Now; var contentType = MockedContentTypes.CreateBasicContentType(); var content1 = MockedContent.CreateBasicContent(contentType); content1.Id = 123; content1.UpdateDate = now.AddMinutes(1); var content2 = MockedContent.CreateBasicContent(contentType); content2.Id = 123; content2.UpdateDate = now.AddMinutes(2); var content3 = MockedContent.CreateBasicContent(contentType); content3.Id = 123; content3.UpdateDate = now.AddMinutes(3); var scopeProvider = new ScopeProvider(Mock.Of <IDatabaseFactory2>()); using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher())) { scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content1)); scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2)); scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content3)); // events have been queued var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray(); Assert.AreEqual(3, events.Length); foreach (var t in events) { var args = (SaveEventArgs <IContent>)t.Args; foreach (var entity in args.SavedEntities) { Assert.AreEqual(content3, entity); Assert.IsTrue(object.ReferenceEquals(content3, entity)); } } } }
public void PropertyDataAssignedCorrectly() { var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, out DataTypeRepository _); var emptyContentType = MockedContentTypes.CreateBasicContentType(); var hasPropertiesContentType = MockedContentTypes.CreateSimpleContentType("umbTextpage1", "Textpage"); contentTypeRepository.Save(emptyContentType); contentTypeRepository.Save(hasPropertiesContentType); ServiceContext.FileService.SaveTemplate(hasPropertiesContentType.DefaultTemplate); // else, FK violation on contentType! var content1 = MockedContent.CreateSimpleContent(hasPropertiesContentType); var content2 = MockedContent.CreateBasicContent(emptyContentType); var content3 = MockedContent.CreateSimpleContent(hasPropertiesContentType); repository.Save(content1); repository.Save(content2); repository.Save(content3); // this will cause the GetPropertyCollection to execute and we need to ensure that // all of the properties and property types are all correct var result = repository.GetMany(content1.Id, content2.Id, content3.Id).ToArray(); var n1 = result[0]; var n2 = result[1]; var n3 = result[2]; Assert.AreEqual(content1.Id, n1.Id); Assert.AreEqual(content2.Id, n2.Id); Assert.AreEqual(content3.Id, n3.Id); // compare everything including properties and their values // this ensures that they have been properly retrieved TestHelper.AssertPropertyValuesAreEqual(content1, n1); TestHelper.AssertPropertyValuesAreEqual(content2, n2); TestHelper.AssertPropertyValuesAreEqual(content3, n3); } }
public void Content_Not_Published() { var contentType = MockedContentTypes.CreateBasicContentType(); var content = MockedContent.CreateBasicContent(contentType); content.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache content.Path = "-1,1046"; var umbContext = GetUmbracoContext("http://localhost:8000"); var publishedRouter = CreatePublishedRouter(Factory, contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) })); var urls = content.GetContentUrls(publishedRouter, umbContext, GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService, Logger).ToList(); Assert.AreEqual(1, urls.Count); Assert.AreEqual("content/itemNotPublished", urls[0].Text); Assert.IsFalse(urls[0].IsUrl); }
public void GetAvailableCompositeContentTypes_Not_Itself() { var ct1 = MockedContentTypes.CreateBasicContentType("ct1", "CT1", null); var ct2 = MockedContentTypes.CreateBasicContentType("ct2", "CT2", null); var ct3 = MockedContentTypes.CreateBasicContentType("ct3", "CT3", null); ct1.Id = 1; ct2.Id = 2; ct3.Id = 3; var service = new Mock <IContentTypeService>(); var availableTypes = service.Object.GetAvailableCompositeContentTypes( ct1, new[] { ct1, ct2, ct3 }) .Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray(); Assert.AreEqual(2, availableTypes.Count()); Assert.AreEqual(ct2.Id, availableTypes.ElementAt(0).Id); Assert.AreEqual(ct3.Id, availableTypes.ElementAt(1).Id); }
public void GetAvailableCompositeContentTypes_Do_Not_Include_Other_Composed_Types() { var ct1 = MockedContentTypes.CreateBasicContentType("ct1", "CT1"); var ct2 = MockedContentTypes.CreateBasicContentType("ct2", "CT2"); var ct3 = MockedContentTypes.CreateBasicContentType("ct3", "CT3"); ct1.Id = 1; ct2.Id = 2; ct3.Id = 3; ct2.AddContentType(ct3); var service = new Mock <IContentTypeService>(); var availableTypes = service.Object.GetAvailableCompositeContentTypes( ct1, new[] { ct1, ct2, ct3 }) .Results.Where(x => x.Allowed).Select(x => x.Composition).ToArray(); Assert.AreEqual(1, availableTypes.Count()); Assert.AreEqual(ct3.Id, availableTypes.Single().Id); }
private IEnumerable <IContent> CreateTestData(int count) { var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); ContentTypeRepository ctRepo; using (var repo = CreateRepository(unitOfWork, out ctRepo)) { var ct = MockedContentTypes.CreateBasicContentType("testing"); ctRepo.AddOrUpdate(ct); unitOfWork.Commit(); var result = new List <IContent>(); for (int i = 0; i < count; i++) { var c = new Content("test" + i, -1, ct); repo.AddOrUpdate(c); result.Add(c); } unitOfWork.Commit(); return(result); } }
private IEnumerable <IContent> CreateTestData(int count) { var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { ContentTypeRepository ctRepo; var repo = CreateRepository(provider, out ctRepo); var ct = MockedContentTypes.CreateBasicContentType("testing"); ctRepo.Save(ct); var result = new List <IContent>(); for (int i = 0; i < count; i++) { var c = new Content("test" + i, -1, ct); repo.Save(c); result.Add(c); } scope.Complete(); return(result); } }
public void Get_Paged_Mixed_Entities_By_Ids() { //Create content var createdContent = new List <IContent>(); var contentType = MockedContentTypes.CreateBasicContentType("blah"); ServiceContext.ContentTypeService.Save(contentType); for (int i = 0; i < 10; i++) { var c1 = MockedContent.CreateBasicContent(contentType); ServiceContext.ContentService.Save(c1); createdContent.Add(c1); } //Create media var createdMedia = new List <IMedia>(); var imageType = MockedContentTypes.CreateImageMediaType("myImage"); ServiceContext.MediaTypeService.Save(imageType); for (int i = 0; i < 10; i++) { var c1 = MockedMedia.CreateMediaImage(imageType, -1); ServiceContext.MediaService.Save(c1); createdMedia.Add(c1); } // Create members var memberType = MockedContentTypes.CreateSimpleMemberType("simple"); ServiceContext.MemberTypeService.Save(memberType); var createdMembers = MockedMember.CreateSimpleMember(memberType, 10).ToList(); ServiceContext.MemberService.Save(createdMembers); var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var repo = CreateRepository((IScopeAccessor)provider); var ids = createdContent.Select(x => x.Id).Concat(createdMedia.Select(x => x.Id)).Concat(createdMembers.Select(x => x.Id)); var objectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }; var query = SqlContext.Query <IUmbracoEntity>() .WhereIn(e => e.Id, ids); var entities = repo.GetPagedResultsByQuery(query, objectTypes, 0, 20, out var totalRecords, null, null).ToList(); Assert.AreEqual(20, entities.Count); Assert.AreEqual(30, totalRecords); //add the next page entities.AddRange(repo.GetPagedResultsByQuery(query, objectTypes, 1, 20, out totalRecords, null, null)); Assert.AreEqual(30, entities.Count); Assert.AreEqual(30, totalRecords); var contentEntities = entities.OfType <IDocumentEntitySlim>().ToList(); var mediaEntities = entities.OfType <IMediaEntitySlim>().ToList(); var memberEntities = entities.OfType <IMemberEntitySlim>().ToList(); Assert.AreEqual(10, contentEntities.Count); Assert.AreEqual(10, mediaEntities.Count); Assert.AreEqual(10, memberEntities.Count); } }
public void Can_Perform_Update_On_UserRepository() { var ct = MockedContentTypes.CreateBasicContentType("test"); var content = MockedContent.CreateBasicContent(ct); var mt = MockedContentTypes.CreateSimpleMediaType("testmedia", "TestMedia"); var media = MockedMedia.CreateSimpleMedia(mt, "asdf", -1); // Arrange var provider = new PetaPocoUnitOfWorkProvider(Logger); var unitOfWork = provider.GetUnitOfWork(); IContentTypeRepository contentTypeRepo; IMediaTypeRepository mediaTypeRepo; using (var contentRepository = CreateContentRepository(unitOfWork, out contentTypeRepo)) using (var mediaRepository = CreateMediaRepository(unitOfWork, out mediaTypeRepo)) using (contentTypeRepo) using (mediaTypeRepo) using (var userRepository = CreateRepository(unitOfWork)) using (var userGroupRepository = CreateUserGroupRepository(unitOfWork)) { contentTypeRepo.AddOrUpdate(ct); mediaTypeRepo.AddOrUpdate(mt); unitOfWork.Commit(); contentRepository.AddOrUpdate(content); mediaRepository.AddOrUpdate(media); unitOfWork.Commit(); var user = CreateAndCommitUserWithGroup(userRepository, userGroupRepository, unitOfWork); // Act var resolved = (User)userRepository.Get((int)user.Id); resolved.Name = "New Name"; resolved.Language = "fr"; resolved.IsApproved = false; resolved.RawPasswordValue = "new"; resolved.IsLockedOut = true; resolved.StartContentIds = new[] { content.Id }; resolved.StartMediaIds = new[] { media.Id }; resolved.Email = "*****@*****.**"; resolved.Username = "******"; userRepository.AddOrUpdate(resolved); unitOfWork.Commit(); var updatedItem = (User)userRepository.Get((int)user.Id); // Assert Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id)); Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name)); Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language)); Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved)); Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue)); Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut)); Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(resolved.StartContentIds)); Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(resolved.StartMediaIds)); Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email)); Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username)); Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(2)); Assert.IsTrue(updatedItem.AllowedSections.Contains("content")); Assert.IsTrue(updatedItem.AllowedSections.Contains("media")); } }
public void Index_Property_Data_With_Value_Indexer() { var contentValueSetBuilder = IndexInitializer.GetContentValueSetBuilder(Factory.GetInstance <PropertyEditorCollection>(), false); using (var luceneDir = new RandomIdRamDirectory()) using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir, validator: new ContentValueSetValidator(false))) using (indexer.ProcessNonAsync()) { indexer.CreateIndex(); var contentType = MockedContentTypes.CreateBasicContentType(); contentType.AddPropertyType(new PropertyType("test", ValueStorageType.Ntext) { Alias = "grid", Name = "Grid", PropertyEditorAlias = Core.Constants.PropertyEditors.Aliases.Grid }); var content = MockedContent.CreateBasicContent(contentType); content.Id = 555; content.Path = "-1,555"; var gridVal = new GridValue { Name = "n1", Sections = new List <GridValue.GridSection> { new GridValue.GridSection { Grid = "g1", Rows = new List <GridValue.GridRow> { new GridValue.GridRow { Id = Guid.NewGuid(), Name = "row1", Areas = new List <GridValue.GridArea> { new GridValue.GridArea { Grid = "g2", Controls = new List <GridValue.GridControl> { new GridValue.GridControl { Editor = new GridValue.GridEditor { Alias = "editor1", View = "view1" }, Value = "value1" }, new GridValue.GridControl { Editor = new GridValue.GridEditor { Alias = "editor1", View = "view1" }, Value = "value2" } } } } } } } } }; var json = JsonConvert.SerializeObject(gridVal); content.Properties["grid"].SetValue(json); var valueSet = contentValueSetBuilder.GetValueSets(content); indexer.IndexItems(valueSet); var searcher = indexer.GetSearcher(); var results = searcher.CreateQuery().Id(555).Execute(); Assert.AreEqual(1, results.TotalItemCount); var result = results.First(); Assert.IsTrue(result.Values.ContainsKey("grid.row1")); Assert.AreEqual("value1", result.AllValues["grid.row1"][0]); Assert.AreEqual("value2", result.AllValues["grid.row1"][1]); Assert.IsTrue(result.Values.ContainsKey("grid")); Assert.AreEqual("value1 value2 ", result["grid"]); Assert.IsTrue(result.Values.ContainsKey($"{UmbracoExamineIndex.RawFieldPrefix}grid")); Assert.AreEqual(json, result[$"{UmbracoExamineIndex.RawFieldPrefix}grid"]); } }
public void GroupsContentTypeEvents() { var num = 30; var contentTypes = Enumerable.Repeat(MockedContentTypes.CreateBasicContentType(), num); var mediaTypes = Enumerable.Repeat(MockedContentTypes.CreateImageMediaType(), num); var memberTypes = Enumerable.Repeat(MockedContentTypes.CreateSimpleMemberType(), num); var definitionsContent = contentTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IContentTypeService, ContentTypeChange <IContentType> .EventArgs>(null, Current.Services.ContentTypeService, new ContentTypeChange <IContentType> .EventArgs(new ContentTypeChange <IContentType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(x), "Saved"), }); var definitionsMedia = mediaTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IMediaTypeService, ContentTypeChange <IMediaType> .EventArgs>(null, Current.Services.MediaTypeService, new ContentTypeChange <IMediaType> .EventArgs(new ContentTypeChange <IMediaType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IMediaTypeService, SaveEventArgs <IMediaType> >(null, Current.Services.MediaTypeService, new SaveEventArgs <IMediaType>(x), "Saved"), }); var definitionsMember = memberTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IMemberTypeService, ContentTypeChange <IMemberType> .EventArgs>(null, Current.Services.MemberTypeService, new ContentTypeChange <IMemberType> .EventArgs(new ContentTypeChange <IMemberType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IMemberTypeService, SaveEventArgs <IMemberType> >(null, Current.Services.MemberTypeService, new SaveEventArgs <IMemberType>(x), "Saved"), }); var definitions = new List <IEventDefinition>(); definitions.AddRange(definitionsContent); definitions.AddRange(definitionsMedia); definitions.AddRange(definitionsMember); var result = DistributedCacheBinder.GetGroupedEventList(definitions); Assert.Multiple(() => { Assert.AreEqual(num * 6, definitions.Count(), "Precondition is we have many definitions"); Assert.AreEqual(6, result.Count(), "Unexpected number of reduced definitions"); foreach (var eventDefinition in result) { if (eventDefinition.Args is SaveEventArgs <IContentType> saveContentEventArgs) { Assert.AreEqual(num, saveContentEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IContentType> .EventArgs changeContentEventArgs) { Assert.AreEqual(num, changeContentEventArgs.Changes.Count()); } if (eventDefinition.Args is SaveEventArgs <IMediaType> saveMediaEventArgs) { Assert.AreEqual(num, saveMediaEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IMediaType> .EventArgs changeMediaEventArgs) { Assert.AreEqual(num, changeMediaEventArgs.Changes.Count()); } if (eventDefinition.Args is SaveEventArgs <IMemberType> saveMemberEventArgs) { Assert.AreEqual(num, saveMemberEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IMemberType> .EventArgs changeMemberEventArgs) { Assert.AreEqual(num, changeMemberEventArgs.Changes.Count()); } } }); }
public void Can_Perform_Update_On_UserRepository() { var ct = MockedContentTypes.CreateBasicContentType("test"); var mt = MockedContentTypes.CreateSimpleMediaType("testmedia", "TestMedia"); // Arrange var provider = TestObjects.GetScopeProvider(Logger); using (var scope = provider.CreateScope()) { var userRepository = CreateRepository(provider); var contentRepository = CreateContentRepository(provider, out var contentTypeRepo); var mediaRepository = CreateMediaRepository(provider, out var mediaTypeRepo); var userGroupRepository = CreateUserGroupRepository(provider); contentTypeRepo.Save(ct); mediaTypeRepo.Save(mt); var content = MockedContent.CreateBasicContent(ct); var media = MockedMedia.CreateSimpleMedia(mt, "asdf", -1); contentRepository.Save(content); mediaRepository.Save(media); var user = CreateAndCommitUserWithGroup(userRepository, userGroupRepository); // Act var resolved = (User)userRepository.Get(user.Id); resolved.Name = "New Name"; //the db column is not used, default permissions are taken from the user type's permissions, this is a getter only //resolved.DefaultPermissions = "ZYX"; resolved.Language = "fr"; resolved.IsApproved = false; resolved.RawPasswordValue = "new"; resolved.IsLockedOut = true; resolved.StartContentIds = new[] { content.Id }; resolved.StartMediaIds = new[] { media.Id }; resolved.Email = "*****@*****.**"; resolved.Username = "******"; userRepository.Save(resolved); var updatedItem = (User)userRepository.Get(user.Id); // Assert Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id)); Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name)); Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language)); Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved)); Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue)); Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut)); Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(resolved.StartContentIds)); Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(resolved.StartMediaIds)); Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email)); Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username)); Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(resolved.AllowedSections.Count())); foreach (var allowedSection in resolved.AllowedSections) { Assert.IsTrue(updatedItem.AllowedSections.Contains(allowedSection)); } } }