public void Can_Serialize_Without_Error() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.Id = 99; Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); int i = 200; foreach (IProperty property in content.Properties) { property.Id = ++i; } content.Id = 10; content.CreateDate = DateTime.Now; content.CreatorId = 22; content.Key = Guid.NewGuid(); content.Level = 3; content.Path = "-1,4,10"; content.SortOrder = 5; content.TemplateId = 88; content.Trashed = false; content.UpdateDate = DateTime.Now; content.WriterId = 23; string json = JsonConvert.SerializeObject(content); Debug.Print(json); }
public void After_Committing_Changes_Was_Dirty_Is_True_On_Changed_Property() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.ResetDirtyProperties(); // reset Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "test", -1); content.ResetDirtyProperties(); // Act content.SetValue("title", "new title"); Assert.That(content.IsEntityDirty(), Is.False); Assert.That(content.IsDirty(), Is.True); Assert.That(content.IsPropertyDirty("title"), Is.True); Assert.That(content.IsAnyUserPropertyDirty(), Is.True); Assert.That(content.GetDirtyUserProperties().Count(), Is.EqualTo(1)); Assert.That(content.Properties[0].IsDirty(), Is.True); Assert.That(content.Properties["title"].IsDirty(), Is.True); content.ResetDirtyProperties(); // this would be like committing the entity // Assert Assert.That(content.WasDirty(), Is.True); Assert.That(content.Properties[0].WasDirty(), Is.True); Assert.That(content.WasPropertyDirty("title"), Is.True); Assert.That(content.Properties["title"].IsDirty(), Is.False); Assert.That(content.Properties["title"].WasDirty(), Is.True); }
public void Can_Add_New_Property_To_New_PropertyType_In_New_PropertyGroup() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); // Act PropertyType propertyType = new PropertyTypeBuilder() .WithAlias("subtitle") .WithName("Subtitle") .Build(); var propertyGroup = new PropertyGroup(true) { Alias = "testGroup", Name = "Test Group", SortOrder = 3 }; propertyGroup.PropertyTypes.Add(propertyType); contentType.PropertyGroups.Add(propertyGroup); var newProperty = new Property(propertyType); newProperty.SetValue("Subtitle Test"); content.Properties.Add(newProperty); // Assert Assert.That(content.Properties.Count, Is.EqualTo(5)); Assert.That(content.Properties["subtitle"].GetValue(), Is.EqualTo("Subtitle Test")); Assert.That(content.Properties["title"].GetValue(), Is.EqualTo("Textpage textpage")); }
public void DirtyProperty_OnlyIfActuallyChanged_User() { var contentTypeService = Mock.Of <IContentTypeService>(); var contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())) .Returns(contentType); var content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); var prop = content.Properties.First(); // if you assign a user property with its value it is not dirty // if you assign it with another value then back, it is dirty prop.SetValue("A"); content.ResetDirtyProperties(false); Assert.IsFalse(prop.IsDirty()); prop.SetValue("B"); Assert.IsTrue(prop.IsDirty()); content.ResetDirtyProperties(false); Assert.IsFalse(prop.IsDirty()); prop.SetValue("B"); Assert.IsFalse(prop.IsDirty()); prop.SetValue("A"); prop.SetValue("B"); Assert.IsTrue(prop.IsDirty()); }
public void DirtyProperty_UpdateDate() { var contentTypeService = Mock.Of <IContentTypeService>(); var contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())) .Returns(contentType); var content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); var prop = content.Properties.First(); content.ResetDirtyProperties(false); var d = content.UpdateDate; prop.SetValue("A"); Assert.IsTrue(content.IsAnyUserPropertyDirty()); Assert.IsFalse(content.IsEntityDirty()); Assert.AreEqual(d, content.UpdateDate); content.UpdateDate = DateTime.Now; Assert.IsTrue(content.IsEntityDirty()); Assert.AreNotEqual(d, content.UpdateDate); // so... changing UpdateDate would count as a content property being changed // however in ContentRepository.PersistUpdatedItem, we change UpdateDate AFTER // we've tested for RequiresSaving & RequiresNewVersion so it's OK }
public void DirtyProperty_WasDirty_ContentSortOrder() { var contentTypeService = Mock.Of <IContentTypeService>(); var contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())) .Returns(contentType); var content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); content.ResetDirtyProperties(false); Assert.IsFalse(content.IsDirty()); Assert.IsFalse(content.WasDirty()); content.SortOrder = 0; content.SortOrder = 1; Assert.IsTrue(content.IsDirty()); Assert.IsFalse(content.WasDirty()); content.ResetDirtyProperties(false); Assert.IsFalse(content.IsDirty()); Assert.IsFalse(content.WasDirty()); content.SortOrder = 0; content.SortOrder = 1; content.ResetDirtyProperties(true); // what PersistUpdatedItem does Assert.IsFalse(content.IsDirty()); Assert.IsTrue(content.WasDirty()); content.SortOrder = 0; content.SortOrder = 1; content.ResetDirtyProperties(); // what PersistUpdatedItem does Assert.IsFalse(content.IsDirty()); Assert.IsTrue(content.WasDirty()); }
public void DirtyProperty_WasDirty_UserProperty() { var contentTypeService = Mock.Of <IContentTypeService>(); var contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())) .Returns(contentType); var content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); var prop = content.Properties.First(); content.ResetDirtyProperties(false); Assert.IsFalse(content.IsDirty()); Assert.IsFalse(content.WasDirty()); prop.SetValue("a"); prop.SetValue("b"); Assert.IsTrue(content.IsDirty()); Assert.IsFalse(content.WasDirty()); content.ResetDirtyProperties(false); Assert.IsFalse(content.IsDirty()); Assert.IsFalse(content.WasDirty()); prop.SetValue("a"); prop.SetValue("b"); content.ResetDirtyProperties(true); // what PersistUpdatedItem does Assert.IsFalse(content.IsDirty()); //// Assert.IsFalse(content.WasDirty()); // not impacted by user properties Assert.IsTrue(content.WasDirty()); // now it is! prop.SetValue("a"); prop.SetValue("b"); content.ResetDirtyProperties(); // what PersistUpdatedItem does Assert.IsFalse(content.IsDirty()); //// Assert.IsFalse(content.WasDirty()); // not impacted by user properties Assert.IsTrue(content.WasDirty()); // now it is! }
public void Can_Verify_Content_Is_Published() { ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); content.ResetDirtyProperties(); content.PublishedState = PublishedState.Publishing; Assert.IsFalse(content.IsPropertyDirty("Published")); Assert.IsFalse(content.Published); Assert.IsFalse(content.IsPropertyDirty("Name")); Assert.AreEqual(PublishedState.Publishing, content.PublishedState); // the repo would do content.Published = true; // and then Assert.IsTrue(content.IsPropertyDirty("Published")); Assert.IsTrue(content.Published); Assert.IsFalse(content.IsPropertyDirty("Name")); Assert.AreEqual(PublishedState.Published, content.PublishedState); // and before returning, content.ResetDirtyProperties(); // and then Assert.IsFalse(content.IsPropertyDirty("Published")); Assert.IsTrue(content.Published); Assert.IsFalse(content.IsPropertyDirty("Name")); Assert.AreEqual(PublishedState.Published, content.PublishedState); }
public void Serialize_ForContentTypeWithHistoryCleanupPolicy_OutputsSerializedHistoryCleanupPolicy() { // Arrange var template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); // else, FK violation on contentType! var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id); contentType.HistoryCleanup = new HistoryCleanup { PreventCleanup = true, KeepAllVersionsNewerThanDays = 1, KeepLatestVersionPerDayForDays = 2 }; ContentTypeService.Save(contentType); // Act var element = Serializer.Serialize(contentType); // Assert Assert.Multiple(() => { Assert.That(element.Element("HistoryCleanupPolicy") !.Attribute("preventCleanup") !.Value, Is.EqualTo("true")); Assert.That(element.Element("HistoryCleanupPolicy") !.Attribute("keepAllVersionsNewerThanDays") !.Value, Is.EqualTo("1")); Assert.That(element.Element("HistoryCleanupPolicy") !.Attribute("keepLatestVersionPerDayForDays") !.Value, Is.EqualTo("2")); }); }
public void Can_Add_New_Property_To_New_PropertyType() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); // Act PropertyType propertyType = new PropertyTypeBuilder() .WithAlias("subtitle") .WithName("Subtitle") .Build(); contentType.PropertyGroups["content"].PropertyTypes.Add(propertyType); var newProperty = new Property(propertyType); newProperty.SetValue("This is a subtitle Test"); content.Properties.Add(newProperty); // Assert Assert.That(content.Properties.Contains("subtitle"), Is.True); Assert.That(content.Properties["subtitle"].GetValue(), Is.EqualTo("This is a subtitle Test")); }
public void PropertyGroups_Collection_FirstOrDefault_Returns_Null() { var contentType = ContentTypeBuilder.CreateTextPageContentType(); Assert.That(contentType.PropertyGroups, Is.Not.Null); Assert.That(contentType.PropertyGroups.FirstOrDefault(x => x.Name.InvariantEquals("Content")) == null, Is.False); Assert.That(contentType.PropertyGroups.FirstOrDefault(x => x.Name.InvariantEquals("Test")) == null, Is.True); Assert.That(contentType.PropertyGroups.Any(x => x.Name.InvariantEquals("Test")), Is.False); }
public void Can_Avoid_Circular_Dependencies_In_Composition() { ContentType textPage = ContentTypeBuilder.CreateTextPageContentType(); ContentType parent = ContentTypeBuilder.CreateSimpleContentType("parent", "Parent", null, randomizeAliases: true); ContentType meta = ContentTypeBuilder.CreateMetaContentType(); PropertyType propertyType1 = new PropertyTypeBuilder() .WithAlias("coauthor") .WithName("Co-author") .Build(); ContentType mixin1 = ContentTypeBuilder.CreateSimpleContentType( "mixin1", "Mixin1", propertyTypeCollection: new PropertyTypeCollection(true, new List <PropertyType> { propertyType1 })); PropertyType propertyType2 = new PropertyTypeBuilder() .WithAlias("author") .WithName("Author") .Build(); ContentType mixin2 = ContentTypeBuilder.CreateSimpleContentType( "mixin2", "Mixin2", propertyTypeCollection: new PropertyTypeCollection(true, new List <PropertyType> { propertyType2 })); // Act bool addedMetaMixin2 = mixin2.AddContentType(meta); bool addedMixin2 = mixin1.AddContentType(mixin2); bool addedMeta = parent.AddContentType(meta); bool addedMixin1 = parent.AddContentType(mixin1); bool addedMixin1Textpage = textPage.AddContentType(mixin1); bool addedTextpageParent = parent.AddContentType(textPage); IEnumerable <string> aliases = textPage.CompositionAliases(); IEnumerable <IPropertyType> propertyTypes = textPage.CompositionPropertyTypes; IEnumerable <PropertyGroup> propertyGroups = textPage.CompositionPropertyGroups; // Assert Assert.That(mixin2.ContentTypeCompositionExists("meta"), Is.True); Assert.That(mixin1.ContentTypeCompositionExists("meta"), Is.True); Assert.That(parent.ContentTypeCompositionExists("meta"), Is.True); Assert.That(textPage.ContentTypeCompositionExists("meta"), Is.True); Assert.That(aliases.Count(), Is.EqualTo(3)); Assert.That(propertyTypes.Count(), Is.EqualTo(8)); Assert.That(propertyGroups.Count(), Is.EqualTo(2)); Assert.That(addedMeta, Is.True); Assert.That(addedMetaMixin2, Is.True); Assert.That(addedMixin2, Is.True); Assert.That(addedMixin1, Is.False); Assert.That(addedMixin1Textpage, Is.True); Assert.That(addedTextpageParent, Is.False); }
private void CreateTestData() { var template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); // else, FK violation on contentType! _contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id); ContentTypeService.Save(_contentType); }
public void IContentType_To_ContentTypeDisplay() { // Arrange //// _dataTypeService.Setup(x => x.GetDataType(It.IsAny<int>())) //// .Returns(new DataType(new VoidEditor(Mock.Of<ILogger>(), Mock.Of<IDataTypeService>(), Mock.Of<ILocalizationService>(),Mock.Of<ILocalizedTextService>(), Mock.Of<IShortStringHelper>()))); // // setup the mocks to return the data we want to test against... var contentType = ContentTypeBuilder.CreateTextPageContentType(); ContentTypeBuilder.EnsureAllIds(contentType, 8888); // Act var result = _sut.Map <DocumentTypeDisplay>(contentType); // Assert Assert.AreEqual(contentType.Alias, result.Alias); Assert.AreEqual(contentType.Description, result.Description); Assert.AreEqual(contentType.Icon, result.Icon); Assert.AreEqual(contentType.Id, result.Id); Assert.AreEqual(contentType.Name, result.Name); Assert.AreEqual(contentType.ParentId, result.ParentId); Assert.AreEqual(contentType.Path, result.Path); Assert.AreEqual(contentType.Thumbnail, result.Thumbnail); Assert.AreEqual(contentType.IsContainer, result.IsContainer); Assert.AreEqual(contentType.CreateDate, result.CreateDate); Assert.AreEqual(contentType.UpdateDate, result.UpdateDate); Assert.AreEqual(contentType.DefaultTemplate.Alias, result.DefaultTemplate.Alias); Assert.AreEqual(contentType.PropertyGroups.Count, result.Groups.Count()); for (var i = 0; i < contentType.PropertyGroups.Count; i++) { Assert.AreEqual(contentType.PropertyGroups[i].Id, result.Groups.ElementAt(i).Id); Assert.AreEqual(contentType.PropertyGroups[i].Name, result.Groups.ElementAt(i).Name); var propTypes = contentType.PropertyGroups[i].PropertyTypes; Assert.AreEqual(propTypes.Count, result.Groups.ElementAt(i).Properties.Count()); for (var j = 0; j < propTypes.Count; j++) { Assert.AreEqual(propTypes[j].Id, result.Groups.ElementAt(i).Properties.ElementAt(j).Id); Assert.AreEqual(propTypes[j].DataTypeId, result.Groups.ElementAt(i).Properties.ElementAt(j).DataTypeId); Assert.AreEqual(propTypes[j].LabelOnTop, result.Groups.ElementAt(i).Properties.ElementAt(j).LabelOnTop); } } Assert.AreEqual(contentType.AllowedTemplates.Count(), result.AllowedTemplates.Count()); for (var i = 0; i < contentType.AllowedTemplates.Count(); i++) { Assert.AreEqual(contentType.AllowedTemplates.ElementAt(i).Id, result.AllowedTemplates.ElementAt(i).Id); } Assert.AreEqual(contentType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count()); for (var i = 0; i < contentType.AllowedContentTypes.Count(); i++) { Assert.AreEqual(contentType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i)); } }
public void CreateTestData() { Template template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); // Create and Save ContentType "textpage" -> ContentType.Id ContentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id); ContentTypeService.Save(ContentType); }
public void CreateTestData() { // Create and Save ContentType "umbTextpage" -> (_simpleContentType.Id) _simpleContentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: 0); ContentTypeService.Save(_simpleContentType); // Create and Save ContentType "textPage" -> (_textpageContentType.Id) _textpageContentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: 0); ContentTypeService.Save(_textpageContentType); }
public void If_Not_Committed_Was_Dirty_Is_False() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); // Act contentType.Alias = "newAlias"; // Assert Assert.That(contentType.IsDirty(), Is.True); Assert.That(contentType.WasDirty(), Is.False); }
public void Detect_That_A_Property_Is_Removed() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Assert.That(contentType.WasPropertyDirty("HasPropertyTypeBeenRemoved"), Is.False); // Act contentType.RemovePropertyType("title"); // Assert Assert.That(contentType.IsPropertyDirty("HasPropertyTypeBeenRemoved"), Is.True); }
public void Can_Generate_Xml_Representation_Of_Content() { // Arrange var template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); // else, FK violation on contentType! var contentType = ContentTypeBuilder.CreateTextPageContentType( defaultTemplateId: template.Id); ContentTypeService.Save(contentType); var content = ContentBuilder.CreateTextpageContent(contentType, "Root Home", -1); ContentService.Save(content, Constants.Security.SuperUserId); var nodeName = content.ContentType.Alias.ToSafeAlias(ShortStringHelper); var urlName = content.GetUrlSegment(ShortStringHelper, new[] { new DefaultUrlSegmentProvider(ShortStringHelper) }); // Act var element = content.ToXml(Serializer); // Assert Assert.That(element, Is.Not.Null); Assert.That(element.Name.LocalName, Is.EqualTo(nodeName)); Assert.AreEqual(content.Id.ToString(), (string)element.Attribute("id")); Assert.AreEqual(content.ParentId.ToString(), (string)element.Attribute("parentID")); Assert.AreEqual(content.Level.ToString(), (string)element.Attribute("level")); Assert.AreEqual(content.CreatorId.ToString(), (string)element.Attribute("creatorID")); Assert.AreEqual(content.SortOrder.ToString(), (string)element.Attribute("sortOrder")); Assert.AreEqual(content.CreateDate.ToString("s"), (string)element.Attribute("createDate")); Assert.AreEqual(content.UpdateDate.ToString("s"), (string)element.Attribute("updateDate")); Assert.AreEqual(content.Name, (string)element.Attribute("nodeName")); Assert.AreEqual(urlName, (string)element.Attribute("urlName")); Assert.AreEqual(content.Path, (string)element.Attribute("path")); Assert.AreEqual("", (string)element.Attribute("isDoc")); Assert.AreEqual(content.ContentType.Id.ToString(), (string)element.Attribute("nodeType")); Assert.AreEqual(content.GetCreatorProfile(UserService).Name, (string)element.Attribute("creatorName")); Assert.AreEqual(content.GetWriterProfile(UserService).Name, (string)element.Attribute("writerName")); Assert.AreEqual(content.WriterId.ToString(), (string)element.Attribute("writerID")); Assert.AreEqual(content.TemplateId.ToString(), (string)element.Attribute("template")); Assert.AreEqual(content.Properties["title"].GetValue().ToString(), element.Elements("title").Single().Value); Assert.AreEqual(content.Properties["bodyText"].GetValue().ToString(), element.Elements("bodyText").Single().Value); Assert.AreEqual(content.Properties["keywords"].GetValue().ToString(), element.Elements("keywords").Single().Value); Assert.AreEqual(content.Properties["description"].GetValue().ToString(), element.Elements("description").Single().Value); }
public void Can_Remove_PropertyGroup_From_ContentType() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.ResetDirtyProperties(); // Act contentType.PropertyGroups.Remove("content"); // Assert Assert.That(contentType.PropertyGroups.Count, Is.EqualTo(1)); //// Assert.That(contentType.IsPropertyDirty("PropertyGroups"), Is.True); }
public void Can_Verify_Mocked_Content() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); // Act // Assert Assert.That(content, Is.Not.Null); }
public void Can_Deep_Clone_Perf_Test() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.Id = 99; Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); int i = 200; foreach (IProperty property in content.Properties) { property.Id = ++i; } content.Id = 10; content.CreateDate = DateTime.Now; content.CreatorId = 22; content.Key = Guid.NewGuid(); content.Level = 3; content.Path = "-1,4,10"; content.ContentSchedule.Add(DateTime.Now, DateTime.Now.AddDays(1)); //// content.ChangePublishedState(PublishedState.Published); content.SortOrder = 5; content.TemplateId = 88; content.Trashed = false; content.UpdateDate = DateTime.Now; content.WriterId = 23; var runtimeCache = new ObjectCacheAppCache(); runtimeCache.Insert(content.Id.ToString(CultureInfo.InvariantCulture), () => content); IProfilingLogger proflog = GetTestProfilingLogger(); using (proflog.DebugDuration <ContentTests>("STARTING PERF TEST WITH RUNTIME CACHE")) { for (int j = 0; j < 1000; j++) { object clone = runtimeCache.Get(content.Id.ToString(CultureInfo.InvariantCulture)); } } using (proflog.DebugDuration <ContentTests>("STARTING PERF TEST WITHOUT RUNTIME CACHE")) { for (int j = 0; j < 1000; j++) { var clone = (ContentType)contentType.DeepClone(); } } }
public void Can_Add_PropertyGroup_On_ContentType() { // Arrange var contentType = ContentTypeBuilder.CreateTextPageContentType(); // Act contentType.PropertyGroups.Add( new PropertyGroup(true) { Alias = "testGroup", Name = "Test Group", SortOrder = 3 }); // Assert Assert.That(contentType.PropertyGroups.Count, Is.EqualTo(3)); }
public void DirtyProperty_Reset_Clears_SavedPublishedState() { IContentTypeService contentTypeService = Mock.Of <IContentTypeService>(); ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); content.PublishedState = PublishedState.Publishing; Assert.IsFalse(content.Published); content.ResetDirtyProperties(false); // resets Assert.AreEqual(PublishedState.Unpublished, content.PublishedState); Assert.IsFalse(content.Published); }
public void Automatically_Track_Relations() { var mt = MediaTypeBuilder.CreateSimpleMediaType("testMediaType", "Test Media Type"); MediaTypeService.Save(mt); var m1 = MediaBuilder.CreateSimpleMedia(mt, "hello 1", -1); var m2 = MediaBuilder.CreateSimpleMedia(mt, "hello 1", -1); MediaService.Save(m1); MediaService.Save(m2); var template = TemplateBuilder.CreateTextPageTemplate(); FileService.SaveTemplate(template); var ct = ContentTypeBuilder.CreateTextPageContentType("richTextTest", defaultTemplateId: template.Id); ct.AllowedTemplates = Enumerable.Empty <ITemplate>(); ContentTypeService.Save(ct); var c1 = ContentBuilder.CreateTextpageContent(ct, "my content 1", -1); ContentService.Save(c1); var c2 = ContentBuilder.CreateTextpageContent(ct, "my content 2", -1); // 'bodyText' is a property with a RTE property editor which we knows tracks relations c2.Properties["bodyText"].SetValue(@"<p> <img src='/media/12312.jpg' data-udi='umb://media/" + m1.Key.ToString("N") + @"' /> </p><p><img src='/media/234234.jpg' data-udi=""umb://media/" + m2.Key.ToString("N") + @""" /> </p> <p> <a href=""{locallink:umb://document/" + c1.Key.ToString("N") + @"}"">hello</a> </p>"); ContentService.Save(c2); var relations = RelationService.GetByParentId(c2.Id).ToList(); Assert.AreEqual(3, relations.Count); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedMediaAlias, relations[0].RelationType.Alias); Assert.AreEqual(m1.Id, relations[0].ChildId); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedMediaAlias, relations[1].RelationType.Alias); Assert.AreEqual(m2.Id, relations[1].ChildId); Assert.AreEqual(Constants.Conventions.RelationTypes.RelatedDocumentAlias, relations[2].RelationType.Alias); Assert.AreEqual(c1.Id, relations[2].ChildId); }
public void All_Dirty_Properties_Get_Reset() { ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); content.ResetDirtyProperties(false); Assert.IsFalse(content.IsDirty()); foreach (IProperty prop in content.Properties) { Assert.IsFalse(prop.IsDirty()); } }
public void After_Committing_Changes_Was_Dirty_Is_True() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.ResetDirtyProperties(); // reset // Act contentType.Alias = "newAlias"; contentType.ResetDirtyProperties(); // this would be like committing the entity // Assert Assert.That(contentType.IsDirty(), Is.False); Assert.That(contentType.WasDirty(), Is.True); Assert.That(contentType.WasPropertyDirty("Alias"), Is.True); }
public void Can_Add_PropertyType_To_Group_On_ContentType() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); // Act PropertyType propertyType = new PropertyTypeBuilder() .WithAlias("subtitle") .WithName("Subtitle") .Build(); contentType.PropertyGroups["content"].PropertyTypes.Add(propertyType); // Assert Assert.That(contentType.PropertyGroups["content"].PropertyTypes.Count, Is.EqualTo(3)); }
public void Can_Set_Property_Value_As_String() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); // Act content.SetValue("title", "This is the new title"); // Assert Assert.That(content.Properties.Any(), Is.True); Assert.That(content.Properties["title"], Is.Not.Null); Assert.That(content.Properties["title"].GetValue(), Is.EqualTo("This is the new title")); }
public void Can_Verify_Dirty_Property_On_Content() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType); Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); // Act content.ResetDirtyProperties(); content.Name = "New Home"; // Assert Assert.That(content.Name, Is.EqualTo("New Home")); Assert.That(content.IsPropertyDirty("Name"), Is.True); }