package com.atlassian.user.impl.osuser;
   
   import com.atlassian.user.EntityException;
   import com.atlassian.user.User;
   import com.atlassian.user.UserManager;
   import com.atlassian.user.generic.AbstractTestUserManager;
   import com.atlassian.user.generic.JdbcHelper;
   import com.atlassian.user.impl.DefaultUser;
   import com.atlassian.user.impl.osuser.properties.OSUPropertySetFactory;
  import com.atlassian.user.properties.PropertySetFactory;
  import com.atlassian.user.security.authentication.Authenticator;
  import com.atlassian.user.security.password.Credential;
  import com.opensymphony.module.propertyset.PropertySet;
  import org.springframework.dao.DataAccessException;
  import org.springframework.jdbc.core.PreparedStatementCallback;
  
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.Iterator;
  import java.util.List;
  
  public class TestOSUserUserManager extends AbstractTestUserManager
  {
      private OSUAccessor accessor;
      private OSUUserManager osuUserManager;
      private Authenticator osuAuthenticator;
  
      protected String[] getConfigLocations()
      {
          return new String[]{
              "classpath:com/atlassian/user/impl/osuser/osuserTestContext.xml",
              "classpath:com/atlassian/user/dataSourceTestContext.xml"
          };
      }
  
      protected UserManager getUserManager()
      {
          return osuUserManager;
      }
  
      public void setOsuUserManager(OSUUserManager osuUserManager)
      {
          this.osuUserManager = osuUserManager;
      }
  
      public void setAccessor(OSUAccessor accessor)
      {
          this.accessor = accessor;
      }
  
      public void setOsuAuthenticator(Authenticator osuAuthenticator)
      {
          this.osuAuthenticator = osuAuthenticator;
      }
  
      protected void onTearDown() throws Exception
      {
          // osuser is poo and doesnt seem to clean up properly
          deleteUsers();
          super.onTearDown();
          deleteUsers();
          // osuser does not clean up the property entry table correctly
          // See: http://jira.atlassian.com/browse/USER-192
          new JdbcHelper().deleteTable(jdbcTemplate, "OS_PROPERTYENTRY");
      }
  
      private void deleteUsers()
          throws EntityException
      {
          for (Iterator i = osuUserManager.getUsers().iterator(); i.hasNext();)
          {
              User user = (User) i.next();
              osuUserManager.removeUser(user);
          }
      }
  
      public void testGetPropertySet() throws Exception
      {
          PropertySetFactory propertySetFactory = new OSUPropertySetFactory(accessor.getProfileProvider());
          User user = getUserManager().createUser("zorro");
  
          PropertySet propertySet = propertySetFactory.getPropertySet(user);
          assertNotNull(propertySet);
  
          getUserManager().removeUser(user);
          assertNull(propertySetFactory.getPropertySet(user));
      }
  
      public void testGetUserReturnsOSUUser() throws EntityException
      {
          boolean created = accessor.getCredentialsProvider().create("zorro");
          assertTrue(created);
  
          User user = getUserManager().getUser("zorro");
          assertNotNull(user);
  
          User osuUser = new OSUUser(new com.opensymphony.user.User("zorro", accessor));
          assertEquals("The osuserUserManager is not returning users equivalent to the opensymphony osuser construct",
             user, osuUser);
     }
 
     public void testCreateUserCreatesOSUUser() throws EntityException
     {
         User userA = getUserManager().createUser("zorro");
         User userB = new OSUUser(new com.opensymphony.user.User("zorro", accessor));
         assertEquals("The osuserUserManager is not creating users equivalent to the opensymphony osuser construct",
             userA, userB);
     }
 
 
     public void testNullPasswords() throws Exception
     {
         String username = "zorro";
         User user = getUserManager().createUser(username);
         assertNotNull(user);
 
         assertNull(getOSUserPasswordFromJDBC(username));
 
         // zorro has a null password so these should both fail
         assertFalse(osuAuthenticator.authenticate("zorro", ""));
         try
         {
             osuAuthenticator.authenticate("zorro", null);
             fail("Should not be able to authenticate against a null password");
         }
         catch (NullPointerException e)
         {
             // good
         }
 
         User zorroUser = getUserManager().getUser("zorro");
         assertNotNull(zorroUser);
 
         getUserManager().alterPassword(zorroUser, "password ");
         assertFalse(osuAuthenticator.authenticate("zorro", "test"));
         assertTrue(osuAuthenticator.authenticate("zorro", "password"));
         assertTrue(osuAuthenticator.authenticate("zorro", "password "));
         getUserManager().alterPassword(zorroUser, "password");
         assertTrue(osuAuthenticator.authenticate("zorro", "password"));
         assertTrue(osuAuthenticator.authenticate("zorro", "password "));
         assertTrue(osuAuthenticator.authenticate("zorro", "   password  "));
         assertFalse(osuAuthenticator.authenticate("zorro", "test"));
 
         getUserManager().alterPassword(zorroUser, "");
         try
         {
             getUserManager().alterPassword(zorroUser, null);
             fail("Altering password to null should throw NullPointerException");
         }
         catch (NullPointerException e)
         {
             // good
         }
     }
 
     private String getOSUserPasswordFromJDBC(final String username) throws Exception
     {
         return (String) jdbcTemplate.execute("select passwd from os_user where username = ?", new PreparedStatementCallback()
         {
 
             public Object doInPreparedStatement(PreparedStatement preparedStatement) throws SQLException, DataAccessException
             {
                 preparedStatement.setString(1, username);
                 ResultSet rs = preparedStatement.executeQuery();
                 rs.next();
                 return rs.getString(1);
             }
         });
     }
 
     /**
      * Removing the OSUSer should remove its properties
      * See: http://jira.atlassian.com/browse/USER-192
      */
     public void testRemoveOSUserRemovesProperties() throws EntityException
     {
         osuUserManager.createUser(new DefaultUser("user1", "", ""), Credential.NONE);
 
         // check initial changes to the database
         JdbcHelper jdbcHelper = new JdbcHelper();
         List/*<String>*/ tables = jdbcHelper.getNonEmtpyTables(jdbcTemplate);
         int userCount = jdbcHelper.getTableCount(jdbcTemplate, "OS_USER");
         int propertyCount = jdbcHelper.getTableCount(jdbcTemplate, "OS_PROPERTYENTRY");
         assertEquals("creating user should create exactly one entry in OS_USER", 1, userCount);
         assertEquals("creating user should create exactly two entry in OS_PROPERTYENTRY", 2, propertyCount);
         assertEquals("creating user should add data to two tables", 2, tables.size());
         assertTrue("creating user should add data to OS_USER", tables.contains("OS_USER"));
         assertTrue("creating user should add data to OS_PROPERTYENTRY", tables.contains("OS_PROPERTYENTRY"));
 
         User retrievedUser = osuUserManager.getUser("user1");
         osuUserManager.removeUser(retrievedUser);
         assertNull("removing user should remove it from the user manager", osuUserManager.getUser("user1"));
         tables = jdbcHelper.getNonEmtpyTables(jdbcTemplate);
         userCount = jdbcHelper.getTableCount(jdbcTemplate, "OS_USER");
         propertyCount = jdbcHelper.getTableCount(jdbcTemplate, "OS_PROPERTYENTRY");
         assertEquals("removing user should remove entry in OS_USER", 0, userCount);
         assertEquals("removing user should remove entries in OS_PROPERTYENTRY", 0, propertyCount);
         assertEquals("removing user should remove all data from database", 0, tables.size());
     }
 
 }