source: branches/HeuristicLab.Services.Authentication Prototype/UnitTests/HeuristicLabMembershipProviderTest.cs @ 4021

using System;
using System.Collections.Specialized;
using Service.Provider;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Security;
using Persistence;
using System.Linq;
using System.Collections.Generic;
using System.Data.SqlClient;

namespace UnitTests {
  /// <summary>
  ///This is a test class for HeuristicLabMembershipProviderTest and is intended
  ///to contain all HeuristicLabMembershipProviderTest Unit Tests
  ///</summary>
  [TestClass()]
  public class HeuristicLabMembershipProviderTest : AbstractHeuristicLabTest {
    private TestContext testContextInstance;

    /// <summary>
    ///Gets or sets the test context which provides
    ///information about and functionality for the current test run.
    ///</summary>
    public TestContext TestContext {
      get {
        return testContextInstance;
      }
      set {
        testContextInstance = value;
      }
    }

    #region Additional test attributes
    // 
    //You can use the following additional attributes as you write your tests:
    //
    //Use ClassInitialize to run code before running the first test in the class
    //[ClassInitialize()]
    //public static void MyClassInitialize(TestContext testContext)
    //{
    //}
    //
    //Use ClassCleanup to run code after all tests in a class have run
    //[ClassCleanup()]
    //public static void MyClassCleanup()
    //{
    //}
    //
    //Use TestInitialize to run code before running each test
    //[TestInitialize()]
    //public void MyTestInitialize()
    //{
    //}
    //
    //Use TestCleanup to run code after each test has run
    //[TestCleanup()]
    //public void MyTestCleanup()
    //{
    //}
    //
    #endregion


    /// <summary>
    ///A test for RequiresUniqueEmail
    ///</summary>
    [TestMethod()]
    public void RequiresUniqueEmailTest() {
      MembershipProvider target = Membership.Provider;  // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.RequiresUniqueEmail;
      Assert.IsTrue(actual);
    }

    /// <summary>
    ///A test for RequiresQuestionAndAnswer
    ///</summary>
    [TestMethod()]
    public void RequiresQuestionAndAnswerTest() {
      MembershipProvider target = Membership.Provider;  // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.RequiresQuestionAndAnswer;
      Assert.IsFalse(actual);
    }

    /// <summary>
    ///A test for PasswordStrengthRegularExpression
    ///</summary>
    [TestMethod()]
    public void PasswordStrengthRegularExpressionTest() {
      MembershipProvider target = Membership.Provider;
      string actual;
      actual = target.PasswordStrengthRegularExpression;
      Assert.AreEqual(actual, String.Empty);
    }



  

    /// <summary>
    ///A test for MinRequiredPasswordLength
    ///</summary>
    [TestMethod()]
    public void MinRequiredPasswordLengthTest() {
      MembershipProvider target = Membership.Provider;  // TODO: Initialize to an appropriate value

      MembershipCreateStatus status;
      target.CreateUser("username", "", "mail", "question", "answer", true, null, out status);
      Assert.AreEqual(status, MembershipCreateStatus.InvalidPassword);
      target.CreateUser("username", "testusername", "mail", "question", "answer", true, null, out status);
      Assert.AreEqual(status, MembershipCreateStatus.Success);
      Assert.IsFalse(target.ChangePassword("username", "testusername", ""));
      Assert.IsTrue(target.ChangePassword("username", "testusername", "foofoofoo"));
    }

    /// <summary>
    ///A test for MinRequiredNonAlphanumericCharacters
    ///</summary>
    [TestMethod()]
    public void MinRequiredNonAlphanumericCharactersTest() {
      MembershipProvider target = Membership.Provider;  // TODO: Initialize to an appropriate value
      int actual;
      actual = target.MinRequiredNonAlphanumericCharacters;
      Assert.AreEqual(actual, 0);
    }

    /// <summary>
    ///A test for MaxInvalidPasswordAttempts
    ///</summary>
    [TestMethod()]
    public void MaxInvalidPasswordAttemptsTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      target.CreateUser("testUser", "MySuperPassword", "mail", "question", "answer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.Success, status);

      target.ValidateUser("testUser", "MySuperPassword");
      Assert.IsFalse(target.GetUser("testUser", true).IsLockedOut);

      for (int i = 0; i < target.MaxInvalidPasswordAttempts - 1; i++) {
        target.ValidateUser("testUser", "foo");
        Assert.IsFalse(target.GetUser("testUser", true).IsLockedOut);
      }

      target.ValidateUser("testUser", "MySuperPassword");
      Assert.IsFalse(target.GetUser("testUser", true).IsLockedOut);


      for (int i = 0; i < target.MaxInvalidPasswordAttempts; i++) {
        target.ValidateUser("testUser", "foo");
        Assert.IsFalse(target.GetUser("testUser", true).IsLockedOut);
      }
      
      target.ValidateUser("testUser", "foo");
      Assert.IsTrue(target.GetUser("testUser", true).IsLockedOut);

      target.ValidateUser("testUser", "MySuperPassword");
      Assert.IsTrue(target.GetUser("testUser", true).IsLockedOut);

    }

    /// <summary>
    ///A test for EnablePasswordRetrieval
    ///</summary>
    [TestMethod()]
    public void EnablePasswordRetrievalTest() {
      MembershipProvider target = Membership.Provider;
      bool actual;
      actual = target.EnablePasswordRetrieval;
      Assert.IsFalse(actual);
    }

    /// <summary>
    ///A test for EnablePasswordReset
    ///</summary>
    [TestMethod()]
    public void EnablePasswordResetTest() {
      MembershipProvider target = Membership.Provider;  // TODO: Initialize to an appropriate value
      bool actual;
      actual = target.EnablePasswordReset;
      Assert.IsFalse(actual);
    }

    /// <summary>
    ///A test for ValidateUser
    ///</summary>
    [TestMethod()]
    public void ValidateUserTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.IsTrue(target.ValidateUser("testname", "newPassword"));
    }

    /// <summary>
    ///A test for ValidateUser
    ///</summary>
    [TestMethod()]
    public void ValidateUserTestEncrypted() {
      MembershipProvider target = Membership.Provider;
      NameValueCollection config = new NameValueCollection();
      config.Add("passwordFormat", "Encrypted");
      MembershipCreateStatus status;
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.IsTrue(target.ValidateUser("testname", "newPassword"));
    }

    /// <summary>
    ///A test for ValidateUser
    ///</summary>
    [TestMethod()]
    public void ValidateUserTestHashed() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.IsTrue(target.ValidateUser("testname", "newPassword"));
    }

    /// <summary>
    ///A test for UpdateUser
    ///</summary>
    [TestMethod()]
    public void UpdateUserTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      MembershipUser user = null;
      target.CreateUser("testUser", "myPassword", "mail", "question", "answer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.Success, status);
      user =target.GetUser("testUser", true);
      Assert.IsNotNull(user);
      user.Email = "newMail";
      target.UpdateUser(user);
      user = target.GetUser("testUser", true);
      Assert.AreEqual(user.Email, "newMail");
    }

    /// <summary>
    ///A test for LockUser
    ///</summary>
    [TestMethod()]
    public void LockUserTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      Persistence.HeuristicLabMembershipUser user = (Persistence.HeuristicLabMembershipUser)target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      user.UnlockUser();
      HeuristicLabUser dbUser = db.HeuristicLabUsers.Single(u => u.UserName == "testname");
      Assert.IsFalse(dbUser.Locked);

    }



    /// <summary>
    ///A test for ResetPassword
    ///</summary>
    [TestMethod()]
    public void ResetPasswordTest() {
      MembershipProvider target = Membership.Provider; 
      string username = string.Empty; 
      string answer = string.Empty; 
      string expected = string.Empty;
      string actual;
      try {
        target.ResetPassword("foo", "foo");
      }
      catch (NotSupportedException) {
      //should be thrown
      }
      
    }

    /// <summary>
    ///A test for GetUserNameByEmail
    ///</summary>
    [TestMethod()]
    public void GetUserNameByEmailTest() {
      MembershipProvider target = Membership.Provider; // TODO: Initialize to an appropriate value
      string email = string.Empty; // TODO: Initialize to an appropriate value
      string expected = string.Empty; // TODO: Initialize to an appropriate value
      string actual;
      actual = target.GetUserNameByEmail(email);
      Assert.IsNull(actual);
      MembershipCreateStatus status;
      target.CreateUser("testuser", "mySecret", "testmail", "question", "answer", true, null, out status);
      Assert.AreEqual(status, MembershipCreateStatus.Success);
      Assert.AreEqual(target.GetUserNameByEmail("testmail"), "testuser");
    }


    /// <summary>
    ///A test for GetUser
    ///</summary>
    [TestMethod()]
    public void GetUserTest() {
      MembershipProvider target = Membership.Provider; // TODO: Initialize to an appropriate value
      MembershipCreateStatus status;
      target.CreateUser("testUser","myPersonalSecret", "root@nowhere.com","myQuestion", "myAnswer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.Success, status);
      MembershipUser user = target.GetUser("testUser", true);
      Assert.AreEqual(user.UserName, "testUser");
      Assert.AreEqual(user.Email, "root@nowhere.com");
      Assert.AreEqual(user.PasswordQuestion, "myQuestion");
      Assert.IsTrue(target.ValidateUser("testUser", "myPersonalSecret"));
      
    }

    /// <summary>
    ///A test for GetPassword
    ///</summary>
    [TestMethod()]
    public void GetPasswordTest() {
      MembershipProvider target = Membership.Provider; // TODO: Initialize to an appropriate value
      string username = string.Empty; // TODO: Initialize to an appropriate value
      string answer = string.Empty; // TODO: Initialize to an appropriate value
      string expected = string.Empty; // TODO: Initialize to an appropriate value
      string actual;
      try {
        actual = target.GetPassword(username, answer);
        Assert.Fail();
      }
      catch (NotSupportedException) {
        //swallow because expected
      }
     
    }

    /// <summary>
    ///A test for GetNumberOfUsersOnline
    ///</summary>
    [TestMethod()]
    public void GetNumberOfUsersOnlineTest() {
      MembershipProvider target = Membership.Provider; // TODO: Initialize to an appropriate value
      int expected = 0; // TODO: Initialize to an appropriate value
      int actual;
      actual = target.GetNumberOfUsersOnline();
      Assert.AreEqual(expected, actual);
    }

    /// <summary>
    ///A test for GetAllUsers
    ///
    /// work in progress
    ///</summary>
    [TestMethod()]
    public void GetAllUsersTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      MembershipUserCollection users;
      int totalRecords;
      int numberOfUsers = 13;
      int pageSize = 5;

      // make sure that we get an empty result if there are no users
      Assert.AreEqual(0, target.GetAllUsers(1, pageSize, out totalRecords).Count);

      // Create some users
      for (int i = 0; i < numberOfUsers; i++) {
        target.CreateUser("User " + i, "newPassword " + i, "testemail " + i, "testquestion " + i, "testanswer " + i, true, null, out status);
      }

      // basic proof as in http://msdn.microsoft.com/en-us/library/system.web.security.membershipprovider.getallusers.aspx
      users = target.GetAllUsers(1, pageSize, out totalRecords);
      HeuristicLabMembershipUser firstUser = null;
      HeuristicLabMembershipUser lastUser = null;
      foreach (HeuristicLabMembershipUser user in users) {
        if (firstUser == null) {
          firstUser = user;
        }
        lastUser = user;
      }
      Assert.AreEqual("User 5", firstUser.UserName);
      Assert.AreEqual("User 9", lastUser.UserName);

      // simulate paging and make sure that a valid empty collection is returned in the end
      int pageIndex = 0;
      while ((users = target.GetAllUsers(pageIndex, pageSize, out totalRecords)).Count != 0) {

        // check that totalRecords constantly equals the number of created users
        Assert.AreEqual(numberOfUsers, totalRecords);

        int j = pageIndex * pageSize;
        foreach (HeuristicLabMembershipUser user in users) {
          Assert.AreEqual("User " + j, user.UserName);
          j++;
        }
        pageIndex++;
      }

      // Make sure that we ended up at the last page
      Assert.AreEqual(3, pageIndex);

      // Make sure that we get an empty result if the page index is out of bounds
      Assert.AreEqual(0, target.GetAllUsers(42, pageSize, out totalRecords).Count);
    }

    /// <summary>
    ///A test for FindUsersByName
    ///</summary>
    [TestMethod()]
    public void FindUsersByNameTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      int totalRecords;
      int pageSize = 5;

      target.CreateUser("User 1", "newPassword ", "foo@bar.com", "testquestion ", "testanswer ", true, null, out status);
      target.CreateUser("User 2", "newPassword ", "foo@baz.com", "testquestion ", "testanswer ", true, null, out status);
      MembershipUserCollection users = target.FindUsersByName("User 2", 0, pageSize, out totalRecords);
      HeuristicLabMembershipUser firstUser = null;
      HeuristicLabMembershipUser lastUser = null;
      foreach (HeuristicLabMembershipUser user in users) {
        if (firstUser == null) {
          firstUser = user;
        }
        lastUser = user;
      }
      Assert.AreEqual("User 2", firstUser.UserName);
      Assert.AreEqual("User 2", lastUser.UserName);
      Assert.AreEqual(1, totalRecords);
    }

    /// <summary>
    ///A test for FindUsersByEmail
    ///</summary>
    [TestMethod()]
    public void FindUsersByEmailTest() {
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      int totalRecords;
      int pageSize = 5;

      target.CreateUser("User 1", "newPassword ", "foo@bar.com", "testquestion ", "testanswer ", true, null, out status);
      target.CreateUser("User 2", "newPassword ", "foo@baz.com", "testquestion ", "testanswer ", true, null, out status);
      MembershipUserCollection users = target.FindUsersByEmail("foo@bar.com", 0, pageSize, out totalRecords);
      HeuristicLabMembershipUser firstUser = null;
      HeuristicLabMembershipUser lastUser = null;
      foreach (HeuristicLabMembershipUser user in users) {
        if (firstUser == null) {
          firstUser = user;
        }
        lastUser = user;
      }
      Assert.AreEqual("User 1", firstUser.UserName);
      Assert.AreEqual("User 1", lastUser.UserName);
      Assert.AreEqual(1, totalRecords);
    }

    /// <summary>
    ///A test for DeleteUser
    ///</summary>
    [TestMethod()]
    public void DeleteUserTest() {
      // insert new user
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.Success, status);

      // delete user
      Assert.IsTrue(target.DeleteUser("testname", true));
      Assert.AreEqual(0, db.HeuristicLabUsers.Count(x => x.UserName == "testname"));
    }

    /// <summary>
    ///A test for CreateUser
    ///</summary>
    [TestMethod()]
    public void CreateUserTest() {
      // create user
      MembershipProvider target = Membership.Provider;
      MembershipCreateStatus status;
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.Success, status);

      // check if user is OK
      HeuristicLabUser u = db.HeuristicLabUsers.Single<HeuristicLabUser>(x => x.UserName == "testname");
      Assert.AreEqual<string>("testname", u.UserName);
      Assert.AreEqual<string>("testemail", u.Email);
      Assert.AreEqual<string>(((HeuristicLabMembershipProvider)target).EncodePassword("newPassword"), u.Password);
      Assert.AreEqual<string>("testquestion", u.PasswordQuestion);
      Assert.AreEqual<string>("testanswer", u.PasswordAnswer);
      Assert.AreEqual<string>("", u.Comment);

      // check for duplicate errors
      target.CreateUser("testname", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.DuplicateUserName, status);
      target.CreateUser("testname2", "newPassword", "testemail", "testquestion", "testanswer", true, null, out status);
      Assert.AreEqual(MembershipCreateStatus.DuplicateEmail, status);
    }

    /// <summary>
    ///A test for ChangePasswordQuestionAndAnswer
    ///</summary>
    [TestMethod()]
    public void ChangePasswordQuestionAndAnswerTest() {
      // create user
      HeuristicLabUser u = new HeuristicLabUser("testname", "testemail", "testquestion", "testcomment");
      db.HeuristicLabUsers.InsertOnSubmit(u);
      db.SubmitChanges();

      // check if user is stored
      u = db.HeuristicLabUsers.Single<HeuristicLabUser>(x => x.UserName == "testname");
      Assert.AreEqual<String>("testquestion", u.PasswordQuestion);
      Assert.AreEqual<String>("", u.PasswordAnswer);

      // change data and check again
      MembershipProvider target = Membership.Provider;
      // gibt zwar true zurück, was schon mal gut ist
      Assert.IsTrue(target.ChangePasswordQuestionAndAnswer("testname", "INIT", "newquestion", "newanswer"));
      db.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, u);
      u = db.HeuristicLabUsers.Single<HeuristicLabUser>(x => x.UserName == "testname");
      Assert.AreEqual<String>("newquestion", u.PasswordQuestion);
      Assert.AreEqual<String>("newanswer", u.PasswordAnswer);
    }

    /// <summary>
    ///A test for ChangePassword
    ///</summary>
    [TestMethod()]
    public void ChangePasswordTest() {
      MembershipProvider target = Membership.Provider;
      
      // create user
      HeuristicLabUser u = new HeuristicLabUser("testname", "testemail", "testquestion", "testcomment");
      u.Password = ((HeuristicLabMembershipProvider)target).EncodePassword("INIT");
      db.HeuristicLabUsers.InsertOnSubmit(u);
      db.SubmitChanges();

      // check if user is stored
      u = db.HeuristicLabUsers.Single<HeuristicLabUser>(x => x.UserName == "testname");
      Assert.AreEqual<String>(((HeuristicLabMembershipProvider)target).EncodePassword("INIT"), u.Password);

      // change data and check again
      Assert.IsTrue(target.ChangePassword("testname", "INIT", "newPassword"));
      db.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, u);
      u = db.HeuristicLabUsers.Single<HeuristicLabUser>(x => x.UserName == "testname");
      Assert.AreEqual<String>(((HeuristicLabMembershipProvider)target).EncodePassword("newPassword"), u.Password);
    }


    [TestMethod()]
    public void NoDuplicateUserNameTest() {
      try {
        Persistence.HeuristicLabUser user = new Persistence.HeuristicLabUser("duplicateName", "mail", "myQuestion", "myComment");
        db.HeuristicLabUsers.InsertOnSubmit(user);
        Persistence.HeuristicLabUser user2 = new Persistence.HeuristicLabUser("duplicateName", "mail2", "myQuestion2", "myComment2");
        db.HeuristicLabUsers.InsertOnSubmit(user2);
        db.SubmitChanges();
        Assert.Fail();
      }
      catch (SqlException) {
        //swallowing Exception because it is expected that a SQL Exception is thrown        
      }
    }
    [TestMethod()]
    public void NoDuplicateEmailTest() {
      try {
        Persistence.HeuristicLabUser user = new Persistence.HeuristicLabUser("duplicateName", "mail", "myQuestion", "myComment");
        db.HeuristicLabUsers.InsertOnSubmit(user);
        Persistence.HeuristicLabUser user2 = new Persistence.HeuristicLabUser("duplicateName2", "mail", "myQuestion2", "myComment2");
        db.HeuristicLabUsers.InsertOnSubmit(user2);
        db.SubmitChanges();
        Assert.Fail();
      }
      catch (SqlException) {
        //swallowing Exception because it is expected that a SQL Exception is thrown        
      }
    }
  }
}