private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
{
mediaTypeRepository = new MediaTypeRepository(unitOfWork, NullCacheProvider.Current);
var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current);
var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, mediaTypeRepository, tagRepository);
return repository;
}
public void Can_Perform_Update_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
MediaType videoMediaType = MediaTypeBuilder.CreateNewMediaType();
repository.Save(videoMediaType);
// Act
IMediaType mediaType = repository.Get(videoMediaType.Id);
mediaType.Thumbnail = "Doc2.png";
mediaType.PropertyGroups["media"].PropertyTypes.Add(new PropertyType(ShortStringHelper, "test", ValueStorageType.Ntext, "subtitle")
{
Name = "Subtitle",
Description = "Optional Subtitle",
Mandatory = false,
SortOrder = 1,
DataTypeId = -88
});
repository.Save(mediaType);
bool dirty = ((MediaType)mediaType).IsDirty();
// Assert
Assert.That(mediaType.HasIdentity, Is.True);
Assert.That(dirty, Is.False);
Assert.That(mediaType.Thumbnail, Is.EqualTo("Doc2.png"));
Assert.That(mediaType.PropertyTypes.Any(x => x.Alias == "subtitle"), Is.True);
}
}
public void Can_Update_MediaType_With_PropertyType_Removed()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
MediaType mediaType = MediaTypeBuilder.CreateNewMediaType();
repository.Save(mediaType);
// Act
IMediaType mediaTypeV2 = repository.Get(mediaType.Id);
mediaTypeV2.PropertyGroups["media"].PropertyTypes.Remove("title");
repository.Save(mediaTypeV2);
IMediaType mediaTypeV3 = repository.Get(mediaType.Id);
// Assert
Assert.That(mediaTypeV3.PropertyTypes.Any(x => x.Alias == "title"), Is.False);
Assert.That(mediaTypeV2.PropertyGroups.Count, Is.EqualTo(mediaTypeV3.PropertyGroups.Count));
Assert.That(mediaTypeV2.PropertyTypes.Count(), Is.EqualTo(mediaTypeV3.PropertyTypes.Count()));
}
}
private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
{
mediaTypeRepository = new MediaTypeRepository(unitOfWork, NullCacheProvider.Current);
var repository = new MediaRepository(unitOfWork, NullCacheProvider.Current, mediaTypeRepository);
return(repository);
}
public HttpResponseMessage GetSingleMediaType(int id)
{
var mediaTypeRepository = new MediaTypeRepository();
var singleMediaType = mediaTypeRepository.SingleMediaType(id);
return(Request.CreateResponse(HttpStatusCode.OK, singleMediaType));
}
public void Can_Delete_Container_Containing_Media_Types()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
EntityContainerRepository containerRepository = CreateContainerRepository(provider);
MediaTypeRepository repository = CreateRepository(provider);
var container = new EntityContainer(Constants.ObjectTypes.MediaType)
{
Name = "blah"
};
containerRepository.Save(container);
IMediaType contentType =
MediaTypeBuilder.CreateSimpleMediaType("test", "Test", propertyGroupAlias: "testGroup", propertyGroupName: "testGroup");
contentType.ParentId = container.Id;
repository.Save(contentType);
// Act
containerRepository.Delete(container);
EntityContainer found = containerRepository.Get(container.Id);
Assert.IsNull(found);
contentType = repository.Get(contentType.Id);
Assert.IsNotNull(contentType);
Assert.AreEqual(-1, contentType.ParentId);
}
}
public HttpResponseMessage GetMediaTypes()
{
var mediaTypeRepository = new MediaTypeRepository();
var allMediaTypes = mediaTypeRepository.GetAllMediaTypes();
return(Request.CreateResponse(HttpStatusCode.OK, allMediaTypes));
}
private MediaTypeRepository CreateMediaTypeRepository(IScopeAccessor scopeAccessor)
{
var templateRepository = new TemplateRepository(scopeAccessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches.Disabled);
var contentTypeRepository = new MediaTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository);
return(contentTypeRepository);
}
private MediaRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository)
{
mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var tagRepository = new TagRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var repository = new MediaRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of <IContentSection>());
return(repository);
}
private MediaRepository CreateMediaRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository)
{
var accessor = (IScopeAccessor)provider;
var tagRepository = new TagRepository(accessor, CacheHelper.Disabled, Logger);
mediaTypeRepository = new MediaTypeRepository(accessor, CacheHelper.Disabled, Logger);
var repository = new MediaRepository(accessor, CacheHelper.Disabled, Logger, mediaTypeRepository, tagRepository, Mock.Of <IContentSection>(), Mock.Of <ILanguageRepository>());
return(repository);
}
private MediaRepository CreateMediaRepository(IScopeProvider provider, out IMediaTypeRepository mediaTypeRepository)
{
var accessor = (IScopeAccessor)provider;
mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches, Mock.Of <ILogger>());
var tagRepository = new TagRepository(accessor, AppCaches, Mock.Of <ILogger>());
var repository = new MediaRepository(accessor, AppCaches, Mock.Of <ILogger>(), mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>());
return(repository);
}
private MediaRepository CreateRepository(IScopeUnitOfWork unitOfWork, out MediaTypeRepository mediaTypeRepository, CacheHelper cacheHelper = null)
{
cacheHelper = cacheHelper ?? CacheHelper;
mediaTypeRepository = new MediaTypeRepository(unitOfWork, cacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var tagRepository = new TagRepository(unitOfWork, cacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var repository = new MediaRepository(unitOfWork, cacheHelper, Mock.Of <ILogger>(), SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of <IContentSection>());
return(repository);
}
private MediaRepository CreateRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository, AppCaches appCaches = null)
{
appCaches = appCaches ?? AppCaches;
var scopeAccessor = (IScopeAccessor)provider;
mediaTypeRepository = new MediaTypeRepository(scopeAccessor, appCaches, Logger);
var tagRepository = new TagRepository(scopeAccessor, appCaches, Logger);
var repository = new MediaRepository(scopeAccessor, appCaches, Logger, mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>());
return(repository);
}
public void DotMemoryUnitTest()
{
var repo = new MediaTypeRepository();
repo.GetAll();
dotMemory.Check(memory =>
Assert.Equal(1, memory.GetObjects(where => where.Type.Is <MediaType>()).ObjectsCount));
GC.KeepAlive(repo); // prevent objects from GC if this is implied by test logic
}
private MediaRepository CreateRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository, CacheHelper cacheHelper = null)
{
cacheHelper = cacheHelper ?? CacheHelper;
var scopeAccessor = (IScopeAccessor)provider;
mediaTypeRepository = new MediaTypeRepository(scopeAccessor, cacheHelper, Logger);
var tagRepository = new TagRepository(scopeAccessor, cacheHelper, Logger);
var repository = new MediaRepository(scopeAccessor, cacheHelper, Logger, mediaTypeRepository, tagRepository, Mock.Of <IContentSection>(), Mock.Of <ILanguageRepository>());
return(repository);
}
private MediaRepository CreateMediaRepository(IScopeProvider provider, out IMediaTypeRepository mediaTypeRepository)
{
var accessor = (IScopeAccessor)provider;
var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches, Mock.Of <ILogger>(), commonRepository);
var tagRepository = new TagRepository(accessor, AppCaches, Mock.Of <ILogger>());
var repository = new MediaRepository(accessor, AppCaches, Mock.Of <ILogger>(), mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>());
return(repository);
}
private MediaRepository CreateRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository, AppCaches appCaches = null)
{
appCaches = appCaches ?? AppCaches;
var scopeAccessor = (IScopeAccessor)provider;
var templateRepository = new TemplateRepository(scopeAccessor, appCaches, Logger, TestObjects.GetFileSystemsMock());
var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, appCaches);
mediaTypeRepository = new MediaTypeRepository(scopeAccessor, appCaches, Logger, commonRepository);
var tagRepository = new TagRepository(scopeAccessor, appCaches, Logger);
var repository = new MediaRepository(scopeAccessor, appCaches, Logger, mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>());
return(repository);
}
public void Can_Perform_Exists_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
bool exists = repository.Exists(1032); // Image
// Assert
Assert.That(exists, Is.True);
}
}
public void Can_Move()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
EntityContainerRepository containerRepository = CreateContainerRepository(provider);
MediaTypeRepository repository = CreateRepository(provider);
var container1 = new EntityContainer(Constants.ObjectTypes.MediaType)
{
Name = "blah1"
};
containerRepository.Save(container1);
var container2 = new EntityContainer(Constants.ObjectTypes.MediaType)
{
Name = "blah2", ParentId = container1.Id
};
containerRepository.Save(container2);
IMediaType contentType =
MediaTypeBuilder.CreateNewMediaType();
contentType.ParentId = container2.Id;
repository.Save(contentType);
// create a
var contentType2 = (IMediaType) new MediaType(ShortStringHelper, contentType, "hello")
{
Name = "Blahasdfsadf"
};
contentType.ParentId = contentType.Id;
repository.Save(contentType2);
global::Umbraco.Cms.Core.Events.MoveEventInfo <IMediaType>[] result = repository.Move(contentType, container1).ToArray();
Assert.AreEqual(2, result.Length);
// 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 SchemaRepositoryContainer()
{
#region Entity Repositories
Album = new AlbumRepository();
Artist = new ArtistRepository();
Genre = new GenreRepository();
MediaType = new MediaTypeRepository();
Playlist = new PlaylistRepository();
PlaylistTrack = new PlaylistTrackRepository();
Track = new TrackRepository();
#endregion
#region Store Procedure Repository
StoredProcs = new StoredProcRepository();
#endregion
// If not implemented this method is removed during compilation
LoadCustomRepositories();
}
public void Can_Verify_PropertyTypes_On_File_MediaType()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
IMediaType contentType = repository.Get(1033); // File
// Assert
Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(3));
Assert.That(contentType.PropertyGroups.Count(), Is.EqualTo(1));
}
}
private MediaRepository CreateMediaRepository(IScopeProvider provider, out IMediaTypeRepository mediaTypeRepository)
{
var accessor = (IScopeAccessor)provider;
var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
var languageRepository = new LanguageRepository(accessor, AppCaches, Logger);
mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches, Mock.Of <ILogger>(), commonRepository, languageRepository);
var tagRepository = new TagRepository(accessor, AppCaches, Mock.Of <ILogger>());
var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
var entityRepository = new EntityRepository(accessor);
var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository, entityRepository);
var propertyEditors = new Lazy <PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty <IDataEditor>())));
var dataValueReferences = new DataValueReferenceFactoryCollection(Enumerable.Empty <IDataValueReferenceFactory>());
var repository = new MediaRepository(accessor, AppCaches, Mock.Of <ILogger>(), mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors, dataValueReferences);
return(repository);
}
public void Can_Perform_Get_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
IMediaType mediaType = repository.Get(1033); // File
// Assert
Assert.That(mediaType, Is.Not.Null);
Assert.That(mediaType.Id, Is.EqualTo(1033));
Assert.That(mediaType.Name, Is.EqualTo(Constants.Conventions.MediaTypes.File));
}
}
private MediaRepository CreateRepository(IScopeProvider provider, out MediaTypeRepository mediaTypeRepository, AppCaches appCaches = null)
{
appCaches ??= AppCaches.NoCache;
var scopeAccessor = (IScopeAccessor)provider;
var globalSettings = new GlobalSettings();
var commonRepository = new ContentTypeCommonRepository(scopeAccessor, TemplateRepository, appCaches, ShortStringHelper);
var languageRepository = new LanguageRepository(scopeAccessor, appCaches, LoggerFactory.CreateLogger <LanguageRepository>());
mediaTypeRepository = new MediaTypeRepository(scopeAccessor, appCaches, LoggerFactory.CreateLogger <MediaTypeRepository>(), commonRepository, languageRepository, ShortStringHelper);
var tagRepository = new TagRepository(scopeAccessor, appCaches, LoggerFactory.CreateLogger <TagRepository>());
var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <RelationTypeRepository>());
var entityRepository = new EntityRepository(scopeAccessor, AppCaches.Disabled);
var relationRepository = new RelationRepository(scopeAccessor, LoggerFactory.CreateLogger <RelationRepository>(), relationTypeRepository, entityRepository);
var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => Enumerable.Empty <IDataEditor>()));
var mediaUrlGenerators = new MediaUrlGeneratorCollection(() => Enumerable.Empty <IMediaUrlGenerator>());
var dataValueReferences = new DataValueReferenceFactoryCollection(() => Enumerable.Empty <IDataValueReferenceFactory>());
var repository = new MediaRepository(scopeAccessor, appCaches, LoggerFactory.CreateLogger <MediaRepository>(), LoggerFactory, mediaTypeRepository, tagRepository, Mock.Of <ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors, mediaUrlGenerators, dataValueReferences, DataTypeService, JsonSerializer, Mock.Of <IEventAggregator>());
return(repository);
}
public void Can_Verify_PropertyTypes_On_Video_MediaType()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
MediaType mediaType = MediaTypeBuilder.CreateNewMediaType();
repository.Save(mediaType);
// Act
IMediaType contentType = repository.Get(mediaType.Id);
// Assert
Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(2));
Assert.That(contentType.PropertyGroups.Count(), Is.EqualTo(1));
}
}
public void Can_Perform_GetAll_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
IEnumerable <IMediaType> mediaTypes = repository.GetMany();
int count =
ScopeAccessor.AmbientScope.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM umbracoNode WHERE nodeObjectType = @NodeObjectType",
new { NodeObjectType = Constants.ObjectTypes.MediaType });
// Assert
Assert.That(mediaTypes.Any(), Is.True);
Assert.That(mediaTypes.Count(), Is.EqualTo(count));
}
}
public void Can_Perform_Delete_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
MediaType mediaType = MediaTypeBuilder.CreateNewMediaType();
repository.Save(mediaType);
IMediaType contentType2 = repository.Get(mediaType.Id);
repository.Delete(contentType2);
bool exists = repository.Exists(mediaType.Id);
// Assert
Assert.That(exists, Is.False);
}
}
public void Can_Perform_GetAll_By_Guid_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
Guid[] allGuidIds = repository.GetMany().Select(x => x.Key).ToArray();
// Act
IEnumerable <IMediaType> mediaTypes = ((IReadRepository <Guid, IMediaType>)repository).GetMany(allGuidIds);
int count =
scope.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM umbracoNode WHERE nodeObjectType = @NodeObjectType",
new { NodeObjectType = Constants.ObjectTypes.MediaType });
// Assert
Assert.That(mediaTypes.Any(), Is.True);
Assert.That(mediaTypes.Count(), Is.EqualTo(count));
}
}
public void Can_Perform_Add_On_MediaTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaTypeRepository repository = CreateRepository(provider);
// Act
MediaType contentType = MediaTypeBuilder.CreateNewMediaType();
repository.Save(contentType);
IMediaType fetched = repository.Get(contentType.Id);
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(contentType.PropertyGroups.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.Path.Contains(","), Is.True);
Assert.That(contentType.SortOrder, Is.GreaterThan(0));
TestHelper.AssertPropertyValuesAreEqual(contentType, fetched, ignoreProperties: new[] { "UpdateDate" });
}
}
private MediaTypeRepository CreateMediaTypeRepository(IScopeAccessor scopeAccessor)
{
var contentTypeRepository = new MediaTypeRepository(scopeAccessor, AppCaches.Disabled, Logger);
return(contentTypeRepository);
}
private MediaTypeRepository CreateMediaTypeRepository(IScopeUnitOfWork unitOfWork)
{
var contentTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
return(contentTypeRepository);
}
