/* | |
* 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.addOwner("garbage"); | |
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()); | |
} | |
} |