public void Can_Perform_GetPagedResultsByQuery_WithFilterMatchingSome_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
// Act
var query = Query <IContent> .Builder.Where(x => x.Level == 2);
long totalRecords;
var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "Name", Direction.Ascending, "Page 2");
// Assert
Assert.That(totalRecords, Is.EqualTo(1));
Assert.That(result.Count(), Is.EqualTo(1));
Assert.That(result.First().Name, Is.EqualTo("Text Page 2"));
}
}
public void Can_Perform_GetByQuery_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.RelationTypeId == RelationTypeDto.NodeIdSeed);
var relations = repository.GetByQuery(query);
// Assert
Assert.That(relations, Is.Not.Null);
Assert.That(relations.Any(), Is.True);
Assert.That(relations.Any(x => x == null), Is.False);
Assert.That(relations.Count(), Is.EqualTo(2));
}
}
public void Can_Perform_Add_MasterPage_Detect_Content()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var template = new Template("test", "test")
{
Content = @"<%@ Master Language=""C#"" %>"
};
repository.AddOrUpdate(template);
unitOfWork.Commit();
//Assert
Assert.That(repository.Get("test"), Is.Not.Null);
Assert.That(_masterPageFileSystem.FileExists("test.master"), Is.True);
}
}
public void Can_Perform_GetPagedResultsByQuery_WithFilterMatchingAll_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
// Act
var query = Query <IMedia> .Builder.Where(x => x.Level == 2);
long totalRecords;
var result = repository.GetPagedResultsByQuery(query, 0, 1, out totalRecords, "SortOrder", Direction.Ascending, "Test");
// Assert
Assert.That(totalRecords, Is.EqualTo(2));
Assert.That(result.Count(), Is.EqualTo(1));
Assert.That(result.First().Name, Is.EqualTo("Test Image"));
}
}
public void Default_User_Permissions_Based_On_User_Type()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var utRepo = new UserTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax))
using (var repository = new UserRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, utRepo))
{
// Act
var user1 = MockedUser.CreateUser(CreateAndCommitUserType(), "1", "test", "media");
repository.AddOrUpdate(user1);
unitOfWork.Commit();
// Assert
Assert.AreEqual(3, user1.DefaultPermissions.Count());
Assert.AreEqual("A", user1.DefaultPermissions.ElementAt(0));
Assert.AreEqual("B", user1.DefaultPermissions.ElementAt(1));
Assert.AreEqual("C", user1.DefaultPermissions.ElementAt(2));
}
}
public void Can_Perform_Get_On_DictionaryRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
LanguageRepository languageRepository;
using (var repository = CreateRepository(unitOfWork, out languageRepository))
{
// Act
var dictionaryItem = repository.Get(1);
// Assert
Assert.That(dictionaryItem, Is.Not.Null);
Assert.That(dictionaryItem.ItemKey, Is.EqualTo("Read More"));
Assert.That(dictionaryItem.Translations.Any(), Is.True);
Assert.That(dictionaryItem.Translations.Any(x => x == null), Is.False);
Assert.That(dictionaryItem.Translations.First().Value, Is.EqualTo("Read More"));
Assert.That(dictionaryItem.Translations.Last().Value, Is.EqualTo("Læs mere"));
}
}
public void Can_Perform_Get_By_Guid_On_ContentTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var contentType = repository.Get(NodeDto.NodeIdSeed + 1);
var childContentType = MockedContentTypes.CreateSimpleContentType("blah", "Blah", contentType, randomizeAliases: true);
repository.AddOrUpdate(childContentType);
unitOfWork.Commit();
// Act
var result = repository.Get(childContentType.Key);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(childContentType.Id));
}
}
public void Can_Perform_Update_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
ContentTypeRepository contentTypeRepository;
using (var repository = CreateRepository(unitOfWork, out contentTypeRepository))
{
// Act
var content = repository.Get(1047);
content.Name = "About 2";
repository.AddOrUpdate(content);
unitOfWork.Commit();
var updatedContent = repository.Get(1047);
// Assert
Assert.That(updatedContent.Id, Is.EqualTo(content.Id));
Assert.That(updatedContent.Name, Is.EqualTo(content.Name));
}
}
public void Can_Perform_GetByQuery_On_RelationTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var childObjType = new Guid(Constants.ObjectTypes.DocumentType);
var query = Query <IRelationType> .Builder.Where(x => x.ChildObjectType == childObjType);
var result = repository.GetByQuery(query);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result.Any(), Is.True);
Assert.That(result.Any(x => x == null), Is.False);
Assert.That(result.Count(), Is.EqualTo(1));
}
}
public void Can_Get_Members_By_Ids()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var type = CreateTestMemberType();
var m1 = CreateTestMember(type, "Test 1", "*****@*****.**", "pass1", "test1");
var m2 = CreateTestMember(type, "Test 2", "*****@*****.**", "pass2", "test2");
var members = repository.GetAll(m1.Id, m2.Id);
Assert.That(members, Is.Not.Null);
Assert.That(members.Count(), Is.EqualTo(2));
Assert.That(members.Any(x => x == null), Is.False);
Assert.That(members.Any(x => x.HasIdentity == false), Is.False);
}
}
private void CreateTestData(bool closed, int count, int entityId = -1)
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repo = new TaskRepository(unitOfWork, CacheHelper, Logger, SqlSyntax))
{
for (int i = 0; i < count; i++)
{
repo.AddOrUpdate(new Task(new TaskType("asdfasdf"))
{
AssigneeUserId = 0,
Closed = closed,
Comment = "hello world " + i,
EntityId = entityId,
OwnerUserId = 0
});
unitOfWork.Commit();
}
}
}
public void Can_Perform_Add_On_LanguageRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
// Act
var languageBR = new Language("pt-BR")
{
CultureName = "pt-BR"
};
repository.AddOrUpdate(languageBR);
unitOfWork.Commit();
// Assert
Assert.That(languageBR.HasIdentity, Is.True);
Assert.That(languageBR.Id, Is.EqualTo(6)); //With 5 existing entries the Id should be 6
}
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
UserTypeRepository userTypeRepository;
using (var repository = CreateRepository(unitOfWork, out userTypeRepository))
{
var user = MockedUser.CreateUser(CreateAndCommitUserType());
repository.AddOrUpdate(user);
unitOfWork.Commit();
// Act
var resolved = repository.Get((int)user.Id);
bool dirty = ((User)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
}
public void Can_Delete_Content_And_Verify_Relation_Is_Removed()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
RelationTypeRepository repositoryType;
using (var repository = CreateRepository(unitOfWork, out repositoryType))
{
var content = ServiceContext.ContentService.GetById(NodeDto.NodeIdSeed + 2);
ServiceContext.ContentService.Delete(content, 0);
// Act
var shouldntExist = repository.Exists(1);
var shouldExist = repository.Exists(2);
// Assert
Assert.That(shouldntExist, Is.False);
Assert.That(shouldExist, Is.True);
}
}
public void Can_Perform_Update_On_Repository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = new MacroRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax))
{
// Act
var macro = repository.Get(2);
macro.Name = "Hello";
macro.CacheDuration = 1234;
macro.CacheByPage = true;
macro.CacheByMember = true;
macro.ControlAssembly = "";
macro.ControlType = "";
macro.DontRender = false;
macro.ScriptPath = "~/newpath.cshtml";
macro.UseInEditor = true;
macro.XsltPath = "";
repository.AddOrUpdate(macro);
unitOfWork.Commit();
var macroUpdated = repository.Get(2);
// Assert
Assert.That(macroUpdated, Is.Not.Null);
Assert.That(macroUpdated.Name, Is.EqualTo("Hello"));
Assert.That(macroUpdated.CacheDuration, Is.EqualTo(1234));
Assert.That(macroUpdated.CacheByPage, Is.EqualTo(true));
Assert.That(macroUpdated.CacheByMember, Is.EqualTo(true));
Assert.That(macroUpdated.ControlAssembly, Is.EqualTo(""));
Assert.That(macroUpdated.ControlType, Is.EqualTo(""));
Assert.That(macroUpdated.DontRender, Is.EqualTo(false));
Assert.That(macroUpdated.ScriptPath, Is.EqualTo("~/newpath.cshtml"));
Assert.That(macroUpdated.UseInEditor, Is.EqualTo(true));
Assert.That(macroUpdated.XsltPath, Is.EqualTo(""));
}
}
public void Can_Get_All_Containers()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
EntityContainer container1, container2, container3;
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.DocumentTypeContainerGuid))
{
container1 = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid)
{
Name = "container1"
};
containerRepository.AddOrUpdate(container1);
container2 = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid)
{
Name = "container2"
};
containerRepository.AddOrUpdate(container2);
container3 = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid)
{
Name = "container3"
};
containerRepository.AddOrUpdate(container3);
unitOfWork.Commit();
Assert.That(container1.Id, Is.GreaterThan(0));
Assert.That(container2.Id, Is.GreaterThan(0));
Assert.That(container3.Id, Is.GreaterThan(0));
}
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.DocumentTypeContainerGuid))
{
var found1 = containerRepository.Get(container1.Id);
Assert.IsNotNull(found1);
var found2 = containerRepository.Get(container2.Id);
Assert.IsNotNull(found2);
var found3 = containerRepository.Get(container3.Id);
Assert.IsNotNull(found3);
var allContainers = containerRepository.GetAll();
Assert.AreEqual(3, allContainers.Count());
}
}
public void Can_Perform_Multiple_Adds_On_UserTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var userType1 = MockedUserType.CreateUserType("1");
var userType2 = MockedUserType.CreateUserType("2");
// Act
repository.AddOrUpdate(userType1);
unitOfWork.Commit();
repository.AddOrUpdate(userType2);
unitOfWork.Commit();
// Assert
Assert.That(userType1.HasIdentity, Is.True);
Assert.That(userType2.HasIdentity, Is.True);
}
}
public void Rebuild_All_Xml_Structures_For_Content_Type()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var memberType1 = CreateTestMemberType("mt1");
var memberType2 = CreateTestMemberType("mt2");
var memberType3 = CreateTestMemberType("mt3");
for (var i = 0; i < 30; i++)
{
var member = MockedMember.CreateSimpleMember(memberType1, "b1lah" + i, "b1lah" + i + "@example.com", "b1lah", "b1lah" + i);
repository.AddOrUpdate(member);
}
for (var i = 0; i < 30; i++)
{
var member = MockedMember.CreateSimpleMember(memberType2, "b2lah" + i, "b2lah" + i + "@example.com", "b2lah", "b2lah" + i);
repository.AddOrUpdate(member);
}
for (var i = 0; i < 30; i++)
{
var member = MockedMember.CreateSimpleMember(memberType3, "b3lah" + i, "b3lah" + i + "@example.com", "b3lah", "b3lah" + i);
repository.AddOrUpdate(member);
}
unitOfWork.Commit();
//delete all xml
unitOfWork.Database.Execute("DELETE FROM cmsContentXml");
Assert.AreEqual(0, unitOfWork.Database.ExecuteScalar <int>("SELECT COUNT(*) FROM cmsContentXml"));
repository.RebuildXmlStructures(media => new XElement("test"), 10, contentTypeIds: new[] { memberType1.Id, memberType2.Id });
Assert.AreEqual(60, unitOfWork.Database.ExecuteScalar <int>("SELECT COUNT(*) FROM cmsContentXml"));
}
}
public void Can_Perform_Get_On_ContentRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IContentRepository>(unitOfWork);
// Act
var content = repository.Get(1048);
// Assert
Assert.That(content.Id, Is.EqualTo(1048));
Assert.That(content.CreateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(content.UpdateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(content.ParentId, Is.Not.EqualTo(0));
Assert.That(content.Name, Is.EqualTo("Text Page 2"));
Assert.That(content.SortOrder, Is.EqualTo(1));
Assert.That(content.Version, Is.Not.EqualTo(Guid.Empty));
Assert.That(content.ContentTypeId, Is.EqualTo(1045));
Assert.That(content.Path, Is.Not.Empty);
Assert.That(content.Properties.Any(), Is.True);
}
public void CreateNotification()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repo = new NotificationsRepository(unitOfWork))
{
var node = new NodeDto {
CreateDate = DateTime.Now, Level = 1, NodeObjectType = Guid.Parse(Constants.ObjectTypes.ContentItem), ParentId = -1, Path = "-1,123", SortOrder = 1, Text = "hello", Trashed = false, UniqueId = Guid.NewGuid(), UserId = 0
};
var result = unitOfWork.Database.Insert(node);
var entity = Mock.Of <IEntity>(e => e.Id == node.NodeId);
var user = Mock.Of <IUser>(e => e.Id == node.UserId);
var notification = repo.CreateNotification(user, entity, "A");
Assert.AreEqual("A", notification.Action);
Assert.AreEqual(node.NodeId, notification.EntityId);
Assert.AreEqual(node.NodeObjectType, notification.EntityType);
Assert.AreEqual(node.UserId, notification.UserId);
}
}
public void Can_Perform_Add_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
var mediaType = mediaTypeRepository.Get(1032);
var image = MockedMedia.CreateMediaImage(mediaType, -1);
// Act
mediaTypeRepository.AddOrUpdate(mediaType);
repository.AddOrUpdate(image);
unitOfWork.Commit();
// Assert
Assert.That(mediaType.HasIdentity, Is.True);
Assert.That(image.HasIdentity, Is.True);
}
}
public void Can_Perform_Delete_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
// Act
var media = repository.Get(1047);
repository.Delete(media);
unitOfWork.Commit();
var deleted = repository.Get(1047);
var exists = repository.Exists(1047);
// Assert
Assert.That(deleted, Is.Null);
Assert.That(exists, Is.False);
}
}
public void Path_Is_Set_Correctly_On_Update()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var parent = new Template("parent", "parent");
var child1 = new Template("child1", "child1");
var child2 = new Template("child2", "child2");
var toddler1 = new Template("toddler1", "toddler1");
var toddler2 = new Template("toddler2", "toddler2");
child1.MasterTemplateAlias = parent.Alias;
child1.MasterTemplateId = new Lazy <int>(() => parent.Id);
child2.MasterTemplateAlias = parent.Alias;
child2.MasterTemplateId = new Lazy <int>(() => parent.Id);
toddler1.MasterTemplateAlias = child1.Alias;
toddler1.MasterTemplateId = new Lazy <int>(() => child1.Id);
toddler2.MasterTemplateAlias = child1.Alias;
toddler2.MasterTemplateId = new Lazy <int>(() => child1.Id);
repository.AddOrUpdate(parent);
repository.AddOrUpdate(child1);
repository.AddOrUpdate(child2);
repository.AddOrUpdate(toddler1);
repository.AddOrUpdate(toddler2);
unitOfWork.Commit();
//Act
toddler2.SetMasterTemplate(child2);
repository.AddOrUpdate(toddler2);
unitOfWork.Commit();
//Assert
Assert.AreEqual(string.Format("-1,{0},{1},{2}", parent.Id, child2.Id, toddler2.Id), toddler2.Path);
}
}
public void Can_Get_Children()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var created = CreateHierarchy(repository, unitOfWork).ToArray();
// Act
var childrenById = repository.GetChildren(created[1].Id);
var childrenByAlias = repository.GetChildren(created[1].Alias);
// Assert
Assert.AreEqual(2, childrenById.Count());
Assert.AreEqual(2, childrenById.DistinctBy(x => x.Id).Count());
Assert.AreEqual(2, childrenByAlias.Count());
Assert.AreEqual(2, childrenByAlias.DistinctBy(x => x.Id).Count());
}
}
public void Can_Create_Container()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
EntityContainer container;
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.DocumentTypeContainerGuid))
{
container = new EntityContainer(Constants.ObjectTypes.DocumentTypeGuid)
{
Name = "blah"
};
containerRepository.AddOrUpdate(container);
unitOfWork.Commit();
Assert.That(container.Id, Is.GreaterThan(0));
}
using (var containerRepository = CreateContainerRepository(unitOfWork, Constants.ObjectTypes.DocumentTypeContainerGuid))
{
var found = containerRepository.Get(container.Id);
Assert.IsNotNull(found);
}
}
public void Can_Persist_Member()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var member = CreateTestMember();
var sut = repository.Get(member.Id);
Assert.That(sut, Is.Not.Null);
Assert.That(sut.HasIdentity, Is.True);
Assert.That(sut.Properties.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
Assert.That(sut.Name, Is.EqualTo("Johnny Hefty"));
Assert.That(sut.Email, Is.EqualTo("*****@*****.**"));
Assert.That(sut.RawPasswordValue, Is.EqualTo("123"));
Assert.That(sut.Username, Is.EqualTo("hefty"));
}
}
public void Can_Perform_Update_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MediaTypeRepository mediaTypeRepository;
using (var repository = CreateRepository(unitOfWork, out mediaTypeRepository))
{
// Act
var content = repository.Get(NodeDto.NodeIdSeed + 2);
content.Name = "Test File Updated";
repository.AddOrUpdate(content);
unitOfWork.Commit();
var updatedContent = repository.Get(NodeDto.NodeIdSeed + 2);
// Assert
Assert.That(updatedContent.Id, Is.EqualTo(content.Id));
Assert.That(updatedContent.Name, Is.EqualTo(content.Name));
}
}
public void Can_Perform_Add_On_RelationTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = new RelationTypeRepository(unitOfWork);
// Act
var relateMemberToContent = new RelationType(new Guid("39eb0f98-b348-42a1-8662-e7eb18487560"),
new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"),
"relateMemberToContent")
{
IsBidirectional = true, Name = "Relate Member to Content"
};
repository.AddOrUpdate(relateMemberToContent);
unitOfWork.Commit();
// Assert
Assert.That(relateMemberToContent.HasIdentity, Is.True);
Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);
}
public void Can_Perform_GetAll_By_Guid_On_ContentTypeRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var allGuidIds = repository.GetAll().Select(x => x.Key).ToArray();
// Act
var contentTypes = ((IReadRepository <Guid, IContentType>)repository).GetAll(allGuidIds);
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_Get_On_MediaRepository()
{
// Arrange
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
var repository = RepositoryResolver.Current.ResolveByType <IMediaRepository>(unitOfWork);
// Act
var media = repository.Get(1046);
// Assert
Assert.That(media.Id, Is.EqualTo(1046));
Assert.That(media.CreateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(media.UpdateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(media.ParentId, Is.Not.EqualTo(0));
Assert.That(media.Name, Is.EqualTo("Test Image"));
Assert.That(media.SortOrder, Is.EqualTo(0));
Assert.That(media.Version, Is.Not.EqualTo(Guid.Empty));
Assert.That(media.ContentTypeId, Is.EqualTo(1032));
Assert.That(media.Path, Is.Not.Empty);
Assert.That(media.Properties.Any(), Is.True);
}
/// <summary>
/// The initialize.
/// </summary>
/// <returns>
/// The <see cref="IBootManager"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Throws an exception if Merchello is already initialized
/// </exception>
public override IBootManager Initialize()
{
if (IsInitialized)
throw new InvalidOperationException("The Merchello core boot manager has already been initialized");
OnMerchelloInit();
_timer = DisposableTimer.DebugDuration<CoreBootManager>("Merchello starting", "Merchello startup complete");
// create the service context for the MerchelloAppContext
var connString = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ConnectionString;
var providerName = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ProviderName;
_unitOfWorkProvider = new PetaPocoUnitOfWorkProvider(connString, providerName);
var serviceContext = new ServiceContext(_unitOfWorkProvider);
var cache = ApplicationContext.Current == null
? new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new NullCacheProvider())
: ApplicationContext.Current.ApplicationCache;
InitializeGatewayResolver(serviceContext, cache);
CreateMerchelloContext(serviceContext, cache);
InitializeResolvers();
InitializeObserverSubscriptions();
IsInitialized = true;
return this;
}
/// <summary>
/// Sets up unit of work provider.
/// </summary>
private void SetUnitOfWorkProvider()
{
var connString = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ConnectionString;
var providerName = ConfigurationManager.ConnectionStrings[MerchelloConfiguration.Current.Section.DefaultConnectionStringName].ProviderName;
_unitOfWorkProvider = new PetaPocoUnitOfWorkProvider(_logger, connString, providerName);
}
