src/test/java/com/gitblit/tests/RpcTests.java - gitblit - Git at Google

 /*
  * Copyright 2011 gitblit.com.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.gitblit.tests;

 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 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.ForbiddenException;
 import com.gitblit.GitBlitException.UnauthorizedException;
 import com.gitblit.Keys;
 import com.gitblit.models.FederationModel;
 import com.gitblit.models.FederationProposal;
 import com.gitblit.models.FederationSet;
 import com.gitblit.models.RegistrantAccessPermission;
 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.servlet.RpcServlet;
 import com.gitblit.utils.RpcUtils;

 /**
  * Tests all the rpc client utility methods, the rpc filter and rpc servlet.
  *
  * @author James Moger
  *
  */
 public class RpcTests extends GitblitUnitTest {

 	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 {
 			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 testGetUser() throws IOException {
 		UserModel user = null;
 		try {
 			user = RpcUtils.getUser("admin", url, null, null);
 		} catch (ForbiddenException e) {
 		}
 		assertNull("Server allows anyone to get user!", user);

 		user = RpcUtils.getUser("admin", url, "admin", "admin".toCharArray());
 		assertEquals("User is not the admin!", "admin", user.username);
 		assertTrue("User is not an administrator!", user.canAdmin());
 	}

 	@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;
 			}
 		}
 		return retrievedUser;
 	}

 	@Test
 	public void testRepositoryAdministration() throws IOException {
 		RepositoryModel model = new RepositoryModel();
 		model.name = "garbagerepo.git";
 		model.description = "created by RpcUtils";
 		model.accessRestriction = AccessRestrictionType.VIEW;
 		model.authorizationControl = AuthorizationControl.AUTHENTICATED;

 		// create
 		RpcUtils.deleteRepository(model, url, account, password.toCharArray());
 		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.CLONE;
 		model.authorizationControl = AuthorizationControl.NAMED;
 		RpcUtils.deleteRepository(model, url, account, password.toCharArray());
 		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.CLONE.equals(retrievedRepository.accessRestriction));

 		// restore VIEW restriction
 		retrievedRepository.accessRestriction = AccessRestrictionType.VIEW;
 		assertTrue("Failed to update repository!", RpcUtils.updateRepository(retrievedRepository.name, retrievedRepository,
 				url, account, password.toCharArray()));
 		retrievedRepository = findRepository(retrievedRepository.name);

 		// 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("Unexpected permissions! " + permissions.toString(), 1, permissions.size());
 		permissions.add(new RegistrantAccessPermission(testMember.username, AccessPermission.VIEW, 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.VIEW, 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);
 	}

 	@Test
 	public void testFork() throws Exception {
 		// test forking by an administrator
 		// admins are all-powerful and can fork the unforakable :)
 		testFork(account, password, true, true);
 		testFork(account, password, false, true);

 		// test forking by a permitted normal user
 		UserModel forkUser = new UserModel("forkuser");
 		forkUser.password = forkUser.username;
 		forkUser.canFork = true;
 		RpcUtils.deleteUser(forkUser, url, account, password.toCharArray());
 		RpcUtils.createUser(forkUser, url, account, password.toCharArray());
 		testFork(forkUser.username, forkUser.password, true, true);
 		testFork(forkUser.username, forkUser.password, false, false);
 		RpcUtils.deleteUser(forkUser, url, account, password.toCharArray());

 		// test forking by a non-permitted normal user
 		UserModel noForkUser = new UserModel("noforkuser");
 		noForkUser.password = noForkUser.username;
 		noForkUser.canFork = false;
 		RpcUtils.deleteUser(noForkUser, url, account, password.toCharArray());
 		RpcUtils.createUser(noForkUser, url, account, password.toCharArray());
 		testFork(forkUser.username, forkUser.password, true, false);
 		testFork(forkUser.username, forkUser.password, false, false);
 		RpcUtils.deleteUser(noForkUser, url, account, password.toCharArray());
 	}

 	private void testFork(String forkAcct, String forkAcctPassword, boolean allowForks, boolean expectSuccess) throws Exception {
 		// test does not exist
 		RepositoryModel dne = new RepositoryModel();
 		dne.name = "doesNotExist.git";
         assertFalse(String.format("Successfully forked %s!", dne.name),
                 RpcUtils.forkRepository(dne, url, forkAcct, forkAcctPassword.toCharArray()));

 		// delete any previous fork
 		RepositoryModel fork = findRepository(String.format("~%s/helloworld.git", forkAcct));
 		if (fork != null) {
 			RpcUtils.deleteRepository(fork, url, account, password.toCharArray());
 		}

 		// update the origin to allow forks or not
 		RepositoryModel origin = findRepository("helloworld.git");
 		origin.allowForks = allowForks;
 		RpcUtils.updateRepository(origin.name, origin, url, account, password.toCharArray());

 		// fork the repository
 		if (expectSuccess) {
 			assertTrue(String.format("Failed to fork %s!", origin.name),
                 RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));
 		} else {
 			assertFalse(String.format("Successfully forked %s!", origin.name),
 	                RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));
 		}

         // attempt another fork
         assertFalse(String.format("Successfully forked %s!", origin.name),
                 RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));

         // delete the fork repository
         RpcUtils.deleteRepository(fork, url, account, password.toCharArray());
 	}
 }
	/*
	* Copyright 2011 gitblit.com.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.gitblit.tests;

	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 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.ForbiddenException;
	import com.gitblit.GitBlitException.UnauthorizedException;
	import com.gitblit.Keys;
	import com.gitblit.models.FederationModel;
	import com.gitblit.models.FederationProposal;
	import com.gitblit.models.FederationSet;
	import com.gitblit.models.RegistrantAccessPermission;
	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.servlet.RpcServlet;
	import com.gitblit.utils.RpcUtils;

	/**
	* Tests all the rpc client utility methods, the rpc filter and rpc servlet.
	*
	* @author James Moger
	*
	*/
	public class RpcTests extends GitblitUnitTest {

	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 {
	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 testGetUser() throws IOException {
	UserModel user = null;
	try {
	user = RpcUtils.getUser("admin", url, null, null);
	} catch (ForbiddenException e) {
	}
	assertNull("Server allows anyone to get user!", user);

	user = RpcUtils.getUser("admin", url, "admin", "admin".toCharArray());
	assertEquals("User is not the admin!", "admin", user.username);
	assertTrue("User is not an administrator!", user.canAdmin());
	}

	@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;
	}
	}
	return retrievedUser;
	}

	@Test
	public void testRepositoryAdministration() throws IOException {
	RepositoryModel model = new RepositoryModel();
	model.name = "garbagerepo.git";
	model.description = "created by RpcUtils";
	model.accessRestriction = AccessRestrictionType.VIEW;
	model.authorizationControl = AuthorizationControl.AUTHENTICATED;

	// create
	RpcUtils.deleteRepository(model, url, account, password.toCharArray());
	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.CLONE;
	model.authorizationControl = AuthorizationControl.NAMED;
	RpcUtils.deleteRepository(model, url, account, password.toCharArray());
	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.CLONE.equals(retrievedRepository.accessRestriction));

	// restore VIEW restriction
	retrievedRepository.accessRestriction = AccessRestrictionType.VIEW;
	assertTrue("Failed to update repository!", RpcUtils.updateRepository(retrievedRepository.name, retrievedRepository,
	url, account, password.toCharArray()));
	retrievedRepository = findRepository(retrievedRepository.name);

	// 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("Unexpected permissions! " + permissions.toString(), 1, permissions.size());
	permissions.add(new RegistrantAccessPermission(testMember.username, AccessPermission.VIEW, 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.VIEW, 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);
	}

	@Test
	public void testFork() throws Exception {
	// test forking by an administrator
	// admins are all-powerful and can fork the unforakable :)
	testFork(account, password, true, true);
	testFork(account, password, false, true);

	// test forking by a permitted normal user
	UserModel forkUser = new UserModel("forkuser");
	forkUser.password = forkUser.username;
	forkUser.canFork = true;
	RpcUtils.deleteUser(forkUser, url, account, password.toCharArray());
	RpcUtils.createUser(forkUser, url, account, password.toCharArray());
	testFork(forkUser.username, forkUser.password, true, true);
	testFork(forkUser.username, forkUser.password, false, false);
	RpcUtils.deleteUser(forkUser, url, account, password.toCharArray());

	// test forking by a non-permitted normal user
	UserModel noForkUser = new UserModel("noforkuser");
	noForkUser.password = noForkUser.username;
	noForkUser.canFork = false;
	RpcUtils.deleteUser(noForkUser, url, account, password.toCharArray());
	RpcUtils.createUser(noForkUser, url, account, password.toCharArray());
	testFork(forkUser.username, forkUser.password, true, false);
	testFork(forkUser.username, forkUser.password, false, false);
	RpcUtils.deleteUser(noForkUser, url, account, password.toCharArray());
	}

	private void testFork(String forkAcct, String forkAcctPassword, boolean allowForks, boolean expectSuccess) throws Exception {
	// test does not exist
	RepositoryModel dne = new RepositoryModel();
	dne.name = "doesNotExist.git";
	assertFalse(String.format("Successfully forked %s!", dne.name),
	RpcUtils.forkRepository(dne, url, forkAcct, forkAcctPassword.toCharArray()));

	// delete any previous fork
	RepositoryModel fork = findRepository(String.format("~%s/helloworld.git", forkAcct));
	if (fork != null) {
	RpcUtils.deleteRepository(fork, url, account, password.toCharArray());
	}

	// update the origin to allow forks or not
	RepositoryModel origin = findRepository("helloworld.git");
	origin.allowForks = allowForks;
	RpcUtils.updateRepository(origin.name, origin, url, account, password.toCharArray());

	// fork the repository
	if (expectSuccess) {
	assertTrue(String.format("Failed to fork %s!", origin.name),
	RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));
	} else {
	assertFalse(String.format("Successfully forked %s!", origin.name),
	RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));
	}

	// attempt another fork
	assertFalse(String.format("Successfully forked %s!", origin.name),
	RpcUtils.forkRepository(origin, url, forkAcct, forkAcctPassword.toCharArray()));

	// delete the fork repository
	RpcUtils.deleteRepository(fork, url, account, password.toCharArray());
	}
	}