Fixed bug in receive hook for repositories in subfolders

James Moger

2012-01-05 cb285cbfddfc0b633d6b8cdb4dc0d2bd2b8b51ef

 tests/com/gitblit/tests/RpcTests.java

@@ -16,14 +16,17 @@
package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;



import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicBoolean;



import org.junit.AfterClass;

import org.junit.BeforeClass;

@@ -31,14 +34,15 @@


import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.GitBlitException.UnauthorizedException;

import com.gitblit.GitBlitServer;

import com.gitblit.Keys;

import com.gitblit.RpcServlet;

import com.gitblit.models.FederationModel;

import com.gitblit.models.FederationProposal;

import com.gitblit.models.FederationSet;

import com.gitblit.models.RepositoryModel;

import com.gitblit.models.ServerSettings;

import com.gitblit.models.ServerStatus;

import com.gitblit.models.TeamModel;

import com.gitblit.models.UserModel;

import com.gitblit.utils.RpcUtils;



@@ -50,42 +54,34 @@
 */

public class RpcTests {



   static int port = 8180;

   static int shutdownPort = 8181;

   String url = GitBlitSuite.url;

   String account = GitBlitSuite.account;

   String password = GitBlitSuite.password;



   String url = "http://localhost:" + port;

   String account = "admin";

   String password = "admin";

   private static final AtomicBoolean started = new AtomicBoolean(false);



   @BeforeClass

   public static void startGitblit() throws Exception {

      // Start a Gitblit instance

      Executors.newSingleThreadExecutor().execute(new Runnable() {

         public void run() {

            GitBlitServer.main("--httpPort", "" + port, "--httpsPort", "0", "--shutdownPort",

                  "" + shutdownPort, "--repositoriesFolder",

                  "\"" + GitBlitSuite.REPOSITORIES.getAbsolutePath() + "\"", "--userService",

                  "distrib/users.properties");

         }

      });



      // Wait a few seconds for it to be running

      Thread.sleep(2500);

      started.set(GitBlitSuite.startGitblit());

   }



   @AfterClass

   public static void stopGitblit() throws Exception {

      // Stop Gitblit

      GitBlitServer.main("--stop", "--shutdownPort", "" + shutdownPort);

      if (started.get()) {

         GitBlitSuite.stopGitblit();

      }

   }



      // Wait a few seconds for it to be running

      Thread.sleep(2500);

   @Test

   public void testGetProtocolVersion() throws IOException {

      int protocol = RpcUtils.getProtocolVersion(url, null, null);

      assertEquals(RpcServlet.PROTOCOL_VERSION, protocol);

   }



   @Test

   public void testListRepositories() throws IOException {

      Map<String, RepositoryModel> map = RpcUtils.getRepositories(url, null, null);

      assertTrue("Repository list is null!", map != null);

      assertNotNull("Repository list is null!", map);

      assertTrue("Repository list is empty!", map.size() > 0);

   }



@@ -96,10 +92,24 @@
         list = RpcUtils.getUsers(url, null, null);

      } catch (UnauthorizedException e) {

      }

      assertTrue("Server allows anyone to admin!", list == null);

      assertNull("Server allows anyone to admin!", list);



      list = RpcUtils.getUsers(url, "admin", "admin".toCharArray());

      assertTrue("User list is empty!", list.size() > 0);

   }



   @Test

   public void testListTeams() throws IOException {

      List<TeamModel> list = null;

      try {

         list = RpcUtils.getTeams(url, null, null);

      } catch (UnauthorizedException e) {

      }

      assertNull("Server allows anyone to admin!", list);



      list = RpcUtils.getTeams(url, "admin", "admin".toCharArray());

      assertTrue("Team list is empty!", list.size() > 0);

      assertEquals("admins", list.get(0).name);

   }



   @Test

@@ -113,7 +123,7 @@
            RpcUtils.createUser(user, url, account, password.toCharArray()));



      UserModel retrievedUser = findUser(user.username);

      assertTrue("Failed to find " + user.username, retrievedUser != null);

      assertNotNull("Failed to find " + user.username, retrievedUser);

      assertTrue("Retrieved user can not administer Gitblit", retrievedUser.canAdmin);



      // rename and toggle admin permission

@@ -124,7 +134,7 @@
            RpcUtils.updateUser(originalName, user, url, account, password.toCharArray()));



      retrievedUser = findUser(user.username);

      assertTrue("Failed to find " + user.username, retrievedUser != null);

      assertNotNull("Failed to find " + user.username, retrievedUser);

      assertTrue("Retrieved user did not update", !retrievedUser.canAdmin);



      // delete

@@ -132,7 +142,7 @@
            RpcUtils.deleteUser(retrievedUser, url, account, password.toCharArray()));



      retrievedUser = findUser(user.username);

      assertTrue("Failed to delete " + user.username, retrievedUser == null);

      assertNull("Failed to delete " + user.username, retrievedUser);

   }



   private UserModel findUser(String name) throws IOException {

@@ -160,9 +170,8 @@
            RpcUtils.createRepository(model, url, account, password.toCharArray()));



      RepositoryModel retrievedRepository = findRepository(model.name);

      assertTrue("Failed to find " + model.name, retrievedRepository != null);

      assertTrue("Access retriction type is wrong",

            AccessRestrictionType.VIEW.equals(retrievedRepository.accessRestriction));

      assertNotNull("Failed to find " + model.name, retrievedRepository);

      assertEquals(AccessRestrictionType.VIEW, retrievedRepository.accessRestriction);



      // rename and change access restriciton

      String originalName = model.name;

@@ -172,16 +181,18 @@
            url, account, password.toCharArray()));



      retrievedRepository = findRepository(model.name);

      assertTrue("Failed to find " + model.name, retrievedRepository != null);

      assertNotNull("Failed to find " + model.name, retrievedRepository);

      assertTrue("Access retriction type is wrong",

            AccessRestrictionType.PUSH.equals(retrievedRepository.accessRestriction));



      // memberships

      String testMember = "justadded";

      UserModel testMember = new UserModel("justadded");

      assertTrue(RpcUtils.createUser(testMember, url, account, password.toCharArray()));



      List<String> members = RpcUtils.getRepositoryMembers(retrievedRepository, url, account,

            password.toCharArray());

      assertTrue("Membership roster is not empty!", members.size() == 0);

      members.add(testMember);

      assertEquals("Membership roster is not empty!", 0, members.size());

      members.add(testMember.username);

      assertTrue(

            "Failed to set memberships!",

            RpcUtils.setRepositoryMembers(retrievedRepository, members, url, account,

@@ -190,7 +201,7 @@
            password.toCharArray());

      boolean foundMember = false;

      for (String member : members) {

         if (member.equalsIgnoreCase(testMember)) {

         if (member.equalsIgnoreCase(testMember.username)) {

            foundMember = true;

            break;

         }

@@ -202,11 +213,11 @@
            url, account, password.toCharArray()));



      retrievedRepository = findRepository(model.name);

      assertTrue("Failed to delete " + model.name, retrievedRepository == null);

      assertNull("Failed to delete " + model.name, retrievedRepository);



      for (UserModel u : RpcUtils.getUsers(url, account, password.toCharArray())) {

         if (u.username.equals(testMember)) {

            RpcUtils.deleteUser(u, url, account, password.toCharArray());

         if (u.username.equals(testMember.username)) {

            assertTrue(RpcUtils.deleteUser(u, url, account, password.toCharArray()));

            break;

         }

      }

@@ -223,6 +234,61 @@
         }

      }

      return retrievedRepository;

   }



   @Test

   public void testTeamAdministration() throws IOException {

      List<TeamModel> teams = RpcUtils.getTeams(url, account, password.toCharArray());

      assertEquals(1, teams.size());

		
      // Create the A-Team

      TeamModel aTeam = new TeamModel("A-Team");

      aTeam.users.add("admin");

      aTeam.repositories.add("helloworld.git");

      assertTrue(RpcUtils.createTeam(aTeam, url, account, password.toCharArray()));



      aTeam = null;

      teams = RpcUtils.getTeams(url, account, password.toCharArray());

      assertEquals(2, teams.size());

      for (TeamModel team : teams) {

         if (team.name.equals("A-Team")) {

            aTeam = team;

            break;

         }

      }

      assertNotNull(aTeam);

      assertTrue(aTeam.hasUser("admin"));

      assertTrue(aTeam.hasRepository("helloworld.git"));



      RepositoryModel helloworld = null;

      Map<String, RepositoryModel> repositories = RpcUtils.getRepositories(url, account,

            password.toCharArray());

      for (RepositoryModel repository : repositories.values()) {

         if (repository.name.equals("helloworld.git")) {

            helloworld = repository;

            break;

         }

      }

      assertNotNull(helloworld);

		
      // Confirm that we have added the team

      List<String> helloworldTeams = RpcUtils.getRepositoryTeams(helloworld, url, account,

            password.toCharArray());

      assertEquals(1, helloworldTeams.size());

      assertTrue(helloworldTeams.contains(aTeam.name));



      // set no teams

      assertTrue(RpcUtils.setRepositoryTeams(helloworld, new ArrayList<String>(), url, account,

            password.toCharArray()));

      helloworldTeams = RpcUtils.getRepositoryTeams(helloworld, url, account,

            password.toCharArray());

      assertEquals(0, helloworldTeams.size());

		
      // delete the A-Team

      assertTrue(RpcUtils.deleteTeam(aTeam, url, account, password.toCharArray()));



      teams = RpcUtils.getTeams(url, account, password.toCharArray());

      assertEquals(1, teams.size());

   }



   @Test

@@ -255,13 +321,13 @@
   @Test

   public void testSettings() throws Exception {

      ServerSettings settings = RpcUtils.getSettings(url, account, password.toCharArray());

      assertTrue("No settings were retrieved!", settings != null);

      assertNotNull("No settings were retrieved!", settings);

   }



   @Test

   public void testServerStatus() throws Exception {

      ServerStatus status = RpcUtils.getStatus(url, account, password.toCharArray());

      assertTrue("No status was retrieved!", status != null);

      assertNotNull("No status was retrieved!", status);

   }



   @Test

@@ -286,13 +352,18 @@
      // restore setting

      newValue = !newValue;

      updated.put(Keys.web.showRepositorySizes, String.valueOf(newValue));

      success = RpcUtils.updateSettings(updated, url, account, password.toCharArray());

      assertTrue("Failed to update server settings", success);

      settings = RpcUtils.getSettings(url, account, password.toCharArray());

      showSizes = settings.get(Keys.web.showRepositorySizes).getBoolean(true);

      assertEquals(newValue, showSizes);

   }



   @Test

   public void testBranches() throws Exception {

      Map<String, Collection<String>> branches = RpcUtils.getBranches(url, account,

            password.toCharArray());

      assertTrue(branches != null);

      assertNotNull(branches);

      assertTrue(branches.size() > 0);

   }

}