public void Can_Verify_Content_Is_Trashed()
{
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
// Act
content.ResetDirtyProperties();
content.ChangeTrashedState(true);
// Assert
Assert.That(content.IsPropertyDirty("Trashed"), Is.True);
Assert.That(content.Trashed, Is.True);
Assert.That(content.IsPropertyDirty("Name"), Is.False);
}
public void Can_Add_PropertyGroup_On_ContentType()
{
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
// Act
contentType.PropertyGroups.Add(new PropertyGroup {
Name = "Test Group", SortOrder = 3
});
// Assert
Assert.That(contentType.PropertyGroups.Count, Is.EqualTo(3));
Assert.That(content.PropertyGroups.Count(), Is.EqualTo(3));
}
public void Can_Change_ContentType_On_Content_And_Clear_Old_PropertyTypes()
{
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
var simpleContentType = MockedContentTypes.CreateSimpleContentType();
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
// Act
content.ChangeContentType(simpleContentType, true);
// Assert
Assert.That(content.Properties.Contains("author"), Is.True);
Assert.That(content.Properties.Contains("keywords"), Is.False);
Assert.That(content.Properties.Contains("description"), Is.False);
}
public void Can_Change_ContentType_On_Content_And_Set_Property_Value()
{
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
var simpleContentType = MockedContentTypes.CreateSimpleContentType();
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
// Act
content.ChangeContentType(simpleContentType);
content.SetValue("author", "John Doe");
// Assert
Assert.That(content.Properties.Contains("author"), Is.True);
Assert.That(content.Properties["author"].Value, Is.EqualTo("John Doe"));
}
public void Ensure_Content_Xml_Created()
{
var mediaService = ServiceContext.MediaService;
var mediaType = MockedContentTypes.CreateVideoMediaType();
ServiceContext.MediaTypeService.Save(mediaType);
var media = mediaService.CreateMedia("Test", -1, "video");
mediaService.Save(media);
using (var scope = ScopeProvider.CreateScope())
{
Assert.IsTrue(scope.Database.Exists <ContentXmlDto>(media.Id));
}
}
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 To_Content_Item_Simple()
{
var contentType = MockedContentTypes.CreateSimpleContentType();
var content = MockedContent.CreateSimpleContent(contentType);
FixUsers(content);
var result = Mapper.Map <IContent, ContentItemBasic <ContentPropertyBasic> >(content);
AssertBasics(result, content);
foreach (var p in content.Properties)
{
AssertBasicProperty(result, p);
}
}
public void To_Media_Item_Simple()
{
var contentType = MockedContentTypes.CreateImageMediaType();
var content = MockedMedia.CreateMediaImage(contentType, -1);
FixUsers(content);
var result = Mapper.Map <IMedia, ContentItemBasic <ContentPropertyBasic> >(content);
AssertBasics(result, content);
foreach (var p in content.Properties)
{
AssertBasicProperty(result, p);
}
}
public void Can_Change_Property_Value_Through_Anonymous_Object()
{
// Arrange
var contentType = MockedContentTypes.CreateTextpageContentType();
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
// Act
content.PropertyValues(new { 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"].Alias, Is.EqualTo("title"));
Assert.That(content.Properties["title"].Value, Is.EqualTo("This is the new title"));
Assert.That(content.Properties["description"].Value, Is.EqualTo("This is the meta description for a textpage"));
}
public void Empty_Description_Is_Always_Null_After_Saving_Member_Type()
{
var service = ServiceContext.MemberTypeService;
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberType.Description = null;
service.Save(memberType);
var memberType2 = MockedContentTypes.CreateSimpleMemberType("memberType2", "Member Type 2");
memberType2.Description = string.Empty;
service.Save(memberType2);
Assert.IsNull(memberType.Description);
Assert.IsNull(memberType2.Description);
}
public void All_Dirty_Properties_Get_Reset()
{
var contentType = MockedContentTypes.CreateTextPageContentType();
Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType);
var content = MockedContent.CreateTextpageContent(contentType, "Textpage", -1);
content.ResetDirtyProperties(false);
Assert.IsFalse(content.IsDirty());
foreach (var prop in content.Properties)
{
Assert.IsFalse(prop.IsDirty());
}
}
private IMemberType CreateTestMemberType(string alias = null)
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
var repository = CreateRepository(provider, out memberTypeRepository, out memberGroupRepository);
var memberType = MockedContentTypes.CreateSimpleMemberType(alias);
memberTypeRepository.Save(memberType);
scope.Complete();
return(memberType);
}
}
public void After_Committing_Changes_Was_Dirty_Is_True()
{
// Arrange
var contentType = MockedContentTypes.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_Perform_Add_On_ContentTypeRepository_After_Model_Mapping()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var contentType = (IContentType)MockedContentTypes.CreateSimpleContentType2("test", "Test", propertyGroupName: "testGroup");
Assert.AreEqual(4, contentType.PropertyTypes.Count());
// there is NO mapping from display to contentType, but only from save
// to contentType, so if we want to test, let's to it properly!
var display = Mapper.Map <DocumentTypeDisplay>(contentType);
var save = MapToContentTypeSave(display);
var mapped = Mapper.Map <IContentType>(save);
Assert.AreEqual(4, mapped.PropertyTypes.Count());
repository.AddOrUpdate(mapped);
unitOfWork.Commit();
Assert.AreEqual(4, mapped.PropertyTypes.Count());
//re-get
contentType = repository.Get(mapped.Id);
Assert.AreEqual(4, contentType.PropertyTypes.Count());
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(contentType.PropertyGroups.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.PropertyTypes.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.Path.Contains(","), Is.True);
Assert.That(contentType.SortOrder, Is.GreaterThan(0));
Assert.That(contentType.PropertyGroups.ElementAt(0).Name == "testGroup", Is.True);
var groupId = contentType.PropertyGroups.ElementAt(0).Id;
var propertyTypes = contentType.PropertyTypes.ToArray();
Assert.AreEqual("gen", propertyTypes[0].Alias); // just to be sure
Assert.IsNull(propertyTypes[0].PropertyGroupId);
Assert.IsTrue(propertyTypes.Skip(1).All((x => x.PropertyGroupId.Value == groupId)));
}
}
public void Publishing_Set_Mandatory_Value()
{
var contentTypeService = ServiceContext.ContentTypeService;
var contentType = MockedContentTypes.CreateTextPageContentType();
var titleProperty = contentType.PropertyTypes.First(x => x.Alias == "title");
titleProperty.Mandatory = true; // make this required!
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate);
contentTypeService.Save(contentType);
var contentService = ServiceContext.ContentService;
IContent document = new Content("content", -1, contentType);
var result = contentService.SaveAndPublish(document);
Assert.IsFalse(result.Success);
Assert.AreEqual("title", result.InvalidProperties.First().Alias);
// when a service operation fails, the object is dirty and should not be re-used,
// re-create it
document = new Content("content", -1, contentType);
void OnSaving(IContentService sender, ContentSavingEventArgs e)
{
var saved = e.SavedEntities.First();
Assert.IsTrue(document.GetValue <string>("title").IsNullOrWhiteSpace());
saved.SetValue("title", "title");
}
//We are binding to Saving (not Publishing), because the Publishing event is really just used for cancelling, it should not be
//used for setting values and it won't actually work! This is because the Publishing event is raised AFTER the values on the model
//are published, but Saving is raised BEFORE.
ContentService.Saving += OnSaving;
try
{
result = contentService.SaveAndPublish(document);
Assert.IsTrue(result.Success); //will succeed now because we were able to specify the required value in the Saving event
}
finally
{
ContentService.Saving -= OnSaving;
}
}
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 TagsAreUpdatedWhenContentIsUnpublishedAndRePublished_Tree()
{
var contentService = ServiceContext.ContentService;
var contentTypeService = ServiceContext.ContentTypeService;
var tagService = ServiceContext.TagService;
var contentType = MockedContentTypes.CreateSimpleContentType("umbMandatory", "Mandatory Doc Type", true);
contentType.PropertyGroups.First().PropertyTypes.Add(
new PropertyType("test", ValueStorageType.Ntext, "tags")
{
DataTypeId = 1041
});
contentTypeService.Save(contentType);
var content1 = MockedContent.CreateSimpleContent(contentType, "Tagged content 1", -1);
content1.AssignTags("tags", new[] { "hello", "world", "some", "tags", "bam" });
contentService.SaveAndPublish(content1);
var content2 = MockedContent.CreateSimpleContent(contentType, "Tagged content 2", content1);
content2.AssignTags("tags", new[] { "hello", "world", "some", "tags" });
contentService.SaveAndPublish(content2);
contentService.Unpublish(content1);
var tags = tagService.GetTagsForEntity(content1.Id);
Assert.AreEqual(0, tags.Count());
// fixme tag & tree issue
// when we (un)publish, we 'just' publish the top one and not the ones below = fails
// see similar note above
tags = tagService.GetTagsForEntity(content2.Id);
Assert.AreEqual(0, tags.Count());
var allTags = tagService.GetAllContentTags();
Assert.AreEqual(0, allTags.Count());
content1.PublishCulture();
contentService.SaveAndPublish(content1);
tags = tagService.GetTagsForEntity(content2.Id);
Assert.AreEqual(4, tags.Count());
allTags = tagService.GetAllContentTags();
Assert.AreEqual(5, allTags.Count());
}
public void Can_Get_All_With_Ids()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (ScopeProvider.CreateScope())
{
var contentRepository = CreateContentRepository(provider, out var contentTypeRepository);
//create data to relate to
var contentType = MockedContentTypes.CreateSimpleContentType("test", "Test");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var content1 = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content1);
var content2 = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content2);
var repository = CreateRepository(provider);
var tags = new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test"
},
new Tag {
Text = "tag3", Group = "test"
},
new Tag {
Text = "tag4", Group = "test"
}
};
repository.Assign(
content1.Id,
contentType.PropertyTypes.First().Id,
tags, false);
// TODO: This would be nice to be able to map the ids back but unfortunately we are not doing this
//var result = repository.GetAll(new[] {tags[0].Id, tags[1].Id, tags[2].Id});
var all = repository.GetMany().ToArray();
var result = repository.GetMany(all[0].Id, all[1].Id, all[2].Id);
Assert.AreEqual(3, result.Count());
}
}
public void CacheActiveForIntsAndGuids()
{
MediaTypeRepository mediaTypeRepository;
var realCache = new AppCaches(
new ObjectCacheAppCache(),
new DictionaryAppCache(),
new IsolatedCaches(t => new ObjectCacheAppCache()));
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider, out mediaTypeRepository, appCaches: realCache);
var udb = (UmbracoDatabase)scope.Database;
udb.EnableSqlCount = false;
var mediaType = MockedContentTypes.CreateSimpleMediaType("umbTextpage1", "Textpage");
mediaTypeRepository.Save(mediaType);
var media = MockedMedia.CreateSimpleMedia(mediaType, "hello", -1);
repository.Save(media);
udb.EnableSqlCount = true;
//go get it, this should already be cached since the default repository key is the INT
var found = repository.Get(media.Id);
Assert.AreEqual(0, udb.SqlCount);
//retrieve again, this should use cache
found = repository.Get(media.Id);
Assert.AreEqual(0, udb.SqlCount);
//reset counter
udb.EnableSqlCount = false;
udb.EnableSqlCount = true;
//now get by GUID, this won't be cached yet because the default repo key is not a GUID
found = repository.Get(media.Key);
var sqlCount = udb.SqlCount;
Assert.Greater(sqlCount, 0);
//retrieve again, this should use cache now
found = repository.Get(media.Key);
Assert.AreEqual(sqlCount, udb.SqlCount);
}
}
public void Can_Merge_Tag_Relations()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (ScopeProvider.CreateScope())
{
var contentRepository = CreateContentRepository(provider, out var contentTypeRepository);
//create data to relate to
var contentType = MockedContentTypes.CreateSimpleContentType("test", "Test");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var content = MockedContent.CreateSimpleContent(contentType);
contentRepository.Save(content);
var repository = CreateRepository(provider);
repository.Assign(
content.Id,
contentType.PropertyTypes.First().Id,
new[]
{
new Tag {
Text = "tag1", Group = "test"
},
new Tag {
Text = "tag2", Group = "test"
},
}, false);
repository.Assign(
content.Id,
contentType.PropertyTypes.First().Id,
new[]
{
new Tag {
Text = "tag2", Group = "test"
},
new Tag {
Text = "tag3", Group = "test"
},
}, false);
var result = repository.GetTagsForEntity(content.Id);
Assert.AreEqual(3, result.Count());
}
}
public void Saving_Set_Value()
{
var contentTypeService = ServiceContext.ContentTypeService;
var contentType = MockedContentTypes.CreateTextPageContentType();
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate);
contentTypeService.Save(contentType);
var contentService = ServiceContext.ContentService;
IContent document = new Content("content", -1, contentType);
void OnSaving(IContentService sender, ContentSavingEventArgs e)
{
var saved = e.SavedEntities.First();
Assert.IsTrue(document.GetValue <string>("title").IsNullOrWhiteSpace());
saved.SetValue("title", "title");
}
void OnSaved(IContentService sender, ContentSavedEventArgs e)
{
var saved = e.SavedEntities.First();
Assert.AreSame("title", document.GetValue <string>("title"));
//we're only dealing with invariant here
var propValue = saved.Properties["title"].Values.First(x => x.Culture == null && x.Segment == null);
Assert.AreEqual("title", propValue.EditedValue);
Assert.IsNull(propValue.PublishedValue);
}
ContentService.Saving += OnSaving;
ContentService.Saved += OnSaved;
try
{
contentService.Save(document);
}
finally
{
ContentService.Saving -= OnSaving;
ContentService.Saved -= OnSaved;
}
}
private IEnumerable <IContent> PrimeDbWithLotsOfContent()
{
var contentType1 = MockedContentTypes.CreateSimpleContentType();
contentType1.AllowedAsRoot = true;
ServiceContext.ContentTypeService.Save(contentType1);
contentType1.AllowedContentTypes = new List <ContentTypeSort>
{
new ContentTypeSort
{
Alias = contentType1.Alias,
Id = new Lazy <int>(() => contentType1.Id),
SortOrder = 0
}
};
var result = new List <IContent>();
ServiceContext.ContentTypeService.Save(contentType1);
IContent lastParent = MockedContent.CreateSimpleContent(contentType1);
ServiceContext.ContentService.SaveAndPublish(lastParent);
result.Add(lastParent);
//create 20 deep
for (var i = 0; i < 20; i++)
{
//for each level, create 20
IContent content = null;
for (var j = 1; j <= 10; j++)
{
content = MockedContent.CreateSimpleContent(contentType1, "Name" + j, lastParent);
//only publish evens
if (j % 2 == 0)
{
ServiceContext.ContentService.SaveAndPublish(content);
}
else
{
ServiceContext.ContentService.Save(content);
}
result.Add(content);
}
//assign the last one as the next parent
lastParent = content;
}
return(result);
}
public void CacheActiveForIntsAndGuids()
{
var realCache = new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new StaticCacheProvider(),
new IsolatedRuntimeCache(t => new ObjectCacheRuntimeCacheProvider()));
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, cacheHelper: realCache);
var udb = (UmbracoDatabase)scope.Database;
udb.EnableSqlCount = false;
var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage1", "Textpage");
ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
contentTypeRepository.Save(contentType);
var content = MockedContent.CreateSimpleContent(contentType);
repository.Save(content);
udb.EnableSqlCount = true;
//go get it, this should already be cached since the default repository key is the INT
repository.Get(content.Id);
Assert.AreEqual(0, udb.SqlCount);
//retrieve again, this should use cache
repository.Get(content.Id);
Assert.AreEqual(0, udb.SqlCount);
//reset counter
udb.EnableSqlCount = false;
udb.EnableSqlCount = true;
//now get by GUID, this won't be cached yet because the default repo key is not a GUID
repository.Get(content.Key);
var sqlCount = udb.SqlCount;
Assert.Greater(sqlCount, 0);
//retrieve again, this should use cache now
repository.Get(content.Key);
Assert.AreEqual(sqlCount, udb.SqlCount);
}
}
private Content[] BuildContentItems(int numberToCreate)
{
var contentType = MockedContentTypes.CreateSimpleContentType();
ServiceContext.ContentTypeService.Save(contentType);
var startContentItems = new List <Content>();
for (var i = 0; i < numberToCreate; i++)
{
startContentItems.Add(MockedContent.CreateSimpleContent(contentType));
}
ServiceContext.ContentService.Save(startContentItems);
return(startContentItems.ToArray());
}
public void To_Content_Item_Dto()
{
var contentType = MockedContentTypes.CreateSimpleContentType();
Mock.Get(_contentTypeService).As <IContentTypeBaseService>().Setup(x => x.Get(It.IsAny <int>())).Returns(contentType);
var content = MockedContent.CreateSimpleContent(contentType);
FixUsers(content);
var result = Mapper.Map <IContent, ContentPropertyCollectionDto>(content);
foreach (var p in content.Properties)
{
AssertProperty(result, p);
}
}
public void Can_Get_Media_With_Crop_By_Path()
{
var mediaService = ServiceContext.MediaService;
var mediaType = MockedContentTypes.CreateImageMediaType("Image2");
ServiceContext.MediaTypeService.Save(mediaType);
var media = MockedMedia.CreateMediaImageWithCrop(mediaType, -1);
mediaService.Save(media);
var mediaPath = "/media/test-image.png";
var resolvedMedia = mediaService.GetMediaByPath(mediaPath);
Assert.IsNotNull(resolvedMedia);
Assert.That(resolvedMedia.GetValue(Constants.Conventions.Media.File).ToString().Contains(mediaPath));
}
public void Rebuild_Member_Xml_On_Property_Removal()
{
var standardProps = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
var contentType1 = MockedContentTypes.CreateSimpleMemberType("test1", "Test1");
ServiceContext.MemberTypeService.Save(contentType1);
var contentItems1 = MockedMember.CreateSimpleMember(contentType1, 10).ToArray();
foreach (var x in contentItems1)
{
ServiceContext.MemberService.Save(x);
}
var alias = contentType1.PropertyTypes.First(x => standardProps.ContainsKey(x.Alias) == false).Alias;
var elementToMatch = "<" + alias + ">";
using (var scope = ScopeProvider.CreateScope())
{
foreach (var c in contentItems1)
{
var xml = scope.Database.FirstOrDefault <ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
Assert.IsNotNull(xml);
Assert.IsTrue(xml.Xml.Contains(elementToMatch)); //verify that it is there before we remove the property
}
scope.Complete();
}
//remove a property (NOT ONE OF THE DEFAULTS)
contentType1.RemovePropertyType(alias);
ServiceContext.MemberTypeService.Save(contentType1);
var reQueried = ServiceContext.MemberTypeService.Get(contentType1.Id);
var reContent = ServiceContext.MemberService.GetById(contentItems1.First().Id);
using (var scope = ScopeProvider.CreateScope())
{
foreach (var c in contentItems1)
{
var xml = scope.Database.FirstOrDefault <ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
Assert.IsNotNull(xml);
Assert.IsFalse(xml.Xml.Contains(elementToMatch)); //verify that it is no longer there
}
scope.Complete();
}
}
public void Built_In_Member_Type_Properties_Are_Automatically_Added_When_Creating()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
repository.AddOrUpdate(memberType);
unitOfWork.Commit();
memberType = repository.Get(memberType.Id);
Assert.That(memberType.PropertyTypes.Count(), Is.EqualTo(3 + Constants.Conventions.Member.GetStandardPropertyTypeStubs().Count));
Assert.That(memberType.PropertyGroups.Count(), Is.EqualTo(2));
}
}
public void Can_Serialize_Content_Type_Without_Error()
{
var ss = new SerializationService(new JsonNetSerializer());
// Arrange
var contentType = MockedContentTypes.CreateTextPageContentType();
contentType.Id = 99;
var i = 200;
foreach (var propertyType in contentType.PropertyTypes)
{
propertyType.Id = ++i;
}
contentType.AllowedTemplates = new[] { new Template((string)"Name", (string)"name")
{
Id = 200
}, new Template((string)"Name2", (string)"name2")
{
Id = 201
} };
contentType.AllowedContentTypes = new[] { new ContentTypeSort(new Lazy <int>(() => 888), 8, "sub"), new ContentTypeSort(new Lazy <int>(() => 889), 9, "sub2") };
contentType.Id = 10;
contentType.CreateDate = DateTime.Now;
contentType.CreatorId = 22;
contentType.SetDefaultTemplate(new Template((string)"Test Template", (string)"testTemplate")
{
Id = 88
});
contentType.Description = "test";
contentType.Icon = "icon";
contentType.IsContainer = true;
contentType.Thumbnail = "thumb";
contentType.Key = Guid.NewGuid();
contentType.Level = 3;
contentType.Path = "-1,4,10";
contentType.SortOrder = 5;
contentType.Trashed = false;
contentType.UpdateDate = DateTime.Now;
var result = ss.ToStream(contentType);
var json = result.ResultStream.ToJsonString();
Debug.Print(json);
}
public void Member_Can_View_Property()
{
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
ServiceContext.MemberTypeService.Save(memberType);
var prop = memberType.PropertyTypes.First().Alias;
memberType.SetMemberCanViewProperty(prop, true);
ServiceContext.MemberTypeService.Save(memberType);
//re-get
memberType = ServiceContext.MemberTypeService.Get(memberType.Id);
foreach (var p in memberType.PropertyTypes.Where(x => x.Alias != prop))
{
Assert.IsFalse(memberType.MemberCanViewProperty(p.Alias));
}
Assert.IsTrue(memberType.MemberCanViewProperty(prop));
}
