public void Rebuild_Member_Xml_On_Alias_Change()
{
var contentType1 = MockedContentTypes.CreateSimpleMemberType("test1", "Test1");
var contentType2 = MockedContentTypes.CreateSimpleMemberType("test2", "Test2");
ServiceContext.MemberTypeService.Save(contentType1);
ServiceContext.MemberTypeService.Save(contentType2);
var contentItems1 = MockedMember.CreateSimpleMember(contentType1, 10).ToArray();
contentItems1.ForEach(x => ServiceContext.MemberService.Save(x));
var contentItems2 = MockedMember.CreateSimpleMember(contentType2, 5).ToArray();
contentItems2.ForEach(x => ServiceContext.MemberService.Save(x));
//only update the contentType1 alias which will force an xml rebuild for all content of that type
contentType1.Alias = "newAlias";
ServiceContext.MemberTypeService.Save(contentType1);
foreach (var c in contentItems1)
{
var xml = DatabaseContext.Database.FirstOrDefault <ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
Assert.IsNotNull(xml);
Assert.IsTrue(xml.Xml.StartsWith("<newAlias"));
}
foreach (var c in contentItems2)
{
var xml = DatabaseContext.Database.FirstOrDefault <ContentXmlDto>("WHERE nodeId = @Id", new { Id = c.Id });
Assert.IsNotNull(xml);
Assert.IsTrue(xml.Xml.StartsWith("<test2")); //should remain the same
}
}
public void MemberRepository_Can_Persist_Member()
{
IMember sut;
var provider = new PetaPocoUnitOfWorkProvider();
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository))
{
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberTypeRepository.AddOrUpdate(memberType);
unitOfWork.Commit();
var member = MockedMember.CreateSimpleContent(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty", -1);
repository.AddOrUpdate(member);
unitOfWork.Commit();
sut = repository.Get(member.Id);
Assert.That(sut, Is.Not.Null);
Assert.That(sut.ContentType.PropertyGroups.Count(), Is.EqualTo(1));
Assert.That(sut.ContentType.PropertyTypes.Count(), Is.EqualTo(12));
Assert.That(sut.Properties.Count(), Is.EqualTo(12));
Assert.That(sut.Properties.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
}
}
public void Can_Get_Custom_Properties()
{
var date = DateTime.Now;
var memberType = MockedContentTypes.CreateSimpleMemberType("Member", "Member");
var member = MockedMember.CreateSimpleMember(memberType, "test name", "*****@*****.**", "test password", "test username");
member.Comments = "test comment";
member.IsApproved = true;
member.IsLockedOut = false;
member.CreateDate = date;
member.LastLoginDate = date.AddMinutes(1);
member.LastLockoutDate = date.AddMinutes(2);
//NOTE: Last activity date is always the same as last login date since we don't have a place to store that data
//member.LastLoginDate = date.AddMinutes(3);
member.LastPasswordChangeDate = date.AddMinutes(4);
member.PasswordQuestion = "test question";
member.Properties["title"].Value = "Test Value 1";
member.Properties["bodyText"].Value = "Test Value 2";
member.Properties["author"].Value = "Test Value 3";
var mpc = new MemberPublishedContent(member);
var d = mpc.AsDynamic();
Assert.AreEqual("Test Value 1", d.title);
Assert.AreEqual("Test Value 1", d.Title);
Assert.AreEqual("Test Value 2", d.bodyText);
Assert.AreEqual("Test Value 2", d.BodyText);
Assert.AreEqual("Test Value 3", d.author);
Assert.AreEqual("Test Value 3", d.Author);
}
public void Can_Persist_Member_Type()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var memberType = (IMemberType)MockedContentTypes.CreateSimpleMemberType();
repository.AddOrUpdate(memberType);
unitOfWork.Commit();
var sut = repository.Get(memberType.Id);
var standardProps = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.PropertyGroups.Count(), Is.EqualTo(2));
Assert.That(sut.PropertyTypes.Count(), Is.EqualTo(3 + standardProps.Count));
Assert.That(sut.PropertyGroups.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
Assert.That(sut.PropertyTypes.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
TestHelper.AssertAllPropertyValuesAreEquals(sut, memberType, "yyyy-MM-dd HH:mm:ss");
}
}
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();
contentItems1.ForEach(x => ServiceContext.MemberService.Save(x));
var alias = contentType1.PropertyTypes.First(x => standardProps.ContainsKey(x.Alias) == false).Alias;
var elementToMatch = "<" + alias + ">";
foreach (var c in contentItems1)
{
var xml = DatabaseContext.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
}
//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);
foreach (var c in contentItems1)
{
var xml = DatabaseContext.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
}
}
public void MemberHasBuiltinProperties()
{
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();
memberTypeRepository.Save(memberType);
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.Save(member);
var sut = repository.Get(member.Id);
Assert.That(memberType.CompositionPropertyGroups.Count(), Is.EqualTo(2));
Assert.That(memberType.CompositionPropertyTypes.Count(), Is.EqualTo(3 + Constants.Conventions.Member.GetStandardPropertyTypeStubs().Count));
Assert.That(sut.Properties.Count(), Is.EqualTo(3 + Constants.Conventions.Member.GetStandardPropertyTypeStubs().Count));
var grp = memberType.CompositionPropertyGroups.FirstOrDefault(x => x.Name == Constants.Conventions.Member.StandardPropertiesGroupName);
Assert.IsNotNull(grp);
var aliases = Constants.Conventions.Member.GetStandardPropertyTypeStubs().Select(x => x.Key).ToArray();
foreach (var p in memberType.CompositionPropertyTypes.Where(x => aliases.Contains(x.Alias)))
{
Assert.AreEqual(grp.Id, p.PropertyGroupId.Value);
}
}
}
public void ValidateUser__must_lock_out_users_after_max_attempts_of_wrong_password()
{
// Arrange
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
ServiceContext.MemberTypeService.Save(memberType);
var member = MockedMember.CreateSimpleMember(memberType, "test", "*****@*****.**", "password", "test");
ServiceContext.MemberService.Save(member);
var wrongPassword = "******";
var numberOfFailedAttempts = MembersMembershipProvider.MaxInvalidPasswordAttempts + 2;
// Act
var memberBefore = ServiceContext.MemberService.GetById(member.Id);
for (int i = 0; i < numberOfFailedAttempts; i++)
{
MembersMembershipProvider.ValidateUser(member.Username, wrongPassword);
}
var memberAfter = ServiceContext.MemberService.GetById(member.Id);
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(0, memberBefore.FailedPasswordAttempts, "Expected 0 failed password attempts before");
Assert.IsFalse(memberBefore.IsLockedOut, "Expected the member NOT to be locked out before");
Assert.AreEqual(MembersMembershipProvider.MaxInvalidPasswordAttempts, memberAfter.FailedPasswordAttempts, "Expected exactly the max possible failed password attempts after");
Assert.IsTrue(memberAfter.IsLockedOut, "Expected the member to be locked out after");
});
}
public void SavingPreservesPassword()
{
IMember sut;
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();
memberTypeRepository.Save(memberType);
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.Save(member);
sut = repository.Get(member.Id);
//when the password is null it will not overwrite what is already there.
sut.RawPasswordValue = null;
repository.Save(sut);
sut = repository.Get(member.Id);
Assert.That(sut.RawPasswordValue, Is.EqualTo("123"));
}
}
public void Can_Get_All_Members_When_No_Properties_Assigned()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var memberType1 = MockedContentTypes.CreateSimpleMemberType();
memberType1.PropertyTypeCollection.Clear();
repository.Save(memberType1);
var memberType2 = MockedContentTypes.CreateSimpleMemberType();
memberType2.PropertyTypeCollection.Clear();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.Save(memberType2);
var result = repository.GetMany();
//there are 3 because of the Member type created for init data
Assert.AreEqual(3, result.Count());
}
}
public void Can_Persist_Member_Type()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var memberType = (IMemberType)MockedContentTypes.CreateSimpleMemberType();
repository.Save(memberType);
var sut = repository.Get(memberType.Id);
var standardProps = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
Assert.That(sut, Is.Not.Null);
Assert.That(sut.PropertyGroups.Count, Is.EqualTo(2));
Assert.That(sut.PropertyTypes.Count(), Is.EqualTo(3 + standardProps.Count));
Assert.That(sut.PropertyGroups.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
Assert.That(sut.PropertyTypes.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
TestHelper.AssertPropertyValuesAreEqual(sut, memberType, "yyyy-MM-dd HH:mm:ss");
}
}
public void New_Member_Has_Built_In_Properties_By_Default()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberTypeRepository.AddOrUpdate(memberType);
unitOfWork.Commit();
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.AddOrUpdate(member);
unitOfWork.Commit();
var sut = repository.Get(member.Id);
Assert.That(sut.ContentType.PropertyGroups.Count(), Is.EqualTo(2));
Assert.That(sut.ContentType.PropertyTypes.Count(), Is.EqualTo(3 + Constants.Conventions.Member.GetStandardPropertyTypeStubs().Count));
Assert.That(sut.Properties.Count(), Is.EqualTo(3 + Constants.Conventions.Member.GetStandardPropertyTypeStubs().Count));
Assert.That(sut.Properties.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
var grp = sut.PropertyGroups.FirstOrDefault(x => x.Name == Constants.Conventions.Member.StandardPropertiesGroupName);
Assert.IsNotNull(grp);
var aliases = Constants.Conventions.Member.GetStandardPropertyTypeStubs().Select(x => x.Key).ToArray();
foreach (var p in sut.PropertyTypes.Where(x => aliases.Contains(x.Alias)))
{
Assert.AreEqual(grp.Id, p.PropertyGroupId.Value);
}
}
}
public void Answer_Is_Encrypted()
{
IMember createdMember = null;
var memberType = MockedContentTypes.CreateSimpleMemberType();
foreach (var p in Constants.Conventions.Member.GetStandardPropertyTypeStubs())
{
memberType.AddPropertyType(p.Value);
}
var mServiceMock = new Mock <IMembershipMemberService>();
mServiceMock.Setup(service => service.Exists("test")).Returns(false);
mServiceMock.Setup(service => service.GetByEmail("*****@*****.**")).Returns(() => null);
mServiceMock.Setup(service => service.GetDefaultMemberType()).Returns("Member");
mServiceMock.Setup(
service => service.CreateWithIdentity(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Callback((string u, string e, string p, string m) =>
{
createdMember = new Member("test", e, u, p, memberType);
})
.Returns(() => createdMember);
var provider = new MembersMembershipProvider(mServiceMock.Object);
provider.Initialize("test", new NameValueCollection());
MembershipCreateStatus status;
provider.CreateUser("test", "test", "testtest$1", "*****@*****.**", "test", "test", true, "test", out status);
Assert.AreNotEqual("test", createdMember.RawPasswordAnswerValue);
Assert.AreEqual(provider.EncryptString("test"), createdMember.RawPasswordAnswerValue);
}
public void MemberRepository_Can_Update_Email_And_Login_When_Changed()
{
IMember sut;
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberTypeRepository.AddOrUpdate(memberType);
unitOfWork.Commit();
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.AddOrUpdate(member);
unitOfWork.Commit();
sut = repository.Get(member.Id);
sut.Username = "******";
sut.Email = "*****@*****.**";
repository.AddOrUpdate(sut);
unitOfWork.Commit();
sut = repository.Get(member.Id);
Assert.That(sut.Email, Is.EqualTo("*****@*****.**"));
Assert.That(sut.Username, Is.EqualTo("This is new"));
}
}
public void MemberRepository_Does_Not_Replace_Password_When_Null()
{
IMember sut;
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberTypeRepository.AddOrUpdate(memberType);
unitOfWork.Commit();
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.AddOrUpdate(member);
unitOfWork.Commit();
sut = repository.Get(member.Id);
//when the password is null it will not overwrite what is already there.
sut.RawPasswordValue = null;
repository.AddOrUpdate(sut);
unitOfWork.Commit();
sut = repository.Get(member.Id);
Assert.That(sut.RawPasswordValue, Is.EqualTo("123"));
}
}
public void Built_In_Member_Type_Properties_Missing_Are_Automatically_Added_When_Creating()
{
var stubs = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
var provider = TestObjects.GetScopeProvider(Logger);
using (provider.CreateScope())
{
var repository = CreateRepository(provider);
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
// created without the stub properties
Assert.AreEqual(1, memberType.PropertyGroups.Count);
Assert.AreEqual(3, memberType.PropertyTypes.Count());
// add one stub property, others are still missing
memberType.AddPropertyType(stubs.First().Value, Constants.Conventions.Member.StandardPropertiesGroupName);
// saving *new* member type adds the (missing) stub properties
repository.Save(memberType);
// saving has added (and saved) the (missing) stub properties
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
// getting with stub properties
memberType = repository.Get(memberType.Id);
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
}
}
public void Can_Get_Member_Types_By_Guid_Id()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var memberType1 = MockedContentTypes.CreateSimpleMemberType();
repository.Save(memberType1);
var memberType2 = MockedContentTypes.CreateSimpleMemberType();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.Save(memberType2);
var result = repository.Get(memberType1.Key);
//there are 3 because of the Member type created for init data
Assert.IsNotNull(result);
Assert.AreEqual(memberType1.Key, result.Key);
}
}
public void Can_Get_All_Members_When_No_Properties_Assigned()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var memberType1 = MockedContentTypes.CreateSimpleMemberType();
memberType1.PropertyTypeCollection.Clear();
repository.AddOrUpdate(memberType1);
unitOfWork.Commit();
var memberType2 = MockedContentTypes.CreateSimpleMemberType();
memberType2.PropertyTypeCollection.Clear();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.AddOrUpdate(memberType2);
unitOfWork.Commit();
var result = repository.GetAll();
//there are 3 because of the Member type created for init data
Assert.AreEqual(3, result.Count());
}
}
public void Can_Serialize_Member_Type_Without_Error()
{
// Arrange
var contentType = MockedContentTypes.CreateSimpleMemberType();
contentType.Id = 99;
var i = 200;
foreach (var propertyType in contentType.PropertyTypes)
{
propertyType.Id = ++i;
}
contentType.Id = 10;
contentType.CreateDate = DateTime.Now;
contentType.CreatorId = 22;
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;
contentType.SetMemberCanEditProperty("title", true);
contentType.SetMemberCanViewProperty("bodyText", true);
var json = JsonConvert.SerializeObject(contentType);
Debug.Print(json);
}
public void SavingUpdatesNameAndEmail()
{
IMember sut;
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();
memberTypeRepository.Save(memberType);
var member = MockedMember.CreateSimpleMember(memberType, "Johnny Hefty", "*****@*****.**", "123", "hefty");
repository.Save(member);
sut = repository.Get(member.Id);
sut.Username = "******";
sut.Email = "*****@*****.**";
repository.Save(sut);
sut = repository.Get(member.Id);
Assert.That(sut.Email, Is.EqualTo("*****@*****.**"));
Assert.That(sut.Username, Is.EqualTo("This is new"));
}
}
public void Cannot_Save_MemberType_With_Empty_Name()
{
// Arrange
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType("memberTypeAlias", string.Empty);
// Act & Assert
Assert.Throws <ArgumentException>(() => ServiceContext.MemberTypeService.Save(memberType));
}
public void Member_Cannot_View_Property()
{
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
ServiceContext.MemberTypeService.Save(memberType);
//re-get
memberType = ServiceContext.MemberTypeService.Get(memberType.Id);
foreach (var p in memberType.PropertyTypes)
{
Assert.IsFalse(memberType.MemberCanViewProperty(p.Alias));
}
}
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia)
{
//Create content
createdContent = new List <IContent>();
var contentType = MockedContentTypes.CreateBasicContentType("blah");
ServiceContext.ContentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedContent.CreateBasicContent(contentType);
ServiceContext.ContentService.Save(c1);
createdContent.Add(c1);
}
//Create media
createdMedia = new List <IMedia>();
var imageType = MockedContentTypes.CreateImageMediaType("myImage");
ServiceContext.MediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedMedia.CreateMediaImage(imageType, -1);
ServiceContext.MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
var memberType = MockedContentTypes.CreateSimpleMemberType("simple");
ServiceContext.MemberTypeService.Save(memberType);
createdMembers = MockedMember.CreateSimpleMember(memberType, 10).ToList();
ServiceContext.MemberService.Save(createdMembers);
var relType = ServiceContext.RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
// Relate content to media
foreach (var content in createdContent)
{
foreach (var media in createdMedia)
{
ServiceContext.RelationService.Relate(content.Id, media.Id, relType);
}
}
// Relate members to media
foreach (var member in createdMembers)
{
foreach (var media in createdMedia)
{
ServiceContext.RelationService.Relate(member.Id, media.Id, relType);
}
}
}
public void Can_Get_Member_Type_By_Guid_Id()
{
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.Key);
Assert.That(memberType, Is.Not.Null);
}
}
public void Cannot_Persist_Member_Type_Without_Alias()
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
using (var repository = CreateRepository(unitOfWork))
{
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberType.Alias = null;
repository.AddOrUpdate(memberType);
Assert.Throws <InvalidOperationException>(unitOfWork.Commit);
}
}
private IMemberType CreateTestMemberType(string alias = null)
{
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
MemberTypeRepository memberTypeRepository;
MemberGroupRepository memberGroupRepository;
using (var repository = CreateRepository(unitOfWork, out memberTypeRepository, out memberGroupRepository))
{
var memberType = MockedContentTypes.CreateSimpleMemberType(alias);
memberTypeRepository.AddOrUpdate(memberType);
unitOfWork.Commit();
return(memberType);
}
}
public void Can_Get_Member_Type_By_Guid_Id()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
repository.Save(memberType);
memberType = repository.Get(memberType.Key);
Assert.That(memberType, Is.Not.Null);
}
}
public void Cannot_Persist_Member_Type_Without_Alias()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository(provider);
var memberType = MockedContentTypes.CreateSimpleMemberType();
memberType.Alias = null;
Assert.Throws <InvalidOperationException>(() => repository.Save(memberType));
}
}
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 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 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));
}
}
