public void Can_Perform_Delete_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new LanguageRepository(unitOfWork);
// Act
var language = repository.Get(3);
repository.Delete(language);
unitOfWork.Commit();
var exists = repository.Exists(3);
// Assert
Assert.That(exists, Is.False);
}
public void Can_Perform_GetAll_With_Params_On_DataTypeDefinitionRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var dataTypeDefinitions = repository.GetAll(-40, -41, -42);
// Assert
Assert.That(dataTypeDefinitions, Is.Not.Null);
Assert.That(dataTypeDefinitions.Any(), Is.True);
Assert.That(dataTypeDefinitions.Any(x => x == null), Is.False);
Assert.That(dataTypeDefinitions.Count(), Is.EqualTo(3));
}
}
public void Can_Perform_GetAll_On_ContentTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IContentTypeRepository>(unitOfWork);
// Act
var contentTypes = repository.GetAll();
int count =
DatabaseContext.Database.ExecuteScalar <int>(
"SELECT COUNT(*) FROM umbracoNode WHERE nodeObjectType = @NodeObjectType",
new { NodeObjectType = new Guid(Constants.ObjectTypes.DocumentType) });
// Assert
Assert.That(contentTypes.Any(), Is.True);
Assert.That(contentTypes.Count(), Is.EqualTo(count));
}
public void Can_Perform_GetAll_By_Param_Ids_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
// Act
var contents = repository.GetAll(NodeDto.NodeIdSeed + 2, NodeDto.NodeIdSeed + 3);
// Assert
Assert.That(contents, Is.Not.Null);
Assert.That(contents.Any(), Is.True);
Assert.That(contents.Count(), Is.EqualTo(2));
}
}
public void Can_Perform_GetByQuery_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
// Act
var query = Query <IContent> .Builder.Where(x => x.Level == 2);
var result = repository.GetByQuery(query);
// Assert
Assert.That(result.Count(), Is.GreaterThanOrEqualTo(2));
}
}
public void Can_Perform_GetAll_By_Param_Ids_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
// Act
var medias = repository.GetAll(1046, 1047);
// Assert
Assert.That(medias, Is.Not.Null);
Assert.That(medias.Any(), Is.True);
Assert.That(medias.Count(), Is.EqualTo(2));
}
}
public void Can_Perform_Get_On_RelationRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repositoryType = new RelationTypeRepository(unitOfWork);
var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
// Act
var relation = repository.Get(1);
// Assert
Assert.That(relation, Is.Not.Null);
Assert.That(relation.HasIdentity, Is.True);
Assert.That(relation.ChildId, Is.EqualTo(1047));
Assert.That(relation.ParentId, Is.EqualTo(1046));
Assert.That(relation.RelationType.Alias, Is.EqualTo("relateContentOnCopy"));
}
public void MemberTypeRepository_Can_Get_MemberType_By_Id()
{
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var memberType = repository.Get(1340);
Assert.That(memberType, Is.Not.Null);
Assert.That(memberType.PropertyTypes.Count(), Is.EqualTo(13));
Assert.That(memberType.PropertyGroups.Any(), Is.False);
repository.AddOrUpdate(memberType);
unitOfWork.Commit();
Assert.That(memberType.PropertyTypes.Any(x => x.HasIdentity == false), Is.False);
}
}
public DbPreTestDataWorker(ServiceContext serviceContext)
{
var syntax = (DbSyntax)Enum.Parse(typeof(DbSyntax), ConfigurationManager.AppSettings["syntax"]);
// sets up the Umbraco SqlSyntaxProvider Singleton
SqlSyntaxProviderTestHelper.EstablishSqlSyntax(syntax);
var uowProvider = new PetaPocoUnitOfWorkProvider();
Database = uowProvider.GetUnitOfWork().Database;
_serviceContext = serviceContext;
WarehouseCatalog = new WarehouseCatalog(Constants.DefaultKeys.Warehouse.DefaultWarehouseKey)
{
Key = Constants.DefaultKeys.Warehouse.DefaultWarehouseCatalogKey
};
}
public void Can_Perform_Get_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
using (var userGroupRepository = CreateUserGroupRepository(unitOfWork))
{
var user = CreateAndCommitUserWithGroup(repository, userGroupRepository, unitOfWork);
// Act
var updatedItem = repository.Get((int)user.Id);
// Assert
AssertPropertyValues(updatedItem, user);
}
}
public void Can_Perform_Add_On_UserGroupRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var userGroup = MockedUserGroup.CreateUserGroup();
// Act
repository.AddOrUpdate(userGroup);
unitOfWork.Commit();
// Assert
Assert.That(userGroup.HasIdentity, Is.True);
}
}
public void Can_Perform_GetAll_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var dictionaryItem = repository.Get(1);
var dictionaryItems = repository.GetAll();
// Assert
Assert.That(dictionaryItems, Is.Not.Null);
Assert.That(dictionaryItems.Any(), Is.True);
Assert.That(dictionaryItems.Any(x => x == null), Is.False);
Assert.That(dictionaryItems.Count(), Is.EqualTo(2));
}
public void Can_Perform_Add_View()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var template = new Template("test", "test");
repository.AddOrUpdate(template);
unitOfWork.Commit();
//Assert
Assert.That(repository.Get("test"), Is.Not.Null);
Assert.That(_viewsFileSystem.FileExists("test.cshtml"), Is.True);
}
}
public void Can_Perform_Count_On_RelationRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
RelationTypeRepository repositoryType;
using (var repository = CreateRepository(unitOfWork, out repositoryType))
{
// Act
var query = Query <IRelation> .Builder.Where(x => x.ParentId == NodeDto.NodeIdSeed + 1);
int count = repository.Count(query);
// Assert
Assert.That(count, Is.EqualTo(2));
}
}
public void Can_Perform_Add_On_Repository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var server = new ServerRegistration("http://shazwazza.com", "COMPUTER4", DateTime.Now);
repository.AddOrUpdate(server);
unitOfWork.Commit();
// Assert
Assert.That(server.HasIdentity, Is.True);
Assert.That(server.Id, Is.EqualTo(4));//With 3 existing entries the Id should be 4
}
}
public void Can_Perform_Exists_On_UserRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var users = CreateAndCommitMultipleUsers(repository, unitOfWork);
// Act
var exists = repository.Exists((int)users[0].Id);
// Assert
Assert.That(exists, Is.True);
}
}
public void Can_Perform_Exists_On_RelationRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
RelationTypeRepository repositoryType;
using (var repository = CreateRepository(unitOfWork, out repositoryType))
{
// Act
var exists = repository.Exists(2);
var doesntExist = repository.Exists(5);
// Assert
Assert.That(exists, Is.True);
Assert.That(doesntExist, Is.False);
}
}
public void Can_Perform_GetAll_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var languages = repository.GetAll();
// Assert
Assert.That(languages, Is.Not.Null);
Assert.That(languages.Any(), Is.True);
Assert.That(languages.Any(x => x == null), Is.False);
Assert.That(languages.Count(), Is.EqualTo(5));
}
}
public void Can_Verify_PropertyTypes_On_Video_MediaType()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IMediaTypeRepository>(unitOfWork);
var mediaType = MockedContentTypes.CreateVideoMediaType();
repository.AddOrUpdate(mediaType);
unitOfWork.Commit();
// Act
var contentType = repository.Get(1045);
// Assert
Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(2));
Assert.That(contentType.PropertyGroups.Count(), Is.EqualTo(1));
}
public void Can_Perform_Get_On_RelationTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var relationType = repository.Get(RelationTypeDto.NodeIdSeed);
// Assert
Assert.That(relationType, Is.Not.Null);
Assert.That(relationType.HasIdentity, Is.True);
Assert.That(relationType.Alias, Is.EqualTo("relateContentOnCopy"));
Assert.That(relationType.Name, Is.EqualTo("Relate Content on Copy"));
}
}
public void Can_Perform_GetAll_With_Params_On_RelationTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var relationTypes = repository.GetAll(2, 3);
// Assert
Assert.That(relationTypes, Is.Not.Null);
Assert.That(relationTypes.Any(), Is.True);
Assert.That(relationTypes.Any(x => x == null), Is.False);
Assert.That(relationTypes.Count(), Is.EqualTo(2));
}
}
public void Can_Perform_GetAll_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
// Act
var contents = repository.GetAll();
// Assert
Assert.That(contents, Is.Not.Null);
Assert.That(contents.Any(), Is.True);
Assert.That(contents.Count(), Is.GreaterThanOrEqualTo(4));
}
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IUserTypeRepository>(unitOfWork);
var userType = MockedUserType.CreateUserType();
repository.AddOrUpdate(userType);
unitOfWork.Commit();
// Act
var resolved = repository.Get(userType.Id);
bool dirty = ((UserType)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
public void Can_Perform_GetByQuery_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var languageRepository = new LanguageRepository(unitOfWork);
var repository = new DictionaryRepository(unitOfWork, languageRepository);
// Act
var query = Query <IDictionaryItem> .Builder.Where(x => x.ItemKey == "Article");
var result = repository.GetByQuery(query);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Any(), Is.True);
Assert.That(result.FirstOrDefault().ItemKey, Is.EqualTo("Article"));
}
public void Can_Perform_Get_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var language = repository.Get(1);
// Assert
Assert.That(language, Is.Not.Null);
Assert.That(language.HasIdentity, Is.True);
Assert.That(language.CultureName, Is.EqualTo("en-US"));
Assert.That(language.IsoCode, Is.EqualTo("en-US"));
}
}
public void Can_Perform_GetByQuery_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
// Act
var query = Query <IMedia> .Builder.Where(x => x.Level == 2);
var result = repository.GetByQuery(query);
// Assert
Assert.That(result.Count(), Is.GreaterThanOrEqualTo(2)); //There should be two entities on level 2: File and Media
}
}
public void Can_Perform_Count_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
LanguageRepository languageRepository;
using (var repository = CreateRepository(unitOfWork, out languageRepository))
{
// Act
var query = Query <IDictionaryItem> .Builder.Where(x => x.ItemKey.StartsWith("Read"));
var result = repository.Count(query);
// Assert
Assert.That(result, Is.EqualTo(1));
}
}
public void Can_Add_Section_ForGroup()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var groups = CreateAndCommitMultipleUserGroups(repository, unitOfWork);
// Act
//add and remove a few times, this tests the internal collection
groups[0].ClearAllowedSections();
groups[0].AddAllowedSection("content");
groups[0].AddAllowedSection("media");
groups[0].RemoveAllowedSection("content");
groups[0].AddAllowedSection("content");
groups[0].AddAllowedSection("settings");
//add the same even though it's already there
groups[0].AddAllowedSection("content");
groups[1].ClearAllowedSections();
groups[1].AddAllowedSection("developer");
groups[2].ClearAllowedSections();
repository.AddOrUpdate(groups[0]);
repository.AddOrUpdate(groups[1]);
repository.AddOrUpdate(groups[2]);
unitOfWork.Commit();
// Assert
var result = repository.GetAll((int)groups[0].Id, (int)groups[1].Id, (int)groups[2].Id).ToArray();
Assert.AreEqual(3, result[0].AllowedSections.Count());
Assert.IsTrue(result[0].AllowedSections.Contains("content"));
Assert.IsTrue(result[0].AllowedSections.Contains("media"));
Assert.IsTrue(result[0].AllowedSections.Contains("settings"));
Assert.AreEqual(1, result[1].AllowedSections.Count());
Assert.IsTrue(result[1].AllowedSections.Contains("developer"));
Assert.AreEqual(0, result[2].AllowedSections.Count());
}
}
Can_Verify_That_A_Combination_Of_Adding_And_Deleting_PropertyTypes_Doesnt_Cause_Issues_For_Content_And_ContentType
()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IContentTypeRepository>(unitOfWork);
var contentRepository = RepositoryResolver.Current.ResolveByType <IContentRepository>(unitOfWork);
var contentType = repository.Get(1046);
var subpage = MockedContent.CreateTextpageContent(contentType, "Text Page 1", contentType.Id);
contentRepository.AddOrUpdate(subpage);
unitOfWork.Commit();
//Remove PropertyType
contentType.RemovePropertyType("keywords");
//Add PropertyType
var propertyGroup = contentType.PropertyGroups.First(x => x.Name == "Meta");
propertyGroup.PropertyTypes.Add(new PropertyType(new Guid(), DataTypeDatabaseType.Ntext)
{
Alias = "metaAuthor", Name = "Meta Author", Description = "", HelpText = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88
});
repository.AddOrUpdate(contentType);
unitOfWork.Commit();
// Act
var content = contentRepository.Get(subpage.Id);
content.SetValue("metaAuthor", "John Doe");
contentRepository.AddOrUpdate(content);
unitOfWork.Commit();
//Assert
var updated = contentRepository.Get(subpage.Id);
Assert.That(updated.GetValue("metaAuthor").ToString(), Is.EqualTo("John Doe"));
Assert.That(updated.Properties.First(x => x.Alias == "metaDescription").Value, Is.EqualTo("This is the meta description for a textpage"));
Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(4));
Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "metaAuthor"), Is.True);
Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "keywords"), Is.False);
}
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);
}
}
