GitConfigTest.java

/*******************************************************************************
 * Copyright (c) 2011, 2014 IBM Corporation and others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.orion.server.tests.servlets.git;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URI;
import java.util.ArrayList;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.orion.internal.server.core.metastore.SimpleMetaStore;
import org.eclipse.orion.server.core.IOUtilities;
import org.eclipse.orion.server.core.ProtocolConstants;
import org.eclipse.orion.server.git.GitConstants;
import org.eclipse.orion.server.git.objects.Clone;
import org.eclipse.orion.server.git.objects.ConfigOption;
import org.eclipse.orion.server.tests.ReflectionUtils;
import org.eclipse.orion.server.tests.servlets.internal.DeleteMethodWebRequest;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.Test;
import org.xml.sax.SAXException;

import com.meterware.httpunit.GetMethodWebRequest;
import com.meterware.httpunit.PostMethodWebRequest;
import com.meterware.httpunit.PutMethodWebRequest;
import com.meterware.httpunit.WebRequest;
import com.meterware.httpunit.WebResponse;

public class GitConfigTest extends GitTest {
	/*
	private static final String GIT_NAME = "test";
	private static final String GIT_MAIL = "test mail";
	private static final String GIT_COMMIT_MESSAGE = "message";

	@Test
	public void testClonedRepoConfigUsingUserProfile() throws Exception {
		// set Git name and mail in the user profile
		WebRequest request = getPutUserRequest();
		WebResponse response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// clone a  repo
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		String workspaceId = workspaceIdFromLocation(workspaceLocation);
		JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
		IPath clonePath = getClonePath(workspaceId, project);

		String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

		// check the repository configuration using JGit API
		Git git = new Git(getRepositoryForContentLocation(contentLocation));
		StoredConfig config = git.getRepository().getConfig();
		assertEquals(GIT_NAME, config.getString(ConfigConstants.CONFIG_USER_SECTION, null, ConfigConstants.CONFIG_KEY_NAME));
		assertEquals(GIT_MAIL, config.getString(ConfigConstants.CONFIG_USER_SECTION, null, ConfigConstants.CONFIG_KEY_EMAIL));

		// now check if commits have the right committer set

		request = getGetRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
		project = new JSONObject(response.getText());
		String childrenLocation = project.getString(ProtocolConstants.KEY_CHILDREN_LOCATION);
		assertNotNull(childrenLocation);

		// check if Git locations are in place
		JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
		String gitIndexUri = gitSection.getString(GitConstants.KEY_INDEX);
		String gitHeadUri = gitSection.getString(GitConstants.KEY_HEAD);

		// modify
		String projectLocation = project.getString(ProtocolConstants.KEY_LOCATION);
		request = getPutFileRequest(projectLocation + "/test.txt", "change to commit");
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// add
		request = GitAddTest.getPutGitIndexRequest(gitIndexUri + "test.txt");
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// commit all
		request = GitCommitTest.getPostGitCommitRequest(gitHeadUri, GIT_COMMIT_MESSAGE, false);
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// log
		JSONArray commitsArray = log(gitHeadUri);
		assertEquals(2, commitsArray.length());
		for (int i = 0; i < commitsArray.length(); i++) {
			if (commitsArray.getJSONObject(i).getString(GitConstants.KEY_COMMIT_MESSAGE).equals(GIT_COMMIT_MESSAGE)) {
				assertEquals(GIT_NAME, commitsArray.getJSONObject(i).getString(GitConstants.KEY_AUTHOR_NAME));
				assertEquals(GIT_MAIL, commitsArray.getJSONObject(i).getString(GitConstants.KEY_AUTHOR_EMAIL));
			}
		}
	}

	@Test
	public void testInitializedRepoConfigUsingUserProfile() throws Exception {
		// set Git name and mail in the user profile
		WebRequest request = getPutUserRequest();
		WebResponse response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// init a repo
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		String workspaceId = workspaceIdFromLocation(workspaceLocation);
		JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
		IPath initPath = getClonePath(workspaceId, project);

		String contentLocation = init(null, initPath, null).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

		// check the repository configuration using JGit API
		Git git = new Git(getRepositoryForContentLocation(contentLocation));
		StoredConfig config = git.getRepository().getConfig();
		assertEquals(GIT_NAME, config.getString(ConfigConstants.CONFIG_USER_SECTION, null, ConfigConstants.CONFIG_KEY_NAME));
		assertEquals(GIT_MAIL, config.getString(ConfigConstants.CONFIG_USER_SECTION, null, ConfigConstants.CONFIG_KEY_EMAIL));

		// now check if commits have the right committer set

		request = getGetRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
		project = new JSONObject(response.getText());
		String childrenLocation = project.getString(ProtocolConstants.KEY_CHILDREN_LOCATION);
		assertNotNull(childrenLocation);

		// check if Git locations are in place
		JSONObject gitSection = project.optJSONObject(GitConstants.KEY_GIT);
		assertNotNull(gitSection);
		String gitIndexUri = gitSection.getString(GitConstants.KEY_INDEX);
		String gitHeadUri = gitSection.getString(GitConstants.KEY_HEAD);

		// modify
		String projectLocation = project.getString(ProtocolConstants.KEY_LOCATION);
		request = getPutFileRequest(projectLocation + "/test.txt", "change to commit");
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// add
		request = GitAddTest.getPutGitIndexRequest(gitIndexUri + "test.txt");
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// commit all
		request = GitCommitTest.getPostGitCommitRequest(gitHeadUri, GIT_COMMIT_MESSAGE, false);
		response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

		// log
		JSONArray commitsArray = log(gitHeadUri);
		assertEquals(2, commitsArray.length());
		for (int i = 0; i < commitsArray.length(); i++) {
			if (commitsArray.getJSONObject(i).getString(GitConstants.KEY_COMMIT_MESSAGE).equals(GIT_COMMIT_MESSAGE)) {
				assertEquals(GIT_NAME, commitsArray.getJSONObject(i).getString(GitConstants.KEY_AUTHOR_NAME));
				assertEquals(GIT_MAIL, commitsArray.getJSONObject(i).getString(GitConstants.KEY_AUTHOR_EMAIL));
			}
		}
	}
	*/
	@Test
	public void testGetListOfConfigEntries() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			JSONObject configResponse = listConfigEntries(gitConfigUri);
			JSONArray configEntries = configResponse.getJSONArray(ProtocolConstants.KEY_CHILDREN);

			for (int i = 0; i < configEntries.length(); i++) {
				JSONObject configEntry = configEntries.getJSONObject(i);
				assertNotNull(configEntry.optString(GitConstants.KEY_CONFIG_ENTRY_KEY, null));
				assertNotNull(configEntry.optString(GitConstants.KEY_CONFIG_ENTRY_VALUE, null));
				assertConfigUri(configEntry.getString(ProtocolConstants.KEY_LOCATION));
				assertCloneUri(configEntry.getString(GitConstants.KEY_CLONE));
				assertEquals(ConfigOption.TYPE, configEntry.getString(ProtocolConstants.KEY_TYPE));
			}
		}
	}

	@Test
	public void testAddConfigEntry() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			JSONObject configResponse = listConfigEntries(gitConfigUri);
			JSONArray configEntries = configResponse.getJSONArray(ProtocolConstants.KEY_CHILDREN);
			// initial number of config entries
			int initialConfigEntriesCount = configEntries.length();

			// set some dummy value
			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
			configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);
			assertConfigUri(entryLocation);

			// get list of config entries again
			configResponse = listConfigEntries(gitConfigUri);
			configEntries = configResponse.getJSONArray(ProtocolConstants.KEY_CHILDREN);
			assertEquals(initialConfigEntriesCount + 1, configEntries.length());

			entryLocation = null;
			for (int i = 0; i < configEntries.length(); i++) {
				JSONObject configEntry = configEntries.getJSONObject(i);
				if (ENTRY_KEY.equals(configEntry.getString(GitConstants.KEY_CONFIG_ENTRY_KEY))) {
					assertMultiConfigOption(configEntry, ENTRY_KEY, new String[] {ENTRY_VALUE});
					break;
				}
			}

			// double check
			org.eclipse.jgit.lib.Config config = getRepositoryForContentLocation(contentLocation).getConfig();
			assertEquals(ENTRY_VALUE, config.getString("a", "b", "c"));
		}
	}

	@Test
	public void testGetSingleConfigEntry() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			// set some dummy value
			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
			JSONObject configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);

			JSONObject configEntry = listConfigEntries(entryLocation);
			assertMultiConfigOption(configEntry, ENTRY_KEY, new String[] {ENTRY_VALUE});
		}
	}

	@Test
	public void testUpdateConfigEntryUsingPOST() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			// set some dummy value
			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());

			JSONObject configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);

			// update config entry using POST
			final String NEW_ENTRY_VALUE = "valueABC";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, NEW_ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());

			// get value of config entry
			JSONObject configEntry = listConfigEntries(entryLocation);
			// assert unchanged
			assertMultiConfigOption(configEntry, ENTRY_KEY, new String[] {ENTRY_VALUE, NEW_ENTRY_VALUE});
		}
	}

	@Test
	public void testUpdateConfigEntryUsingPUT() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			// set some dummy value
			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());

			JSONObject configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);

			// update config entry using PUT
			final String NEW_ENTRY_VALUE = "v2";

			request = getPutGitConfigRequest(entryLocation, NEW_ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

			JSONObject configEntry = listConfigEntries(entryLocation);
			assertMultiConfigOption(configEntry, ENTRY_KEY, new String[] {NEW_ENTRY_VALUE});
		}
	}

	@Test
	public void testDeleteConfigEntry() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			// set some dummy value
			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());

			JSONObject configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);

			// check if it exists
			request = getGetGitConfigRequest(entryLocation);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

			// delete config entry
			request = getDeleteGitConfigRequest(entryLocation);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

			// it shouldn't exist
			request = getGetGitConfigRequest(entryLocation);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

			// so next delete operation should fail
			request = getDeleteGitConfigRequest(entryLocation);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());
		}
	}

	@Test
	public void testCreateInvalidConfigEntry() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			final String INVALID_ENTRY_KEY = "a"; // no name specified, dot missing
			final String ENTRY_VALUE = "v";

			// try to set entry with invalid key
			request = getPostGitConfigRequest(gitConfigUri, INVALID_ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());
		}
	}

	@Test
	public void testUpdateNonExistingConfigEntryUsingPUT() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			String invalidEntryLocation = gitConfigUri.replace(ConfigOption.RESOURCE, ConfigOption.RESOURCE + "/" + ENTRY_KEY);

			// check if it doesn't exist
			request = getGetGitConfigRequest(invalidEntryLocation);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

			// try to update non-existing config entry using PUT (not allowed)
			request = getPutGitConfigRequest(invalidEntryLocation, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());
		}
	}

	@Test
	public void testRequestWithMissingArguments() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		IPath[] clonePaths = createTestProjects(workspaceLocation);

		for (IPath clonePath : clonePaths) {
			// clone a  repo
			String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

			// get project metadata
			WebRequest request = getGetRequest(contentLocation);
			WebResponse response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
			JSONObject project = new JSONObject(response.getText());
			JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
			String gitConfigUri = gitSection.getString(GitConstants.KEY_CONFIG);

			final String ENTRY_KEY = "a.b.c";
			final String ENTRY_VALUE = "v";

			// missing key
			request = getPostGitConfigRequest(gitConfigUri, null, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());

			// missing value
			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, null);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());

			// missing key and value
			request = getPostGitConfigRequest(gitConfigUri, null, null);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());

			// add some config
			request = getPostGitConfigRequest(gitConfigUri, ENTRY_KEY, ENTRY_VALUE);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
			JSONObject configResponse = new JSONObject(response.getText());
			String entryLocation = configResponse.getString(ProtocolConstants.KEY_LOCATION);

			// put without value
			request = getPutGitConfigRequest(entryLocation, null);
			response = webConversation.getResponse(request);
			assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());
		}
	}

	@Test
	public void testGetConfigEntryForNonExistingRepository() throws Exception {
		createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
		String workspaceId = getWorkspaceId(workspaceLocation);

		JSONArray clonesArray = listClones(workspaceId, null);

		String dummyId = "dummyId";
		GitCloneTest.ensureCloneIdDoesntExist(clonesArray, dummyId);
		String entryLocation = SERVER_LOCATION + GIT_SERVLET_LOCATION + ConfigOption.RESOURCE + "/dummyKey/" + Clone.RESOURCE + "/file/" + dummyId;

		// get value of config entry
		WebRequest request = getGetGitConfigRequest(entryLocation);
		WebResponse response = webConversation.getResponse(request);
		assertEquals(response.getResponseMessage(), HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());
	}

	@Test
	public void testKeyToSegmentsMethod() throws Exception {
		Object configOption = ReflectionUtils.callConstructor(ConfigOption.class, new Object[] {new URI(""), FileRepositoryBuilder.create(new File(""))});

		String[] segments = (String[]) ReflectionUtils.callMethod(configOption, "keyToSegments", new Object[] {"a.b.c"});
		assertArrayEquals(new String[] {"a", "b", "c"}, segments);

		segments = (String[]) ReflectionUtils.callMethod(configOption, "keyToSegments", new Object[] {"a.c"});
		assertArrayEquals(new String[] {"a", null, "c"}, segments);

		segments = (String[]) ReflectionUtils.callMethod(configOption, "keyToSegments", new Object[] {"a.b.c.d"});
		assertArrayEquals(new String[] {"a", "b.c", "d"}, segments);

		segments = (String[]) ReflectionUtils.callMethod(configOption, "keyToSegments", new Object[] {"a"});
		assertArrayEquals(null, segments);
	}

	@Test
	public void testSegmentsToKeyMethod() throws Exception {
		Object configOption = ReflectionUtils.callConstructor(ConfigOption.class, new Object[] {new URI(""), FileRepositoryBuilder.create(new File(""))});

		String key = (String) ReflectionUtils.callMethod(configOption, "segmentsToKey", new Object[] {new String[] {"a", "b", "c"}});
		assertEquals("a.b.c", key);

		key = (String) ReflectionUtils.callMethod(configOption, "segmentsToKey", new Object[] {new String[] {"a", null, "c"}});
		assertEquals("a.c", key);

		key = (String) ReflectionUtils.callMethod(configOption, "segmentsToKey", new Object[] {new String[] {"a", "b.c", "d"}});
		assertEquals("a.b.c.d", key);

		key = (String) ReflectionUtils.callMethod(configOption, "segmentsToKey", new Object[] {new String[] {"a", "b"}});
		assertEquals(null, key);

		key = (String) ReflectionUtils.callMethod(configOption, "segmentsToKey", new Object[] {new String[] {"a", "b", "c", "d"}});
		assertEquals(null, key);
	}

	static WebRequest getDeleteGitConfigRequest(String location) {
		String requestURI = toAbsoluteURI(location);
		WebRequest request = new DeleteMethodWebRequest(requestURI);
		request.setHeaderField(ProtocolConstants.HEADER_ORION_VERSION, "1");
		setAuthentication(request);
		return request;
	}

	static WebRequest getPutGitConfigRequest(String location, String value) throws JSONException, UnsupportedEncodingException {
		String requestURI = toAbsoluteURI(location);
		JSONObject body = new JSONObject();
		JSONArray array = new JSONArray();
		array.put(value);
		body.put(GitConstants.KEY_CONFIG_ENTRY_VALUE, array);
		WebRequest request = new PutMethodWebRequest(requestURI, IOUtilities.toInputStream(body.toString()), "UTF-8");
		request.setHeaderField(ProtocolConstants.HEADER_ORION_VERSION, "1");
		setAuthentication(request);
		return request;
	}

	static WebRequest getPostGitConfigRequest(String location, String key, String value) throws JSONException, UnsupportedEncodingException {
		String requestURI = toAbsoluteURI(location);
		JSONObject body = new JSONObject();
		body.put(GitConstants.KEY_CONFIG_ENTRY_KEY, key);
		body.put(GitConstants.KEY_CONFIG_ENTRY_VALUE, value);
		WebRequest request = new PostMethodWebRequest(requestURI, IOUtilities.toInputStream(body.toString()), "UTF-8");
		request.setHeaderField(ProtocolConstants.HEADER_ORION_VERSION, "1");
		setAuthentication(request);
		return request;
	}

	private JSONObject listConfigEntries(final String gitConfigUri) throws IOException, SAXException, JSONException {
		WebRequest request = getGetGitConfigRequest(gitConfigUri);
		WebResponse response = webConversation.getResponse(request);
		assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
		JSONObject configResponse = new JSONObject(response.getText());
		assertEquals(ConfigOption.TYPE, configResponse.getString(ProtocolConstants.KEY_TYPE));
		return configResponse;
	}

	static WebRequest getGetGitConfigRequest(String location) {
		String requestURI = toAbsoluteURI(location);
		WebRequest request = new GetMethodWebRequest(requestURI);
		request.setHeaderField(ProtocolConstants.HEADER_ORION_VERSION, "1");
		setAuthentication(request);
		return request;
	}

	private void assertMultiConfigOption(final JSONObject cfg, final String k, final String[] v) throws JSONException, CoreException, IOException {
		assertEquals(k, cfg.getString(GitConstants.KEY_CONFIG_ENTRY_KEY));

		ArrayList<String> list = new ArrayList<String>();
		JSONArray jsonArray = cfg.getJSONArray(GitConstants.KEY_CONFIG_ENTRY_VALUE);
		if (jsonArray != null) {
			for (int i = 0; i < jsonArray.length(); i++) {
				list.add(jsonArray.get(i).toString());
			}
		}
		String[] compare = new String[list.size()];
		compare = list.toArray(compare);
		assertArrayEquals(v, compare);
		assertConfigUri(cfg.getString(ProtocolConstants.KEY_LOCATION));
		assertCloneUri(cfg.getString(GitConstants.KEY_CLONE));
	}
}