public void Can_Persist_Member_Type() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); var memberType = (IMemberType)MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType); IMemberType sut = repository.Get(memberType.Id); Dictionary <string, PropertyType> standardProps = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper); 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); } }
public void SavingPreservesPassword() { IMember sut; var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); var memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeRepository.Save(memberType); var member = MemberBuilder.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 Built_In_Member_Type_Properties_Are_Automatically_Added_When_Creating() { var stubs = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper); var provider = ScopeProvider; using (provider.CreateScope()) { var repository = CreateRepository(provider); IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); // created without the stub properties Assert.AreEqual(1, memberType.PropertyGroups.Count); Assert.AreEqual(3, memberType.PropertyTypes.Count()); // saving *new* member type adds the stub properties repository.Save(memberType); // saving has added (and saved) the 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 static MemberType BuildSimpleMemberType(this MemberTypeBuilder builder) => (MemberType)builder .WithId(10) .WithAlias("memberType") .WithName("Member type") .WithIcon("icon-user-female") .WithPropertyTypeIdsIncrementingFrom(200) .AddPropertyGroup() .WithName("Content") .AddPropertyType() .WithAlias("title") .WithName("Title") .WithSortOrder(1) .Done() .AddPropertyType() .WithValueStorageType(ValueStorageType.Ntext) .WithAlias("bodyText") .WithName("Body text") .WithSortOrder(2) .WithDataTypeId(-87) .Done() .Done() .WithMemberCanEditProperty("title", true) .WithMemberCanViewProperty("bodyText", true) .Build();
public void Built_In_Member_Type_Properties_Missing_Are_Automatically_Added_When_Creating() { Dictionary <string, PropertyType> stubs = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper); IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); IMemberType memberType = MemberTypeBuilder.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.StandardPropertiesGroupAlias, 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 MemberHasBuiltinProperties() { var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); var memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeRepository.Save(memberType); var member = MemberBuilder.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 + ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper).Count)); Assert.That(sut.Properties.Count(), Is.EqualTo(3 + ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper).Count)); var grp = memberType.CompositionPropertyGroups.FirstOrDefault(x => x.Name == Constants.Conventions.Member.StandardPropertiesGroupName); Assert.IsNotNull(grp); var aliases = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper).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 SavingUpdatesNameAndEmail() { IMember sut; var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); var memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeRepository.Save(memberType); var member = MemberBuilder.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 = MemberTypeBuilder.CreateSimpleMemberType("memberTypeAlias", string.Empty); // Act & Assert Assert.Throws <ArgumentException>(() => MemberTypeService.Save(memberType)); }
private static IMember CreateMember(MemberIdentityUser fakeUser) { var builder = new MemberTypeBuilder(); MemberType memberType = builder.BuildSimpleMemberType(); return(new Member(memberType) { Id = 777, Username = fakeUser.UserName, }); }
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia) { // Create content createdContent = new List <IContent>(); ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah"); ContentTypeService.Save(contentType); for (int i = 0; i < 3; i++) { Content c1 = ContentBuilder.CreateBasicContent(contentType); ContentService.Save(c1); createdContent.Add(c1); } // Create media createdMedia = new List <IMedia>(); MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage"); MediaTypeService.Save(imageType); for (int i = 0; i < 3; i++) { Media c1 = MediaBuilder.CreateMediaImage(imageType, -1); MediaService.Save(c1); createdMedia.Add(c1); } // Create members MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple"); MemberTypeService.Save(memberType); createdMembers = MemberBuilder.CreateSimpleMembers(memberType, 3).ToList(); GetMemberService().Save(createdMembers); IRelationType relType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias); // Relate content to media foreach (IContent content in createdContent) { foreach (IMedia media in createdMedia) { RelationService.Relate(content.Id, media.Id, relType); } } // Relate members to media foreach (IMember member in createdMembers) { foreach (IMedia media in createdMedia) { RelationService.Relate(member.Id, media.Id, relType); } } }
public void Member_Cannot_View_Property() { IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeService.Save(memberType); // re-get memberType = MemberTypeService.Get(memberType.Id); foreach (var p in memberType.PropertyTypes) { Assert.IsFalse(memberType.MemberCanViewProperty(p.Alias)); } }
public void IMemberType_To_MemberTypeDisplay() { // Arrange var memberType = MemberTypeBuilder.CreateSimpleMemberType(); var alias = memberType.PropertyTypes.Last().Alias; memberType.SetIsSensitiveProperty(alias, true); memberType.SetMemberCanEditProperty(alias, true); memberType.SetMemberCanViewProperty(alias, true); MemberTypeBuilder.EnsureAllIds(memberType, 8888); // Act var result = _sut.Map <MemberTypeDisplay>(memberType); // Assert Assert.AreEqual(memberType.Alias, result.Alias); Assert.AreEqual(memberType.Description, result.Description); Assert.AreEqual(memberType.Icon, result.Icon); Assert.AreEqual(memberType.Id, result.Id); Assert.AreEqual(memberType.Name, result.Name); Assert.AreEqual(memberType.ParentId, result.ParentId); Assert.AreEqual(memberType.Path, result.Path); Assert.AreEqual(memberType.Thumbnail, result.Thumbnail); Assert.AreEqual(memberType.IsContainer, result.IsContainer); Assert.AreEqual(memberType.CreateDate, result.CreateDate); Assert.AreEqual(memberType.UpdateDate, result.UpdateDate); Assert.AreEqual(memberType.PropertyGroups.Count(), result.Groups.Count()); for (var i = 0; i < memberType.PropertyGroups.Count(); i++) { Assert.AreEqual(memberType.PropertyGroups.ElementAt(i).Id, result.Groups.ElementAt(i).Id); Assert.AreEqual(memberType.PropertyGroups.ElementAt(i).Name, result.Groups.ElementAt(i).Name); var propTypes = memberType.PropertyGroups.ElementAt(i).PropertyTypes; Assert.AreEqual(propTypes.Count(), result.Groups.ElementAt(i).Properties.Count()); for (var j = 0; j < propTypes.Count(); j++) { Assert.AreEqual(propTypes.ElementAt(j).Id, result.Groups.ElementAt(i).Properties.ElementAt(j).Id); Assert.AreEqual(propTypes.ElementAt(j).DataTypeId, result.Groups.ElementAt(i).Properties.ElementAt(j).DataTypeId); Assert.AreEqual(memberType.MemberCanViewProperty(propTypes.ElementAt(j).Alias), result.Groups.ElementAt(i).Properties.ElementAt(j).MemberCanViewProperty); Assert.AreEqual(memberType.MemberCanEditProperty(propTypes.ElementAt(j).Alias), result.Groups.ElementAt(i).Properties.ElementAt(j).MemberCanEditProperty); } } Assert.AreEqual(memberType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count()); for (var i = 0; i < memberType.AllowedContentTypes.Count(); i++) { Assert.AreEqual(memberType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i)); } }
public void Cannot_Persist_Member_Type_Without_Alias() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); memberType.Alias = null; Assert.Throws <InvalidOperationException>(() => repository.Save(memberType)); } }
private IMemberType CreateTestMemberType(string alias = null) { var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); var memberType = MemberTypeBuilder.CreateSimpleMemberType(alias); MemberTypeRepository.Save(memberType); scope.Complete(); return(memberType); } }
public void Can_Get_Member_Type_By_Guid_Id() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType); memberType = repository.Get(memberType.Key); Assert.That(memberType, Is.Not.Null); } }
public void Empty_Description_Is_Always_Null_After_Saving_Member_Type() { var service = MemberTypeService; var memberType = MemberTypeBuilder.CreateSimpleMemberType(); memberType.Description = null; service.Save(memberType); var memberType2 = MemberTypeBuilder.CreateSimpleMemberType("memberType2", "Member Type 2"); memberType2.Description = string.Empty; service.Save(memberType2); Assert.IsNull(memberType.Description); Assert.IsNull(memberType2.Description); }
public void Bug_Changing_Built_In_Member_Type_Property_Type_Aliases_Results_In_Exception() { Dictionary <string, PropertyType> stubs = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper); IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("mtype"); // created without the stub properties Assert.AreEqual(1, memberType.PropertyGroups.Count); Assert.AreEqual(3, memberType.PropertyTypes.Count()); // saving *new* member type adds the stub properties repository.Save(memberType); // saving has added (and saved) the stub properties Assert.AreEqual(2, memberType.PropertyGroups.Count); Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count()); foreach (KeyValuePair <string, PropertyType> stub in stubs) { IPropertyType prop = memberType.PropertyTypes.First(x => x.Alias == stub.Key); prop.Alias += "__0000"; } // saving *existing* member type does *not* ensure stub properties repository.Save(memberType); // therefore, nothing has changed Assert.AreEqual(2, memberType.PropertyGroups.Count); Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count()); // fetching ensures that the stub properties are there memberType = repository.Get("mtype"); Assert.IsNotNull(memberType); Assert.AreEqual(2, memberType.PropertyGroups.Count); Assert.AreEqual(3 + (stubs.Count * 2), memberType.PropertyTypes.Count()); } }
public void Built_In_Member_Type_Properties_Are_Not_Reused_For_Different_Member_Types() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); IMemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType(); IMemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType("test2"); repository.Save(memberType1); repository.Save(memberType2); int[] m1Ids = memberType1.PropertyTypes.Select(x => x.Id).ToArray(); int[] m2Ids = memberType2.PropertyTypes.Select(x => x.Id).ToArray(); Assert.IsFalse(m1Ids.Any(m2Ids.Contains)); } }
public void Member_Can_View_Property() { IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeService.Save(memberType); var prop = memberType.PropertyTypes.First().Alias; memberType.SetMemberCanViewProperty(prop, true); MemberTypeService.Save(memberType); // re-get memberType = MemberTypeService.Get(memberType.Id); foreach (var p in memberType.PropertyTypes.Where(x => x.Alias != prop)) { Assert.IsFalse(memberType.MemberCanViewProperty(p.Alias)); } Assert.IsTrue(memberType.MemberCanViewProperty(prop)); }
public void Deleting_PropertyType_Removes_The_Property_From_Member() { IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeService.Save(memberType); IMember member = MemberBuilder.CreateSimpleMember(memberType, "test", "*****@*****.**", "pass", "test"); MemberService.Save(member); int initProps = member.Properties.Count; // remove a property (NOT ONE OF THE DEFAULTS) Dictionary <string, PropertyType> standardProps = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper); memberType.RemovePropertyType(memberType.PropertyTypes.First(x => standardProps.ContainsKey(x.Alias) == false).Alias); MemberTypeService.Save(memberType); // re-load it from the db member = MemberService.GetById(member.Id); Assert.AreEqual(initProps - 1, member.Properties.Count); }
private IMember CreateTestMember(IMemberType memberType = null, string name = null, string email = null, string password = null, string username = null, Guid?key = null) { var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); if (memberType == null) { memberType = MemberTypeBuilder.CreateSimpleMemberType(); MemberTypeRepository.Save(memberType); } var member = MemberBuilder.CreateSimpleMember(memberType, name ?? "Johnny Hefty", email ?? "*****@*****.**", password ?? "123", username ?? "hefty", key); repository.Save(member); scope.Complete(); return(member); } }
public void Can_Delete_MemberType() { // Arrange IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); // Act IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType); IMemberType contentType2 = repository.Get(memberType.Id); repository.Delete(contentType2); bool exists = repository.Exists(memberType.Id); // Assert Assert.That(exists, Is.False); } }
public void Can_Get_All_Member_Types() { var provider = ScopeProvider; using (var scope = provider.CreateScope()) { var repository = CreateRepository(provider); var memberType1 = MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType1); var memberType2 = MemberTypeBuilder.CreateSimpleMemberType(); 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_Get_All_Member_Types_By_Guid_Ids() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType1); MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType(); memberType2.Name = "AnotherType"; memberType2.Alias = "anotherType"; repository.Save(memberType2); IEnumerable <IMemberType> result = ((IReadRepository <Guid, IMemberType>)repository).GetMany(memberType1.Key, memberType2.Key); // there are 3 because of the Member type created for init data Assert.AreEqual(2, result.Count()); } }
public void Can_Get_Member_Types_By_Guid_Id() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType1); MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType(); memberType2.Name = "AnotherType"; memberType2.Alias = "anotherType"; repository.Save(memberType2); IMemberType 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() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType(); memberType1.PropertyTypeCollection.Clear(); repository.Save(memberType1); MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType(); memberType2.PropertyTypeCollection.Clear(); memberType2.Name = "AnotherType"; memberType2.Alias = "anotherType"; repository.Save(memberType2); IEnumerable <IMemberType> 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_Same_Property_Keys() { IScopeProvider provider = ScopeProvider; using (IScope scope = provider.CreateScope()) { MemberTypeRepository repository = CreateRepository(provider); var memberType = (IMemberType)MemberTypeBuilder.CreateSimpleMemberType(); repository.Save(memberType); scope.Complete(); Guid[] propertyKeys = memberType.PropertyTypes.Select(x => x.Key).OrderBy(x => x).ToArray(); Guid[] groupKeys = memberType.PropertyGroups.Select(x => x.Key).OrderBy(x => x).ToArray(); memberType = repository.Get(memberType.Id); Guid[] propertyKeys2 = memberType.PropertyTypes.Select(x => x.Key).OrderBy(x => x).ToArray(); Guid[] groupKeys2 = memberType.PropertyGroups.Select(x => x.Key).OrderBy(x => x).ToArray(); Assert.IsTrue(propertyKeys.SequenceEqual(propertyKeys2)); Assert.IsTrue(groupKeys.SequenceEqual(groupKeys2)); } }
/// <summary> /// Setup all standard member data for test /// </summary> private Member SetupMemberTestData( out MemberSave fakeMemberData, out MemberDisplay memberDisplay, ContentSaveAction contentAction) { // arrange MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType(); Member member = MemberBuilder.CreateSimpleMember(memberType, "Test Member", "*****@*****.**", "123", "test"); var memberId = 123; member.Id = memberId; // TODO: replace with builder for MemberSave and MemberDisplay fakeMemberData = new MemberSave() { Id = memberId, SortOrder = member.SortOrder, ContentTypeId = memberType.Id, Key = member.Key, Password = new ChangingPasswordModel() { Id = 456, NewPassword = member.RawPasswordValue, OldPassword = null }, Name = member.Name, Email = member.Email, Username = member.Username, PersistedContent = member, PropertyCollectionDto = new ContentPropertyCollectionDto() { }, Groups = new List <string>(), //Alias = "fakeAlias", ContentTypeAlias = member.ContentTypeAlias, Action = contentAction, Icon = "icon-document", Path = member.Path }; memberDisplay = new MemberDisplay() { Id = memberId, SortOrder = member.SortOrder, ContentTypeId = memberType.Id, Key = member.Key, Name = member.Name, Email = member.Email, Username = member.Username, //Alias = "fakeAlias", ContentTypeAlias = member.ContentTypeAlias, ContentType = new ContentTypeBasic(), ContentTypeName = member.ContentType.Name, Icon = fakeMemberData.Icon, Path = member.Path, Tabs = new List <Tab <ContentPropertyDisplay> >() { new Tab <ContentPropertyDisplay>() { Alias = "test", Id = 77, Properties = new List <ContentPropertyDisplay>() { new ContentPropertyDisplay() { Alias = "_umb_id", View = "idwithguid", Value = new [] { "123", "guid" } }, new ContentPropertyDisplay() { Alias = "_umb_doctype" }, new ContentPropertyDisplay() { Alias = "_umb_login" }, new ContentPropertyDisplay() { Alias = "_umb_email" }, new ContentPropertyDisplay() { Alias = "_umb_password" }, new ContentPropertyDisplay() { Alias = "_umb_membergroup" } } } } }; return(member); }
private static MemberType BuildMemberType() { var builder = new MemberTypeBuilder(); return(builder.BuildSimpleMemberType()); }
public void Is_Built_Correctly() { // Arrange const int testId = 99; var testKey = Guid.NewGuid(); const string testAlias = "memberType"; const string testName = "Member Type"; const string testPropertyGroupName = "Content"; const int testParentId = 98; const int testCreatorId = 22; DateTime testCreateDate = DateTime.Now.AddHours(-1); DateTime testUpdateDate = DateTime.Now; const int testLevel = 3; const string testPath = "-1, 4, 10"; const int testSortOrder = 5; const string testDescription = "The description"; const string testIcon = "icon"; const string testThumbnail = "thumnail"; const bool testTrashed = true; const int testPropertyTypeIdsIncrementingFrom = 200; var testPropertyType1 = new PropertyTypeDetail { Alias = "title", Name = "Title", SortOrder = 1, DataTypeId = -88 }; var testPropertyType2 = new PropertyTypeDetail { Alias = "bodyText", Name = "Body Text", SortOrder = 2, DataTypeId = -87 }; var testPropertyData1 = new KeyValuePair <string, object>("title", "Name member"); var builder = new MemberTypeBuilder(); // Act IMemberType memberType = builder .WithId(testId) .WithKey(testKey) .WithAlias(testAlias) .WithName(testName) .WithCreatorId(testCreatorId) .WithCreateDate(testCreateDate) .WithUpdateDate(testUpdateDate) .WithParentId(testParentId) .WithLevel(testLevel) .WithPath(testPath) .WithSortOrder(testSortOrder) .WithDescription(testDescription) .WithIcon(testIcon) .WithThumbnail(testThumbnail) .WithTrashed(testTrashed) .WithPropertyTypeIdsIncrementingFrom(200) .WithMembershipPropertyGroup() .AddPropertyGroup() .WithId(1) .WithName(testPropertyGroupName) .WithSortOrder(1) .AddPropertyType() .WithAlias(testPropertyType1.Alias) .WithName(testPropertyType1.Name) .WithSortOrder(testPropertyType1.SortOrder) .Done() .AddPropertyType() .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox) .WithValueStorageType(ValueStorageType.Ntext) .WithAlias(testPropertyType2.Alias) .WithName(testPropertyType2.Name) .WithSortOrder(testPropertyType2.SortOrder) .WithDataTypeId(testPropertyType2.DataTypeId) .Done() .Done() .WithMemberCanEditProperty(testPropertyType1.Alias, true) .WithMemberCanViewProperty(testPropertyType2.Alias, true) .Build(); // Assert Assert.AreEqual(testId, memberType.Id); Assert.AreEqual(testAlias, memberType.Alias); Assert.AreEqual(testName, memberType.Name); Assert.AreEqual(testKey, memberType.Key); Assert.AreEqual(testCreateDate, memberType.CreateDate); Assert.AreEqual(testUpdateDate, memberType.UpdateDate); Assert.AreEqual(testCreatorId, memberType.CreatorId); Assert.AreEqual(testParentId, memberType.ParentId); Assert.AreEqual(testLevel, memberType.Level); Assert.AreEqual(testPath, memberType.Path); Assert.AreEqual(testSortOrder, memberType.SortOrder); Assert.AreEqual(testDescription, memberType.Description); Assert.AreEqual(testIcon, memberType.Icon); Assert.AreEqual(testThumbnail, memberType.Thumbnail); Assert.AreEqual(testTrashed, memberType.Trashed); Assert.IsFalse(memberType.IsContainer); Assert.AreEqual(9, memberType.PropertyTypes.Count()); // 7 from membership properties group, 2 custom IOrderedEnumerable <int> propertyTypeIds = memberType.PropertyTypes.Select(x => x.Id).OrderBy(x => x); Assert.AreEqual(testPropertyTypeIdsIncrementingFrom + 1, propertyTypeIds.Min()); Assert.AreEqual(testPropertyTypeIdsIncrementingFrom + 9, propertyTypeIds.Max()); Assert.IsTrue(memberType.MemberCanEditProperty(testPropertyType1.Alias)); Assert.IsFalse(memberType.MemberCanViewProperty(testPropertyType1.Alias)); Assert.IsTrue(memberType.MemberCanViewProperty(testPropertyType2.Alias)); Assert.IsFalse(memberType.MemberCanEditProperty(testPropertyType2.Alias)); }