public void TryManualLogin_NullPassword() { IUsersStorageProviderV40 prov = GetProvider(); prov.AddUser("user", null, "password", "*****@*****.**", true, DateTime.Now); prov.TryManualLogin("user", null); }
public void GetUsersWithData() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user1 = prov.AddUser("user1", "User1", "password", "*****@*****.**", true, DateTime.UtcNow); UserInfo user2 = prov.AddUser("user2", "User2", "password", "*****@*****.**", true, DateTime.UtcNow); UserInfo user3 = prov.AddUser("user3", "User3", "password", "*****@*****.**", true, DateTime.UtcNow); UserInfo user4 = prov.AddUser("user4", "User4", "password", "*****@*****.**", true, DateTime.UtcNow); Assert.AreEqual(0, prov.GetUsersWithData("Key").Count, "Wrong user count"); prov.StoreUserData(user1, "Key", "Value"); prov.StoreUserData(user2, "Key2", "Value"); prov.StoreUserData(user4, "Key", "Value2"); IDictionary <UserInfo, string> data = prov.GetUsersWithData("Key"); Assert.AreEqual(2, data.Count, "Wrong user count"); UserInfo[] users = new UserInfo[data.Count]; data.Keys.CopyTo(users, 0); AssertUserInfosAreEqual(user1, users[0], true); AssertUserInfosAreEqual(user4, users[1], true); Assert.AreEqual("Value", data[users[0]], "Wrong data"); Assert.AreEqual("Value2", data[users[1]], "Wrong data"); }
public void AddUser_GetUsers() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo u1 = new UserInfo("user", "User", "*****@*****.**", true, DateTime.UtcNow.AddDays(-1), prov); UserInfo u2 = new UserInfo("john", null, "*****@*****.**", false, DateTime.UtcNow, prov); UserInfo u1Out = prov.AddUser(u1.Username, u1.DisplayName, "password", u1.Email, u1.Active, u1.DateTime); Assert.IsNotNull(u1Out, "AddUser should return something"); AssertUserInfosAreEqual(u1, u1Out, true); UserInfo u2Out = prov.AddUser(u2.Username, u2.DisplayName, "password", u2.Email, u2.Active, u2.DateTime); Assert.IsNotNull(u2Out, "AddUser should return something"); AssertUserInfosAreEqual(u2, u2Out, true); Assert.IsNull(prov.AddUser("user", null, "pwd999", "*****@*****.**", false, DateTime.UtcNow), "AddUser should return false"); UserInfo[] users = prov.GetUsers(); Array.Sort(users, delegate(UserInfo x, UserInfo y) { return(x.Username.CompareTo(y.Username)); }); Assert.AreEqual(2, users.Length, "Wrong user count"); AssertUserInfosAreEqual(u2, users[0], true); AssertUserInfosAreEqual(u1, users[1], true); }
public void ModifyUserGroup() { IUsersStorageProviderV40 prov = GetProvider(); UserGroup group1 = prov.AddUserGroup("Group1", "Description1"); UserGroup group2 = prov.AddUserGroup("Group2", "Description2"); Assert.IsNull(prov.ModifyUserGroup(new UserGroup("Inexistent", "Descr", prov), "New"), "ModifyUserGroup should return null"); prov.SetUserMembership(prov.AddUser("user", "user", "pass", "*****@*****.**", true, DateTime.Now), new string[] { "Group2" }); UserGroup group2Out = prov.ModifyUserGroup(new UserGroup("Group2", "Description2", prov), "Mod"); UserGroup expected = new UserGroup("Group2", "Mod", prov); expected.Users = new string[] { "user" }; AssertUserGroupsAreEqual(expected, group2Out, true); UserGroup[] allGroups = prov.GetUserGroups(); Assert.AreEqual(2, allGroups.Length, "Wrong group count"); Array.Sort(allGroups, delegate(UserGroup x, UserGroup y) { return(x.Name.CompareTo(y.Name)); }); AssertUserGroupsAreEqual(new UserGroup("Group1", "Description1", prov), allGroups[0], true); AssertUserGroupsAreEqual(expected, allGroups[1], true); }
public void ModifyUser() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = new UserInfo("username", null, "*****@*****.**", false, DateTime.UtcNow, prov); prov.AddUser(user.Username, user.DisplayName, "password", user.Email, user.Active, user.DateTime); prov.AddUser("zzzz", null, "password2", "*****@*****.**", false, DateTime.UtcNow); // Set new password UserInfo expected = new UserInfo(user.Username, "New Display", "*****@*****.**", true, user.DateTime, prov); UserInfo result = prov.ModifyUser(user, "New Display", "newpass", "*****@*****.**", true); AssertUserInfosAreEqual(expected, result, true); UserInfo[] allUsers = prov.GetUsers(); Assert.AreEqual(2, allUsers.Length, "Wrong user count"); Array.Sort(allUsers, delegate(UserInfo x, UserInfo y) { return(x.Username.CompareTo(y.Username)); }); AssertUserInfosAreEqual(expected, allUsers[0], true); Assert.IsTrue(prov.TestAccount(user, "newpass"), "TestAccount should return true"); // Set null display name expected = new UserInfo(user.Username, null, "*****@*****.**", true, user.DateTime, prov); result = prov.ModifyUser(user, null, null, "*****@*****.**", true); AssertUserInfosAreEqual(expected, result, true); allUsers = prov.GetUsers(); Assert.AreEqual(2, allUsers.Length, "Wrong user count"); Array.Sort(allUsers, delegate(UserInfo x, UserInfo y) { return(x.Username.CompareTo(y.Username)); }); AssertUserInfosAreEqual(expected, allUsers[0], true); Assert.IsTrue(prov.TestAccount(user, "newpass"), "TestAccount should return true"); }
public void StoreUserData_InvalidKey(string k) { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = new UserInfo("User", "User", "*****@*****.**", true, DateTime.Now, prov); prov.StoreUserData(user, k, "Value"); }
public void RetrieveUserData_InvalidKey(string k) { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("User", "User", "password", "*****@*****.**", true, DateTime.Now); prov.RetrieveUserData(user, k); }
public void RetrieveUserData_InexistentKey() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("User", "User", "password", "*****@*****.**", true, DateTime.Now); Assert.IsNull(prov.RetrieveUserData(user, "Inexistent"), "RetrieveUserData should return null"); }
public void Init() { IUsersStorageProviderV40 prov = GetProvider(); prov.Init(MockHost(), connString, null); Assert.IsNotNull(prov.Information, "Information should not be null"); }
public void Init() { IUsersStorageProviderV40 prov = GetProvider(); prov.Init(MockHost(), ConfigurationManager.AppSettings["AzureConnString"], "wiki1"); Assert.IsNotNull(prov.Information, "Information should not be null"); }
/// <summary> /// Detects whether a users storage provider fully supports writing to all managed data. /// </summary> /// <param name="provider">The provider.</param> /// <returns><c>true</c> if the provider fully supports writing all managed data, <c>false</c> otherwise.</returns> private static bool IsUsersProviderFullWriteEnabled(IUsersStorageProviderV40 provider) { return (!provider.UserAccountsReadOnly && !provider.UserGroupsReadOnly && !provider.GroupMembershipReadOnly && !provider.UsersDataReadOnly); }
/// <summary> /// Initializes a new instance of the <b>UserInfo</b> class. /// </summary> /// <param name="username">The Username.</param> /// <param name="displayName">The display name.</param> /// <param name="email">The Email.</param> /// <param name="active">Specifies whether the Account is active or not.</param> /// <param name="dateTime">The creation DateTime.</param> /// <param name="provider">The Users Storage Provider that manages the User.</param> public UserInfo(string username, string displayName, string email, bool active, DateTime dateTime, IUsersStorageProviderV40 provider) { this.username = username; this.displayName = displayName; this.email = email; this.active = active; this.dateTime = dateTime; this.provider = provider; }
public void ModifyUser_InvalidNewEmail(string e) { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = new UserInfo("username", null, "*****@*****.**", true, DateTime.Now, prov); prov.AddUser(user.Username, user.DisplayName, "password", user.Email, user.Active, user.DateTime); prov.ModifyUser(user, "Display Name", null, e, false); }
public void GetUser() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("user", null, "password", "*****@*****.**", true, DateTime.UtcNow); Assert.IsNull(prov.GetUser("inexistent"), "TryGetUser should return null"); UserInfo output = prov.GetUser("user"); AssertUserInfosAreEqual(user, output, true); }
public void RemoveUser() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("user", null, "password", "*****@*****.**", false, DateTime.Now); Assert.IsFalse(prov.RemoveUser(new UserInfo("user1", "Joe", "*****@*****.**", false, DateTime.Now, prov)), "RemoveUser should return false"); Assert.IsTrue(prov.RemoveUser(user), "RemoveUser should return true"); Assert.AreEqual(0, prov.GetUsers().Length, "Wrong user count"); }
/// <summary> /// Verifies the read-only/read-write constraints of providers. /// </summary> /// <typeparam name="T">The type of the provider.</typeparam> /// <param name="provider">The provider.</param> /// <exception cref="T:ProviderConstraintException">Thrown when a constraint is not fulfilled.</exception> private static void VerifyConstraints <T>(T provider) { if (typeof(T) == typeof(IUsersStorageProviderV40)) { // If the provider allows to write user accounts data, then group membership must be writeable too IUsersStorageProviderV40 actualInstance = (IUsersStorageProviderV40)provider; if (!actualInstance.UserAccountsReadOnly && actualInstance.GroupMembershipReadOnly) { throw new ProviderConstraintException("If UserAccountsReadOnly is false, then also GroupMembershipReadOnly must be false"); } } }
public void TestAccount() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo u1 = prov.AddUser("user1", null, "password", "*****@*****.**", true, DateTime.Now); UserInfo u2 = prov.AddUser("user2", "User", "password", "*****@*****.**", false, DateTime.Now); Assert.IsTrue(prov.TestAccount(u1, "password"), "TestAccount should return true"); Assert.IsFalse(prov.TestAccount(new UserInfo(u1.Username.ToUpperInvariant(), null, "*****@*****.**", true, DateTime.Now, prov), "password"), "TestAccount should return false"); Assert.IsFalse(prov.TestAccount(u2, "password"), "TestAccount should return false because the account is disabled"); Assert.IsFalse(prov.TestAccount(new UserInfo("blah", null, "*****@*****.**", true, DateTime.Now, prov), "blah"), "TestAccount should return false"); Assert.IsFalse(prov.TestAccount(u1, "password222"), "TestAccount should return false"); Assert.IsFalse(prov.TestAccount(u1, ""), "TestAccount should return false"); }
/// <summary> /// Detects whether a users provider is included in the list. /// </summary> /// <param name="provider">The provider.</param> /// <returns><c>true</c> if the provider is included, <c>false</c> otherwise.</returns> private bool IsUsersProviderIncludedInList(IUsersStorageProviderV40 provider) { switch (usersProviderIntendedUse) { case UsersProviderIntendedUse.AccountsManagement: return(!provider.UserAccountsReadOnly || (provider.UserAccountsReadOnly && !excludeReadOnly)); case UsersProviderIntendedUse.GroupsManagement: return(!provider.UserGroupsReadOnly || (provider.UserGroupsReadOnly && !excludeReadOnly)); default: throw new NotSupportedException(); } }
public void RemoveUserGroup() { IUsersStorageProviderV40 prov = GetProvider(); UserGroup group1 = prov.AddUserGroup("Group1", "Description1"); UserGroup group2 = prov.AddUserGroup("Group2", "Description2"); Assert.IsFalse(prov.RemoveUserGroup(new UserGroup("Inexistent", "Descr", prov)), "RemoveUserGroup should return false"); Assert.IsTrue(prov.RemoveUserGroup(new UserGroup("Group1", "Desc", prov)), "RemoveUser should return true"); UserGroup[] allGroups = prov.GetUserGroups(); Assert.AreEqual(1, allGroups.Length, "Wrong group count"); AssertUserGroupsAreEqual(group2, allGroups[0], true); }
public void StoreUserData_RetrieveUserData_Overwrite() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("User", "User", "password", "*****@*****.**", true, DateTime.Now); Assert.IsTrue(prov.StoreUserData(user, "Key", "Value1"), "StoreUserData should return true"); Assert.IsTrue(prov.StoreUserData(user, "Key2", "Value2"), "StoreUserData should return true"); Assert.IsTrue(prov.StoreUserData(user, "Key", "Value"), "StoreUserData should return true"); string value = prov.RetrieveUserData(user, "Key"); Assert.AreEqual("Value", value, "Wrong value"); string value2 = prov.RetrieveUserData(user, "Key2"); Assert.AreEqual("Value2", value2, "Wrong value"); }
public void RetrieveAllUserData() { IUsersStorageProviderV40 prov = GetProvider(); Assert.AreEqual(0, prov.RetrieveAllUserData(new UserInfo("Inexistent", "Inex", "*****@*****.**", true, DateTime.Now, prov)).Count, "Wrong data count"); UserInfo user1 = prov.AddUser("user1", "User1", "password", "*****@*****.**", true, DateTime.Now); UserInfo user2 = prov.AddUser("user2", "User2", "password", "*****@*****.**", true, DateTime.Now); Assert.AreEqual(0, prov.RetrieveAllUserData(user1).Count, "Wrong data count"); prov.StoreUserData(user1, "Key", "Value"); prov.StoreUserData(user1, "Key2", "Value2"); prov.StoreUserData(user2, "Key", "Value3"); IDictionary <string, string> data = prov.RetrieveAllUserData(user1); Assert.AreEqual(2, data.Count, "Wrong data count"); Assert.AreEqual("Value", data["Key"], "Wrong data"); Assert.AreEqual("Value2", data["Key2"], "Wrong data"); }
public void AddUserGroup_GetUserGroups() { IUsersStorageProviderV40 prov = GetProvider(); UserGroup group1 = prov.AddUserGroup("Group1", "Test1"); UserGroup expected1 = new UserGroup("Group1", "Test1", prov); UserGroup group2 = prov.AddUserGroup("Group2", "Test2"); UserGroup expected2 = new UserGroup("Group2", "Test2", prov); Assert.IsNull(prov.AddUserGroup("Group1", "Test"), "AddUserGroup should return null"); AssertUserGroupsAreEqual(expected1, group1, true); AssertUserGroupsAreEqual(expected2, group2, true); UserGroup[] allGroups = prov.GetUserGroups(); Assert.AreEqual(2, allGroups.Length, "Wrong group count"); Array.Sort(allGroups, delegate(UserGroup x, UserGroup y) { return(x.Name.CompareTo(y.Name)); }); AssertUserGroupsAreEqual(expected1, allGroups[0], true); AssertUserGroupsAreEqual(expected2, allGroups[1], true); }
/// <summary> /// Detectes whether a provider is included in the list. /// </summary> /// <param name="provider">The provider.</param> /// <returns><c>true</c> if the provider is included, <c>false</c> otherwise.</returns> private bool IsProviderIncludedInList(IProviderV40 provider) { IStorageProviderV40 storageProvider = provider as IStorageProviderV40; IUsersStorageProviderV40 usersProvider = provider as IUsersStorageProviderV40; switch (providerType) { case ProviderType.Users: return(IsUsersProviderIncludedInList(usersProvider)); case ProviderType.Pages: return(storageProvider == null || (!storageProvider.ReadOnly || storageProvider.ReadOnly && !excludeReadOnly)); case ProviderType.Files: return(storageProvider == null || (!storageProvider.ReadOnly || storageProvider.ReadOnly && !excludeReadOnly)); case ProviderType.Themes: return(storageProvider == null || (!storageProvider.ReadOnly || storageProvider.ReadOnly && !excludeReadOnly)); default: throw new NotSupportedException(); } }
public void TryManualLogin() { IUsersStorageProviderV40 prov = GetProvider(); UserInfo user = prov.AddUser("user", null, "password", "*****@*****.**", true, DateTime.UtcNow); prov.AddUser("user2", null, "password", "*****@*****.**", false, DateTime.UtcNow); UserInfo output = prov.TryManualLogin("inexistent", "password"); Assert.IsNull(output, "TryManualLogin should return null"); output = prov.TryManualLogin("inexistent", ""); Assert.IsNull(output, "TryManualLogin should return null"); output = prov.TryManualLogin("", "password"); Assert.IsNull(output, "TryManualLogin should return null"); output = prov.TryManualLogin("user2", "password"); Assert.IsNull(output, "TryManualLogin should return null because the account is inactive"); output = prov.TryManualLogin("user", "password"); AssertUserInfosAreEqual(user, output, true); }
public void GetUserByEmail_InvalidEmail(string e) { IUsersStorageProviderV40 prov = GetProvider(); prov.GetUserByEmail(e); }
public void RetrieveAllUserData_NullUser() { IUsersStorageProviderV40 prov = GetProvider(); prov.RetrieveAllUserData(null); }
public void GetUsersWithData_InvalidKey(string k) { IUsersStorageProviderV40 prov = GetProvider(); prov.GetUsersWithData(k); }
public void StoreUserData_NullUser() { IUsersStorageProviderV40 prov = GetProvider(); prov.StoreUserData(null, "Key", "Value"); }
public void NotifyLogout_NullUser() { IUsersStorageProviderV40 prov = GetProvider(); prov.NotifyLogout(null); }
public void NotifyCookieLogin_NullUser() { IUsersStorageProviderV40 prov = GetProvider(); prov.NotifyCookieLogin(null); }