public void Can_Delete_Container_Containing_Media_Types()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var containerRepository = CreateContainerRepository((IScopeAccessor)provider, Constants.ObjectTypes.MediaTypeContainer);
var repository = CreateMediaTypeRepository((IScopeAccessor)provider);
var container = new EntityContainer(Constants.ObjectTypes.MediaType)
{
Name = "blah"
};
containerRepository.Save(container);
IMediaType contentType = MockedContentTypes.CreateSimpleMediaType("test", "Test", propertyGroupName: "testGroup");
contentType.ParentId = container.Id;
repository.Save(contentType);
// Act
containerRepository.Delete(container);
var found = containerRepository.Get(container.Id);
Assert.IsNull(found);
contentType = repository.Get(contentType.Id);
Assert.IsNotNull(contentType);
Assert.AreEqual(-1, contentType.ParentId);
}
}
public void Empty_Description_Is_Always_Null_After_Saving_Media_Type()
{
var mediaType = MockedContentTypes.CreateSimpleMediaType("mediaType", "Media Type");
mediaType.Description = null;
ServiceContext.MediaTypeService.Save(mediaType);
var mediaType2 = MockedContentTypes.CreateSimpleMediaType("mediaType2", "Media Type 2");
mediaType2.Description = string.Empty;
ServiceContext.MediaTypeService.Save(mediaType2);
Assert.IsNull(mediaType.Description);
Assert.IsNull(mediaType2.Description);
}
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 Cache_Active_By_Int_And_Guid()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
var realCache = new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new StaticCacheProvider(),
new IsolatedRuntimeCache(t => new ObjectCacheRuntimeCacheProvider()));
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository, cacheHelper: realCache))
{
DatabaseContext.Database.DisableSqlCount();
var mediaType = MockedContentTypes.CreateSimpleMediaType("umbTextpage1", "Textpage");
var media = MockedMedia.CreateSimpleMedia(mediaType, "hello", -1);
mediaTypeRepository.AddOrUpdate(mediaType);
repository.AddOrUpdate(media);
unitOfWork.Commit();
DatabaseContext.Database.EnableSqlCount();
//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, DatabaseContext.Database.SqlCount);
//retrieve again, this should use cache
found = repository.Get(media.Id);
Assert.AreEqual(0, DatabaseContext.Database.SqlCount);
//reset counter
DatabaseContext.Database.DisableSqlCount();
DatabaseContext.Database.EnableSqlCount();
//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 = DatabaseContext.Database.SqlCount;
Assert.Greater(sqlCount, 0);
//retrieve again, this should use cache now
found = repository.Get(media.Key);
Assert.AreEqual(sqlCount, DatabaseContext.Database.SqlCount);
}
}
public void Can_Copy_MediaType_To_New_Parent_By_Performing_Clone()
{
// Arrange
var parentMediaType1 = MockedContentTypes.CreateSimpleMediaType("parent1", "Parent1");
ServiceContext.MediaTypeService.Save(parentMediaType1);
var parentMediaType2 = MockedContentTypes.CreateSimpleMediaType("parent2", "Parent2", null, true);
ServiceContext.MediaTypeService.Save(parentMediaType2);
var mediaType = MockedContentTypes.CreateImageMediaType("Image2") as IMediaType;
ServiceContext.MediaTypeService.Save(mediaType);
// Act
var clone = mediaType.DeepCloneWithResetIdentities("newcategory");
Assert.IsNotNull(clone);
clone.RemoveContentType("parent1");
clone.AddContentType(parentMediaType2);
clone.ParentId = parentMediaType2.Id;
ServiceContext.MediaTypeService.Save(clone);
// Assert
Assert.That(clone.HasIdentity, Is.True);
var clonedMediaType = ServiceContext.MediaTypeService.Get(clone.Id);
var originalMediaType = ServiceContext.MediaTypeService.Get(mediaType.Id);
Assert.That(clonedMediaType.CompositionAliases().Any(x => x.Equals("parent2")), Is.True);
Assert.That(clonedMediaType.CompositionAliases().Any(x => x.Equals("parent1")), Is.False);
Assert.AreEqual(clonedMediaType.Path, "-1," + parentMediaType2.Id + "," + clonedMediaType.Id);
Assert.AreEqual(clonedMediaType.PropertyTypes.Count(), originalMediaType.PropertyTypes.Count());
Assert.AreNotEqual(clonedMediaType.ParentId, originalMediaType.ParentId);
Assert.AreEqual(clonedMediaType.ParentId, parentMediaType2.Id);
Assert.AreNotEqual(clonedMediaType.Id, originalMediaType.Id);
Assert.AreNotEqual(clonedMediaType.Key, originalMediaType.Key);
Assert.AreNotEqual(clonedMediaType.Path, originalMediaType.Path);
Assert.AreNotEqual(clonedMediaType.PropertyTypes.First(x => x.Alias.StartsWith("umbracoFile")).Id, originalMediaType.PropertyTypes.First(x => x.Alias.StartsWith("umbracoFile")).Id);
Assert.AreNotEqual(clonedMediaType.PropertyGroups.First(x => x.Name.StartsWith("Media")).Id, originalMediaType.PropertyGroups.First(x => x.Name.StartsWith("Media")).Id);
}
public void Deleting_Media_Types_With_Hierarchy_Of_Media_Items_Doesnt_Raise_Trashed_Event_For_Deleted_Items()
{
MediaService.Trashed += MediaServiceOnTrashed;
try
{
IMediaType contentType1 = MockedContentTypes.CreateSimpleMediaType("test1", "Test1");
ServiceContext.MediaTypeService.Save(contentType1);
IMediaType contentType2 = MockedContentTypes.CreateSimpleMediaType("test2", "Test2");
ServiceContext.MediaTypeService.Save(contentType2);
IMediaType contentType3 = MockedContentTypes.CreateSimpleMediaType("test3", "Test3");
ServiceContext.MediaTypeService.Save(contentType3);
var contentTypes = new[] { contentType1, contentType2, contentType3 };
var parentId = -1;
var ids = new List <int>();
for (int i = 0; i < 2; i++)
{
for (var index = 0; index < contentTypes.Length; index++)
{
var contentType = contentTypes[index];
var contentItem = MockedMedia.CreateSimpleMedia(contentType, "MyName_" + index + "_" + i, parentId);
ServiceContext.MediaService.Save(contentItem);
parentId = contentItem.Id;
ids.Add(contentItem.Id);
}
}
foreach (var contentType in contentTypes.Reverse())
{
ServiceContext.MediaTypeService.Delete(contentType);
}
}
finally
{
MediaService.Trashed -= MediaServiceOnTrashed;
}
}
public void Deleting_Media_Type_With_Hierarchy_Of_Media_Items_Moves_Orphaned_Media_To_Recycle_Bin()
{
IMediaType contentType1 = MockedContentTypes.CreateSimpleMediaType("test1", "Test1");
ServiceContext.MediaTypeService.Save(contentType1);
IMediaType contentType2 = MockedContentTypes.CreateSimpleMediaType("test2", "Test2");
ServiceContext.MediaTypeService.Save(contentType2);
IMediaType contentType3 = MockedContentTypes.CreateSimpleMediaType("test3", "Test3");
ServiceContext.MediaTypeService.Save(contentType3);
var contentTypes = new[] { contentType1, contentType2, contentType3 };
var parentId = -1;
var ids = new List <int>();
for (int i = 0; i < 2; i++)
{
for (var index = 0; index < contentTypes.Length; index++)
{
var contentType = contentTypes[index];
var contentItem = MockedMedia.CreateSimpleMedia(contentType, "MyName_" + index + "_" + i, parentId);
ServiceContext.MediaService.Save(contentItem);
parentId = contentItem.Id;
ids.Add(contentItem.Id);
}
}
//delete the first content type, all other content of different content types should be in the recycle bin
ServiceContext.MediaTypeService.Delete(contentTypes[0]);
var found = ServiceContext.MediaService.GetByIds(ids);
Assert.AreEqual(4, found.Count());
foreach (var content in found)
{
Assert.IsTrue(content.Trashed);
}
}
public void Can_Delete_Container_Containing_Media_Types()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
EntityContainer container;
IMediaType contentType;
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.MediaTypeContainerGuid))
using (var repository = CreateMediaTypeRepository(unitOfWork))
{
container = new EntityContainer(Constants.ObjectTypes.MediaTypeGuid)
{
Name = "blah"
};
containerRepository.AddOrUpdate(container);
unitOfWork.Commit();
contentType = MockedContentTypes.CreateSimpleMediaType("test", "Test", propertyGroupName: "testGroup");
contentType.ParentId = container.Id;
repository.AddOrUpdate(contentType);
unitOfWork.Commit();
}
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.MediaTypeContainerGuid))
using (var repository = CreateMediaTypeRepository(unitOfWork))
{
// Act
containerRepository.Delete(container);
unitOfWork.Commit();
var found = containerRepository.Get(container.Id);
Assert.IsNull(found);
contentType = repository.Get(contentType.Id);
Assert.IsNotNull(contentType);
Assert.AreEqual(-1, contentType.ParentId);
}
}
public void Return_List_Of_Content_Items_Where_Media_Item_Referenced()
{
var mt = MockedContentTypes.CreateSimpleMediaType("testMediaType", "Test Media Type");
ServiceContext.MediaTypeService.Save(mt);
var m1 = MockedMedia.CreateSimpleMedia(mt, "hello 1", -1);
ServiceContext.MediaService.Save(m1);
var ct = MockedContentTypes.CreateTextPageContentType("richTextTest");
ct.AllowedTemplates = Enumerable.Empty <ITemplate>();
ServiceContext.ContentTypeService.Save(ct);
void createContentWithMediaRefs()
{
var content = MockedContent.CreateTextpageContent(ct, "my content 2", -1);
//'bodyText' is a property with a RTE property editor which we knows automatically tracks relations
content.Properties["bodyText"].SetValue(@"<p>
<img src='/media/12312.jpg' data-udi='umb://media/" + m1.Key.ToString("N") + @"' />
</p>");
ServiceContext.ContentService.Save(content);
}
for (var i = 0; i < 6; i++)
{
createContentWithMediaRefs(); //create 6 content items referencing the same media
}
var relations = ServiceContext.RelationService.GetByChildId(m1.Id, Constants.Conventions.RelationTypes.RelatedMediaAlias).ToList();
Assert.AreEqual(6, relations.Count);
var entities = ServiceContext.RelationService.GetParentEntitiesFromRelations(relations).ToList();
Assert.AreEqual(6, entities.Count);
}
public void Can_Update_Media_Property_Values()
{
IMediaType mediaType = MockedContentTypes.CreateSimpleMediaType("test", "Test");
ServiceContext.MediaTypeService.Save(mediaType);
IMedia media = MockedMedia.CreateSimpleMedia(mediaType, "hello", -1);
media.SetValue("title", "title of mine");
media.SetValue("bodyText", "hello world");
ServiceContext.MediaService.Save(media);
// re-get
media = ServiceContext.MediaService.GetById(media.Id);
media.SetValue("title", "another title of mine"); // Change a value
media.SetValue("bodyText", null); // Clear a value
media.SetValue("author", "new author"); // Add a value
ServiceContext.MediaService.Save(media);
// re-get
media = ServiceContext.MediaService.GetById(media.Id);
Assert.AreEqual("another title of mine", media.GetValue("title"));
Assert.IsNull(media.GetValue("bodyText"));
Assert.AreEqual("new author", media.GetValue("author"));
}
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));
}
}
}
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"));
}
}