From 27ae9095639bb228a1b7ff86a3ebe4264abf05be Mon Sep 17 00:00:00 2001
From: mschaefers <mschaefers@scoop-gmbh.de>
Date: Thu, 29 Nov 2012 12:33:09 -0500
Subject: [PATCH] feature: when using LdapUserService one can configure Gitblit to fetch all users from ldap that can possibly login. This allows to see newly generated LDAP users instantly in Gitblit. By now an LDAP user had to log in once to appear in GitBlit.
---
tests/com/gitblit/tests/RpcTests.java | 362 ++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 352 insertions(+), 10 deletions(-)
diff --git a/tests/com/gitblit/tests/RpcTests.java b/tests/com/gitblit/tests/RpcTests.java
index e140fb4..62d87bf 100644
--- a/tests/com/gitblit/tests/RpcTests.java
+++ b/tests/com/gitblit/tests/RpcTests.java
@@ -15,26 +15,368 @@
*/
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.atomic.AtomicBoolean;
-import junit.framework.TestCase;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import com.gitblit.Constants.AccessPermission;
+import com.gitblit.Constants.AccessRestrictionType;
+import com.gitblit.Constants.AuthorizationControl;
+import com.gitblit.Constants.PermissionType;
+import com.gitblit.Constants.RegistrantType;
+import com.gitblit.GitBlitException.UnauthorizedException;
+import com.gitblit.Keys;
+import com.gitblit.RpcServlet;
+import com.gitblit.models.RegistrantAccessPermission;
+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;
-public class RpcTests extends TestCase {
+/**
+ * Tests all the rpc client utility methods, the rpc filter and rpc servlet.
+ *
+ * @author James Moger
+ *
+ */
+public class RpcTests {
- public void testListRepositories() throws Exception {
- Map<String, RepositoryModel> map = null;
+ String url = GitBlitSuite.url;
+ String account = GitBlitSuite.account;
+ String password = GitBlitSuite.password;
+
+ private static final AtomicBoolean started = new AtomicBoolean(false);
+
+ @BeforeClass
+ public static void startGitblit() throws Exception {
+ started.set(GitBlitSuite.startGitblit());
+ }
+
+ @AfterClass
+ public static void stopGitblit() throws Exception {
+ if (started.get()) {
+ GitBlitSuite.stopGitblit();
+ }
+ }
+
+ @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);
+ assertNotNull("Repository list is null!", map);
+ assertTrue("Repository list is empty!", map.size() > 0);
+ }
+
+ @Test
+ public void testListUsers() throws IOException {
+ List<UserModel> list = null;
try {
- map = RpcUtils.getRepositories("https://localhost:8443");
- } catch (IOException e) {
- if (!e.getMessage().contains("403")) {
- throw e;
+ list = RpcUtils.getUsers(url, null, null);
+ } catch (UnauthorizedException e) {
+ }
+ 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
+ public void testUserAdministration() throws IOException {
+ UserModel user = new UserModel("garbage");
+ user.canAdmin = true;
+ user.password = "whocares";
+
+ // create
+ assertTrue("Failed to create user!",
+ RpcUtils.createUser(user, url, account, password.toCharArray()));
+
+ UserModel retrievedUser = findUser(user.username);
+ assertNotNull("Failed to find " + user.username, retrievedUser);
+ assertTrue("Retrieved user can not administer Gitblit", retrievedUser.canAdmin);
+
+ // rename and toggle admin permission
+ String originalName = user.username;
+ user.username = "garbage2";
+ user.canAdmin = false;
+ assertTrue("Failed to update user!",
+ RpcUtils.updateUser(originalName, user, url, account, password.toCharArray()));
+
+ retrievedUser = findUser(user.username);
+ assertNotNull("Failed to find " + user.username, retrievedUser);
+ assertTrue("Retrieved user did not update", !retrievedUser.canAdmin);
+
+ // delete
+ assertTrue("Failed to delete " + user.username,
+ RpcUtils.deleteUser(retrievedUser, url, account, password.toCharArray()));
+
+ retrievedUser = findUser(user.username);
+ assertNull("Failed to delete " + user.username, retrievedUser);
+ }
+
+ private UserModel findUser(String name) throws IOException {
+ List<UserModel> users = RpcUtils.getUsers(url, account, password.toCharArray());
+ UserModel retrievedUser = null;
+ for (UserModel model : users) {
+ if (model.username.equalsIgnoreCase(name)) {
+ retrievedUser = model;
+ break;
}
}
- assertTrue("Repository list is null!", map != null);
- assertTrue("Repository list is empty!", map.size() > 0);
+ return retrievedUser;
+ }
+
+ @Test
+ public void testRepositoryAdministration() throws IOException {
+ RepositoryModel model = new RepositoryModel();
+ model.name = "garbagerepo.git";
+ model.description = "created by RpcUtils";
+ model.owner = "garbage";
+ model.accessRestriction = AccessRestrictionType.VIEW;
+ model.authorizationControl = AuthorizationControl.AUTHENTICATED;
+
+ // create
+ assertTrue("Failed to create repository!",
+ RpcUtils.createRepository(model, url, account, password.toCharArray()));
+
+ RepositoryModel retrievedRepository = findRepository(model.name);
+ assertNotNull("Failed to find " + model.name, retrievedRepository);
+ assertEquals(AccessRestrictionType.VIEW, retrievedRepository.accessRestriction);
+ assertEquals(AuthorizationControl.AUTHENTICATED, retrievedRepository.authorizationControl);
+
+ // rename and change access restriciton
+ String originalName = model.name;
+ model.name = "garbagerepo2.git";
+ model.accessRestriction = AccessRestrictionType.PUSH;
+ model.authorizationControl = AuthorizationControl.NAMED;
+ assertTrue("Failed to update repository!", RpcUtils.updateRepository(originalName, model,
+ url, account, password.toCharArray()));
+
+ retrievedRepository = findRepository(model.name);
+ assertNotNull("Failed to find " + model.name, retrievedRepository);
+ assertTrue("Access retriction type is wrong",
+ AccessRestrictionType.PUSH.equals(retrievedRepository.accessRestriction));
+
+ // memberships
+ UserModel testMember = new UserModel("justadded");
+ assertTrue(RpcUtils.createUser(testMember, url, account, password.toCharArray()));
+
+ List<RegistrantAccessPermission> permissions = RpcUtils.getRepositoryMemberPermissions(retrievedRepository, url, account,
+ password.toCharArray());
+ assertEquals("Membership permissions is not empty!", 0, permissions.size());
+ permissions.add(new RegistrantAccessPermission(testMember.username, AccessPermission.PUSH, PermissionType.EXPLICIT, RegistrantType.USER, null, true));
+ assertTrue(
+ "Failed to set member permissions!",
+ RpcUtils.setRepositoryMemberPermissions(retrievedRepository, permissions, url, account,
+ password.toCharArray()));
+ permissions = RpcUtils.getRepositoryMemberPermissions(retrievedRepository, url, account,
+ password.toCharArray());
+ boolean foundMember = false;
+ for (RegistrantAccessPermission permission : permissions) {
+ if (permission.registrant.equalsIgnoreCase(testMember.username)) {
+ foundMember = true;
+ assertEquals(AccessPermission.PUSH, permission.permission);
+ break;
+ }
+ }
+ assertTrue("Failed to find member!", foundMember);
+
+ // delete
+ assertTrue("Failed to delete " + model.name, RpcUtils.deleteRepository(retrievedRepository,
+ url, account, password.toCharArray()));
+
+ retrievedRepository = findRepository(model.name);
+ assertNull("Failed to delete " + model.name, retrievedRepository);
+
+ for (UserModel u : RpcUtils.getUsers(url, account, password.toCharArray())) {
+ if (u.username.equals(testMember.username)) {
+ assertTrue(RpcUtils.deleteUser(u, url, account, password.toCharArray()));
+ break;
+ }
+ }
+ }
+
+ private RepositoryModel findRepository(String name) throws IOException {
+ Map<String, RepositoryModel> repositories = RpcUtils.getRepositories(url, account,
+ password.toCharArray());
+ RepositoryModel retrievedRepository = null;
+ for (RepositoryModel model : repositories.values()) {
+ if (model.name.equalsIgnoreCase(name)) {
+ retrievedRepository = model;
+ break;
+ }
+ }
+ 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.addRepositoryPermission("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.hasRepositoryPermission("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
+ List<RegistrantAccessPermission> permissions = new ArrayList<RegistrantAccessPermission>();
+ for (String team : helloworldTeams) {
+ permissions.add(new RegistrantAccessPermission(team, AccessPermission.NONE, PermissionType.EXPLICIT, RegistrantType.TEAM, null, true));
+ }
+ assertTrue(RpcUtils.setRepositoryTeamPermissions(helloworld, permissions, 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
+ public void testFederationRegistrations() throws Exception {
+ List<FederationModel> registrations = RpcUtils.getFederationRegistrations(url, account,
+ password.toCharArray());
+ assertTrue("No federation registrations were retrieved!", registrations.size() >= 0);
+ }
+
+ @Test
+ public void testFederationResultRegistrations() throws Exception {
+ List<FederationModel> registrations = RpcUtils.getFederationResultRegistrations(url,
+ account, password.toCharArray());
+ assertTrue("No federation result registrations were retrieved!", registrations.size() >= 0);
+ }
+
+ @Test
+ public void testFederationProposals() throws Exception {
+ List<FederationProposal> proposals = RpcUtils.getFederationProposals(url, account,
+ password.toCharArray());
+ assertTrue("No federation proposals were retrieved!", proposals.size() >= 0);
+ }
+
+ @Test
+ public void testFederationSets() throws Exception {
+ List<FederationSet> sets = RpcUtils.getFederationSets(url, account, password.toCharArray());
+ assertTrue("No federation sets were retrieved!", sets.size() >= 0);
+ }
+
+ @Test
+ public void testSettings() throws Exception {
+ ServerSettings settings = RpcUtils.getSettings(url, account, password.toCharArray());
+ assertNotNull("No settings were retrieved!", settings);
+ }
+
+ @Test
+ public void testServerStatus() throws Exception {
+ ServerStatus status = RpcUtils.getStatus(url, account, password.toCharArray());
+ assertNotNull("No status was retrieved!", status);
+ }
+
+ @Test
+ public void testUpdateSettings() throws Exception {
+ Map<String, String> updated = new HashMap<String, String>();
+
+ // grab current setting
+ ServerSettings settings = RpcUtils.getSettings(url, account, password.toCharArray());
+ boolean showSizes = settings.get(Keys.web.showRepositorySizes).getBoolean(true);
+ showSizes = !showSizes;
+
+ // update setting
+ updated.put(Keys.web.showRepositorySizes, String.valueOf(showSizes));
+ boolean success = RpcUtils.updateSettings(updated, url, account, password.toCharArray());
+ assertTrue("Failed to update server settings", success);
+
+ // confirm setting change
+ settings = RpcUtils.getSettings(url, account, password.toCharArray());
+ boolean newValue = settings.get(Keys.web.showRepositorySizes).getBoolean(false);
+ assertEquals(newValue, showSizes);
+
+ // 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());
+ assertNotNull(branches);
+ assertTrue(branches.size() > 0);
}
}
--
Gitblit v1.9.1