// modified + checkout = clean
  @Test
  @Ignore("not supported yet")
  public void testCheckoutDotPath() throws Exception {
    // clone a repo
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    clone(clonePath);

    // get project metadata
    WebRequest request =
        getGetFilesRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project = new JSONObject(response.getText());

    JSONObject testTxt = getChild(project, "test.txt");
    modifyFile(testTxt, "change");

    JSONObject folder1 = getChild(project, "folder");
    JSONObject folderTxt = getChild(folder1, "folder.txt");
    modifyFile(folderTxt, "change");

    JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
    String gitStatusUri = gitSection.getString(GitConstants.KEY_STATUS);
    String gitCloneUri = GitStatusTest.getCloneUri(gitStatusUri);

    request = getCheckoutRequest(gitCloneUri, new String[] {"."});
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    assertStatus(StatusResult.CLEAN, gitStatusUri);
  }
  /**
   * Uses HttpUnit functionality to retrieve a single sds offering (including curnit and jnlp) from
   * the sds.
   *
   * @param sdsOfferingId The id of the offering you want to retrieve
   * @return The SdsOffering with all parameters set.
   * @throws IOException
   * @throws JDOMException
   * @throws SAXException
   */
  protected SdsOffering getOfferingAlternativeMethod(Serializable sdsOfferingId)
      throws IOException, JDOMException, SAXException {
    WebResponse webResponse = this.makeHttpRestGetRequest("/offering/" + sdsOfferingId);
    assertEquals(HttpStatus.SC_OK, webResponse.getResponseCode());

    Document doc = createDocumentFromResponse(webResponse);
    SdsOffering sdsOffering = (SdsOffering) this.applicationContext.getBean("sdsOffering");
    Element offeringElement = doc.getRootElement();
    sdsOffering.setName(offeringElement.getChild("name").getValue());
    sdsOffering.setSdsObjectId(new Long(offeringElement.getChild("id").getValue()));

    Long sdsCurnitId = new Long(offeringElement.getChild("curnit-id").getValue());
    SdsCurnit sdsCurnit = this.getCurnitInSds(sdsCurnitId);
    sdsOffering.setSdsCurnit(sdsCurnit);

    Long sdsJnlpId = new Long(offeringElement.getChild("jnlp-id").getValue());
    SdsJnlp sdsJnlp = this.getJnlpInSds(sdsJnlpId);
    sdsOffering.setSdsJnlp(sdsJnlp);

    WebResponse curnitMapWebResponse =
        this.makeHttpRestGetRequest("/offering/" + sdsOfferingId + "/curnitmap");
    assertEquals(HttpStatus.SC_OK, curnitMapWebResponse.getResponseCode());

    Document curnitMapDoc = createDocumentFromResponse(curnitMapWebResponse);
    sdsOffering.setSdsCurnitMap(curnitMapDoc.getRootElement().getText());

    return sdsOffering;
  }
  // modified + checkout = clean
  @Test
  public void testCheckoutInFolder() throws Exception {
    // clone a repo
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    clone(clonePath);

    // get project metadata
    WebRequest request =
        getGetFilesRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project = new JSONObject(response.getText());

    JSONObject testTxt = getChild(project, "test.txt");
    modifyFile(testTxt, "change");

    JSONObject folder1 = getChild(project, "folder");
    JSONObject folderTxt = getChild(folder1, "folder.txt");
    modifyFile(folderTxt, "change");

    JSONObject gitSection = folder1.getJSONObject(GitConstants.KEY_GIT);
    String gitStatusUri = gitSection.getString(GitConstants.KEY_STATUS);
    // we should get a proper clone URI here: /git/clone/file/{projectId}/
    String gitCloneUri = GitStatusTest.getCloneUri(gitStatusUri);

    request = getCheckoutRequest(gitCloneUri, new String[] {"folder/folder.txt"});
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // 'test.txt' is still modified
    assertStatus(new StatusResult().setModifiedNames("test.txt"), gitStatusUri);
  }
  @Test
  public void testCheckoutBranch() throws Exception {
    // clone a repo
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    JSONObject clone = clone(clonePath);
    String cloneContentLocation = clone.getString(ProtocolConstants.KEY_CONTENT_LOCATION);
    String cloneLocation = clone.getString(ProtocolConstants.KEY_LOCATION);
    String branchesLocation = clone.getString(GitConstants.KEY_BRANCH);

    // get project metadata
    WebRequest request =
        getGetFilesRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project = new JSONObject(response.getText());

    // create branch 'a'
    branch(branchesLocation, "a");

    // checkout 'a'
    response = checkoutBranch(cloneLocation, "a");
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    Repository db1 = getRepositoryForContentLocation(cloneContentLocation);
    Git git = new Git(db1);
    GitRemoteTest.assertOnBranch(git, "a");
  }
  @Test
  public void testCheckoutPathInUri() throws Exception {
    // clone a repo
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    clone(clonePath);

    // get project metadata
    WebRequest request =
        getGetFilesRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project = new JSONObject(response.getText());

    JSONObject testTxt = getChild(project, "test.txt");
    modifyFile(testTxt, "change");

    JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
    String gitStatusUri = gitSection.getString(GitConstants.KEY_STATUS);
    String gitCloneUri = GitStatusTest.getCloneUri(gitStatusUri);

    // TODO: don't create URIs out of thin air
    request = getCheckoutRequest(gitCloneUri + "test.txt", new String[] {});
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());
  }
  @Test
  public void testCheckoutAfterResetByPath() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject projectTop = createProjectOrLink(workspaceLocation, getMethodName() + "-top", null);
    IPath clonePathTop =
        new Path("file").append(projectTop.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    JSONObject projectFolder =
        createProjectOrLink(workspaceLocation, getMethodName() + "-folder", null);
    IPath clonePathFolder =
        new Path("file")
            .append(projectFolder.getString(ProtocolConstants.KEY_ID))
            .append("folder")
            .makeAbsolute();

    IPath[] clonePaths = new IPath[] {clonePathTop, clonePathFolder};

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

      // get project/folder metadata
      WebRequest request = getGetFilesRequest(cloneContentLocation);
      WebResponse response = webConversation.getResponse(request);
      assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
      JSONObject folder = new JSONObject(response.getText());

      JSONObject gitSection = folder.getJSONObject(GitConstants.KEY_GIT);
      String gitIndexUri = gitSection.getString(GitConstants.KEY_INDEX);
      String gitStatusUri = gitSection.getString(GitConstants.KEY_STATUS);
      String gitCloneUri = GitStatusTest.getCloneUri(gitStatusUri);

      JSONObject testTxt = getChild(folder, "test.txt");
      modifyFile(testTxt, "change");

      assertStatus(new StatusResult().setModified(1), gitStatusUri);

      addFile(testTxt);

      assertStatus(new StatusResult().setChanged(1), gitStatusUri);

      // unstage
      request =
          GitResetTest.getPostGitIndexRequest(
              gitIndexUri, new String[] {"test.txt"}, null, (String) null);
      response = webConversation.getResponse(request);
      assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

      // check status again
      assertStatus(new StatusResult().setModified(1), gitStatusUri);

      // checkout
      request = getCheckoutRequest(gitCloneUri, new String[] {"test.txt"});
      response = webConversation.getResponse(request);
      assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

      // check status one more time
      assertStatus(StatusResult.CLEAN, gitStatusUri);
    }
  }
  @Test
  public void testUpdateNonExistingConfigEntryUsingPUT() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    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 testCreateInvalidConfigEntry() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    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 testGetSingleConfigEntry() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    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);
      assertConfigOption(configEntry, ENTRY_KEY, ENTRY_VALUE);
    }
  }
  /**
   * Uses HttpUnit functionality to retrieve a single sds workgroup from the sds, including the
   * offering and the members
   *
   * @param sdsWorkgroupId The id of the workgroup you want to retrieve
   * @return The SdsWorkgroup with all parameters set.
   * @throws IOException
   * @throws JDOMException
   * @throws SAXException
   */
  @SuppressWarnings("unchecked")
  protected SdsWorkgroup getWorkgroupInSds(Serializable sdsWorkgroupId)
      throws IOException, JDOMException, SAXException {
    String WORKGROUP_PATH = "/workgroup/" + sdsWorkgroupId;
    WebResponse webResponse = this.makeHttpRestGetRequest(WORKGROUP_PATH);
    assertEquals(HttpStatus.SC_OK, webResponse.getResponseCode());

    Document doc = createDocumentFromResponse(webResponse);
    SdsWorkgroup sdsWorkgroup = (SdsWorkgroup) this.applicationContext.getBean("sdsWorkgroup");

    Element workgroupElement = doc.getRootElement();
    sdsWorkgroup.setName(workgroupElement.getChild("name").getValue());
    sdsWorkgroup.setSdsObjectId(new Long(workgroupElement.getChild("id").getValue()));

    Integer sdsOfferingId = new Integer(workgroupElement.getChild("offering-id").getValue());
    SdsOffering sdsOffering = this.getOfferingAlternativeMethod(sdsOfferingId);
    sdsWorkgroup.setSdsOffering(sdsOffering);

    WebResponse membersWebResponse = this.makeHttpRestGetRequest(WORKGROUP_PATH + "/membership");
    assertEquals(HttpStatus.SC_OK, membersWebResponse.getResponseCode());
    Document membersDoc = createDocumentFromResponse(membersWebResponse);

    List<Element> memberElements =
        XPath.newInstance("/workgroup-memberships/workgroup-membership/sail-user-id")
            .selectNodes(membersDoc);

    for (Element memberNode : memberElements) {
      SdsUser sdsUser = this.getUserInSds(new Long(memberNode.getValue()));
      sdsWorkgroup.addMember(sdsUser);
    }

    return sdsWorkgroup;
  }
  @Test
  public void testCloneAndLinkToFolder() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

    File folder =
        new File(
            getRepositoryForContentLocation(contentLocation).getDirectory().getParentFile(),
            "folder");

    JSONObject newProject =
        createProjectOrLink(
            workspaceLocation, getMethodName() + "-link", folder.toURI().toString());
    String projectContentLocation = newProject.getString(ProtocolConstants.KEY_CONTENT_LOCATION);

    // http://<host>/file/<projectId>/
    WebRequest request = getGetFilesRequest(projectContentLocation);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    JSONObject link = new JSONObject(response.getText());
    String childrenLocation = link.getString(ProtocolConstants.KEY_CHILDREN_LOCATION);
    assertNotNull(childrenLocation);

    // http://<host>/file/<projectId>/?depth=1
    request = getGetFilesRequest(childrenLocation);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    List<JSONObject> children = getDirectoryChildren(new JSONObject(response.getText()));
    String[] expectedChildren = new String[] {"folder.txt"};
    assertEquals("Wrong number of directory children", expectedChildren.length, children.size());
    assertEquals(expectedChildren[0], children.get(0).getString(ProtocolConstants.KEY_NAME));
  }
  @Test
  public void testCopyFileOverwrite() throws Exception {
    String directoryPath = "/testCopyFile/directory/path" + System.currentTimeMillis();
    String sourcePath = directoryPath + "/source.txt";
    String destName = "destination.txt";
    String destPath = directoryPath + "/" + destName;
    createDirectory(directoryPath);
    createFile(sourcePath, "This is the contents");
    createFile(destPath, "Original file");

    // with no-overwrite, copy should fail
    JSONObject requestObject = new JSONObject();
    addSourceLocation(requestObject, sourcePath);
    WebRequest request =
        getPostFilesRequest(directoryPath, requestObject.toString(), "destination.txt");
    request.setHeaderField("X-Create-Options", "copy,no-overwrite");
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_PRECON_FAILED, response.getResponseCode());

    // now omit no-overwrite and copy should succeed and return 200 instead of 201
    request = getPostFilesRequest(directoryPath, requestObject.toString(), "destination.txt");
    request.setHeaderField("X-Create-Options", "copy");
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    JSONObject responseObject = new JSONObject(response.getText());
    checkFileMetadata(responseObject, destName, null, null, null, null, null, null, null);
    assertTrue(checkFileExists(sourcePath));
    assertTrue(checkFileExists(destPath));
  }
  @Test
  public void testCloneEmptyPath() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    IPath clonePath =
        new Path("workspace").append(getWorkspaceId(workspaceLocation)).makeAbsolute();

    AuthorizationService.removeUserRight("test", "/");
    AuthorizationService.removeUserRight("test", "/*");

    // /workspace/{id}
    JSONObject clone = clone(clonePath, null, null);

    String cloneContentLocation = clone.getString(ProtocolConstants.KEY_CONTENT_LOCATION);
    WebRequest request = getGetFilesRequest(cloneContentLocation);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    JSONObject project = new JSONObject(response.getText());
    assertEquals(gitDir.getName(), project.getString(ProtocolConstants.KEY_NAME));
    assertGitSectionExists(project);

    String childrenLocation = project.getString(ProtocolConstants.KEY_CHILDREN_LOCATION);
    assertNotNull(childrenLocation);

    // http://<host>/file/<projectId>/?depth=1
    request = getGetFilesRequest(childrenLocation);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
  }
  @Test
  public void testGetNonexistingClone() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    String workspaceId = getWorkspaceId(workspaceLocation);

    WebRequest request = listGitClonesRequest(workspaceId, null);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    JSONObject clones = new JSONObject(response.getText());
    JSONArray clonesArray = clones.getJSONArray(ProtocolConstants.KEY_CHILDREN);

    String dummyId = "dummyId";

    ensureCloneIdDoesntExist(clonesArray, dummyId);

    String requestURI =
        SERVER_LOCATION + GIT_SERVLET_LOCATION + Clone.RESOURCE + "/workspace/" + dummyId;
    request = getGetRequest(requestURI);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

    requestURI = SERVER_LOCATION + GIT_SERVLET_LOCATION + Clone.RESOURCE + "/file/" + dummyId;
    request = getGetRequest(requestURI);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());
  }
Exemple #15
0
  private void assertDiffUris(
      String expectedLocation, String[] expectedContent, JSONObject jsonPart)
      throws JSONException, IOException, SAXException {
    JSONObject gitSection = jsonPart.getJSONObject(GitConstants.KEY_GIT);
    assertNotNull(gitSection);

    String fileOldUri = gitSection.getString(GitConstants.KEY_COMMIT_OLD);
    assertNotNull(fileOldUri);
    WebRequest request = getGetFilesRequest(fileOldUri);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    assertEquals(expectedContent[0], response.getText());

    String fileNewUri = gitSection.getString(GitConstants.KEY_COMMIT_NEW);
    assertNotNull(fileNewUri);
    request = getGetFilesRequest(fileNewUri);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    assertEquals(expectedContent[1], response.getText());

    String fileBaseUri = gitSection.getString(GitConstants.KEY_COMMIT_BASE);
    assertNotNull(fileBaseUri);
    request = getGetFilesRequest(fileBaseUri);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    assertEquals(expectedContent[2], response.getText());

    String diffUri = gitSection.getString(GitConstants.KEY_DIFF);
    assertNotNull(diffUri);
    assertEquals(expectedLocation, diffUri);
  }
  @Test
  public void testDeleteInWorkspace() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    JSONObject clone = clone(clonePath);
    String cloneLocation = clone.getString(ProtocolConstants.KEY_LOCATION);
    String contentLocation = clone.getString(ProtocolConstants.KEY_CONTENT_LOCATION);

    Repository repository = getRepositoryForContentLocation(contentLocation);
    assertNotNull(repository);

    // delete folder with cloned repository in it
    WebRequest request = getDeleteFilesRequest(contentLocation);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // the clone is gone
    request = getGetRequest(cloneLocation);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

    assertFalse(repository.getDirectory().exists());
  }
  @Test
  public void testCreateDirectory() throws CoreException, IOException, SAXException, JSONException {
    String directoryPath = "sample/directory/path" + System.currentTimeMillis();
    createDirectory(directoryPath);

    String dirName = "testdir";
    webConversation.setExceptionsThrownOnErrorStatus(false);

    WebRequest request =
        getPostFilesRequest(directoryPath, getNewDirJSON(dirName).toString(), dirName);
    WebResponse response = webConversation.getResponse(request);

    assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
    assertTrue(
        "Create directory response was OK, but the directory does not exist",
        checkDirectoryExists(directoryPath + "/" + dirName));
    assertEquals(
        "Response should contain directory metadata in JSON, but was " + response.getText(),
        "application/json",
        response.getContentType());
    JSONObject responseObject = new JSONObject(response.getText());
    assertNotNull("No directory information in response", responseObject);
    checkDirectoryMetadata(responseObject, dirName, null, null, null, null, null);

    // should be able to perform GET on location header to obtain metadata
    String location = response.getHeaderField(ProtocolConstants.HEADER_LOCATION);
    request = getGetFilesRequest(location);
    response = webConversation.getResource(request);
    assertNotNull(location);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    responseObject = new JSONObject(response.getText());
    assertNotNull("No direcory information in responce", responseObject);
    checkDirectoryMetadata(responseObject, dirName, null, null, null, null, null);
  }
  @Test
  public void testDeleteInFolder() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file")
            .append(project.getString(ProtocolConstants.KEY_ID))
            .append("clone")
            .makeAbsolute();
    JSONObject clone = clone(clonePath);
    String cloneLocation = clone.getString(ProtocolConstants.KEY_LOCATION);
    String contentLocation = clone.getString(ProtocolConstants.KEY_CONTENT_LOCATION);

    // delete clone
    WebRequest request = getDeleteCloneRequest(cloneLocation);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // the clone is gone
    request = getGetRequest(cloneLocation);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

    // so it's the folder
    request = getGetRequest(contentLocation);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_NOT_FOUND, response.getResponseCode());

    // but the project is still there
    request = getGetFilesRequest(project.getString(ProtocolConstants.KEY_ID));
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
  }
  @Test
  public void testCreateTopLevelFile()
      throws CoreException, IOException, SAXException, JSONException {
    String directoryPath = "sample" + System.currentTimeMillis();
    createDirectory(directoryPath);
    String fileName = "testfile.txt";

    WebRequest request =
        getPostFilesRequest(directoryPath, getNewFileJSON(fileName).toString(), fileName);
    WebResponse response = webConversation.getResponse(request);

    assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
    assertTrue(
        "Create file response was OK, but the file does not exist",
        checkFileExists(directoryPath + "/" + fileName));
    assertEquals(
        "Response should contain file metadata in JSON, but was " + response.getText(),
        "application/json",
        response.getContentType());
    JSONObject responseObject = new JSONObject(response.getText());
    assertNotNull("No file information in responce", responseObject);
    checkFileMetadata(responseObject, fileName, null, null, null, null, null, null, null);

    // should be able to perform GET on location header to obtain metadata
    String location = response.getHeaderField("Location");
    request = getGetFilesRequest(location + "?parts=meta");
    response = webConversation.getResource(request);
    assertNotNull(location);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    responseObject = new JSONObject(response.getText());
    assertNotNull("No direcory information in responce", responseObject);
    checkFileMetadata(responseObject, fileName, null, null, null, null, null, null, null);
  }
  @Test
  public void testDeleteNonEmptyDirectory() throws CoreException, IOException, SAXException {
    String dirPath1 = "sample/directory/path/sample1" + System.currentTimeMillis();
    String dirPath2 = "sample/directory/path/sample2" + System.currentTimeMillis();
    String fileName = "subfile.txt";
    String subDirectory = "subdirectory";

    createDirectory(dirPath1);
    createFile(dirPath1 + "/" + fileName, "Sample file content");
    createDirectory(dirPath2 + "/" + subDirectory);

    WebRequest request = getDeleteFilesRequest(dirPath1);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(
        "Could not delete directory with file",
        HttpURLConnection.HTTP_OK,
        response.getResponseCode());

    assertFalse(
        "Delete directory with file request returned OK, but the file still exists",
        checkDirectoryExists(dirPath1));

    request = getDeleteFilesRequest(dirPath2);
    response = webConversation.getResponse(request);
    assertEquals(
        "Could not delete directory with subdirectory",
        HttpURLConnection.HTTP_OK,
        response.getResponseCode());

    assertFalse(
        "Delete directory with subdirectory request returned OK, but the file still exists",
        checkDirectoryExists(dirPath2));
  }
Exemple #21
0
  @Test
  public void testDiffModifiedByOrion() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());

    String projectName = getMethodName();
    JSONObject project = createProjectOrLink(workspaceLocation, projectName, gitDir.toString());
    String projectId = project.getString(ProtocolConstants.KEY_ID);

    WebRequest request = getPutFileRequest(projectId + "/test.txt", "hello");
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    JSONObject gitSection = project.optJSONObject(GitConstants.KEY_GIT);
    assertNotNull(gitSection);
    String gitDiffUri = gitSection.getString(GitConstants.KEY_DIFF);

    request = getGetGitDiffRequest(gitDiffUri);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    StringBuilder sb = new StringBuilder();
    sb.append("diff --git a/test.txt b/test.txt").append("\n");
    sb.append("index 30d74d2..b6fc4c6 100644").append("\n");
    sb.append("--- a/test.txt").append("\n");
    sb.append("+++ b/test.txt").append("\n");
    sb.append("@@ -1 +1 @@").append("\n");
    sb.append("-test").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    sb.append("+hello").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    String[] parts = parseMultiPartResponse(response);
    assertEquals(sb.toString(), parts[1]);
  }
Exemple #22
0
  @Test
  public void testDiffFilter() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());

    String projectName = getMethodName();
    JSONObject project = createProjectOrLink(workspaceLocation, projectName, gitDir.toString());
    String projectId = project.getString(ProtocolConstants.KEY_ID);

    JSONObject gitSection = project.optJSONObject(GitConstants.KEY_GIT);
    assertNotNull(gitSection);
    String gitDiffUri = gitSection.getString(GitConstants.KEY_DIFF);

    WebRequest request = getPutFileRequest(projectId + "/test.txt", "hi");
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    request = getPutFileRequest(projectId + "/folder/folder.txt", "folder change");
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // TODO: don't create URIs out of thin air
    request = getGetGitDiffRequest(gitDiffUri + "folder/");
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    StringBuilder sb = new StringBuilder();
    sb.append("diff --git a/folder/folder.txt b/folder/folder.txt").append("\n");
    sb.append("index 0119635..95c4c65 100644").append("\n");
    sb.append("--- a/folder/folder.txt").append("\n");
    sb.append("+++ b/folder/folder.txt").append("\n");
    sb.append("@@ -1 +1 @@").append("\n");
    sb.append("-folder").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    sb.append("+folder change").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    String[] parts = parseMultiPartResponse(response);
    assertEquals(sb.toString(), parts[1]);

    // TODO: don't create URIs out of thin air
    gitDiffUri += "test.txt";
    request = getGetGitDiffRequest(gitDiffUri);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    parts = parseMultiPartResponse(response);

    assertDiffUris(gitDiffUri, new String[] {"test", "hi", "test"}, new JSONObject(parts[0]));

    sb.setLength(0);
    sb.append("diff --git a/test.txt b/test.txt").append("\n");
    sb.append("index 30d74d2..32f95c0 100644").append("\n");
    sb.append("--- a/test.txt").append("\n");
    sb.append("+++ b/test.txt").append("\n");
    sb.append("@@ -1 +1 @@").append("\n");
    sb.append("-test").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    sb.append("+hi").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    assertEquals(sb.toString(), parts[1]);
  }
  @Test
  public void testMergeIntoLocalFailedDirtyWorkTree() throws Exception {
    // clone a repo
    createWorkspace(SimpleMetaStore.DEFAULT_WORKSPACE_NAME);
    String workspaceId = workspaceIdFromLocation(workspaceLocation);
    JSONObject project =
        createProjectOrLink(workspaceLocation, getMethodName().concat("Project"), null);
    IPath clonePath = getClonePath(workspaceId, project);
    clone(clonePath);

    // get project metadata
    WebRequest request = getGetRequest(project.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project = new JSONObject(response.getText());
    JSONObject gitSection = project.getJSONObject(GitConstants.KEY_GIT);
    String gitHeadUri = gitSection.getString(GitConstants.KEY_HEAD);
    String gitRemoteUri = gitSection.getString(GitConstants.KEY_REMOTE);

    // add a parallel commit in secondary clone and push it to the remote
    JSONObject project2 =
        createProjectOrLink(workspaceLocation, getMethodName().concat("Project2"), null);
    IPath clonePath2 = getClonePath(workspaceId, project2);
    clone(clonePath2);

    // get project2 metadata
    request = getGetRequest(project2.getString(ProtocolConstants.KEY_CONTENT_LOCATION));
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    project2 = new JSONObject(response.getText());
    JSONObject gitSection2 = project2.getJSONObject(GitConstants.KEY_GIT);
    String gitRemoteUri2 = gitSection2.getString(GitConstants.KEY_REMOTE);

    JSONObject testTxt = getChild(project2, "test.txt");
    modifyFile(testTxt, "change in secondary");
    addFile(testTxt);
    commitFile(testTxt, "commit on branch", false);

    ServerStatus pushStatus = push(gitRemoteUri2, 1, 0, Constants.MASTER, Constants.HEAD, false);
    assertEquals(true, pushStatus.isOK());

    // modify on master and try to merge
    testTxt = getChild(project, "test.txt");
    modifyFile(testTxt, "dirty");

    JSONObject masterDetails = getRemoteBranch(gitRemoteUri, 1, 0, Constants.MASTER);
    String masterLocation = masterDetails.getString(ProtocolConstants.KEY_LOCATION);
    fetch(masterLocation);
    JSONObject merge = merge(gitHeadUri, Constants.DEFAULT_REMOTE_NAME + "/" + Constants.MASTER);

    MergeStatus mergeResult = MergeStatus.valueOf(merge.getString(GitConstants.KEY_RESULT));
    assertEquals(MergeStatus.FAILED, mergeResult);
    JSONObject failingPaths = merge.getJSONObject(GitConstants.KEY_FAILING_PATHS);
    assertEquals(1, failingPaths.length());
    assertEquals(
        MergeFailureReason.DIRTY_WORKTREE,
        MergeFailureReason.valueOf(failingPaths.getString("test.txt")));
  }
  @Test
  public void testRoom() throws Exception {
    // create room
    WebRequest request =
        new PostMethodWebRequest(
            getCreateUrl(),
            new ByteArrayInputStream(objectMapper.writeValueAsString(baseRoom).getBytes()),
            MediaType.APPLICATION_JSON_VALUE);
    WebResponse response = conversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_CREATED, response.getResponseCode());
    assertEquals(MediaType.APPLICATION_JSON_VALUE, response.getContentType());
    Room room = objectMapper.readValue(response.getText(), Room.class);
    assertNotNull(room);
    assertTrue(room.getId() != 0);
    assertTrue(compare(baseRoom, room, "id"));

    // update room
    baseRoom = room;
    baseRoom.setName("New name");
    request =
        new PutMethodWebRequest(
            getUpdateUrl(),
            new ByteArrayInputStream(objectMapper.writeValueAsString(baseRoom).getBytes()),
            MediaType.APPLICATION_JSON_VALUE);
    response = conversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    assertEquals(MediaType.APPLICATION_JSON_VALUE, response.getContentType());
    room = objectMapper.readValue(response.getText(), Room.class);
    assertNotNull(room);
    assertEquals(room, baseRoom);

    // get room
    request = new GetMethodWebRequest(getViewUrl(baseRoom.getId()));
    response = conversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    assertEquals(MediaType.APPLICATION_JSON_VALUE, response.getContentType());
    room = objectMapper.readValue(response.getText(), Room.class);
    assertNotNull(room);
    assertEquals(room, baseRoom);

    // remove room
    request =
        new WebRequest(getDeleteUrl(baseRoom.getId())) {

          @Override
          public String getMethod() {
            return RequestMethod.DELETE.toString();
          }
        };
    response = conversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // check removed
    URL url = new URL(getViewUrl(baseRoom.getId()));
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.connect();
    assertEquals(HttpURLConnection.HTTP_NO_CONTENT, connection.getResponseCode());
  }
  @Test
  public void testAddConfigEntry() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    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))) {
          assertConfigOption(configEntry, ENTRY_KEY, ENTRY_VALUE);
          break;
        }
      }

      // double check
      org.eclipse.jgit.lib.Config config =
          getRepositoryForContentLocation(contentLocation).getConfig();
      assertEquals(ENTRY_VALUE, config.getString("a", "b", "c"));
    }
  }
Exemple #26
0
  @Test
  public void testDiffCached() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());

    String projectName = getMethodName();
    JSONObject project = createProjectOrLink(workspaceLocation, projectName, gitDir.toString());
    String projectId = project.getString(ProtocolConstants.KEY_ID);

    JSONObject gitSection = project.optJSONObject(GitConstants.KEY_GIT);
    assertNotNull(gitSection);

    String gitDiffUri = gitSection.optString(GitConstants.KEY_DIFF, null);
    assertNotNull(gitDiffUri);
    String gitIndexUri = gitSection.optString(GitConstants.KEY_INDEX, null);
    assertNotNull(gitIndexUri);

    WebRequest request = getPutFileRequest(projectId + "/test.txt", "stage me");
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // TODO: don't create URIs out of thin air
    // "git add test.txt"
    request = GitAddTest.getPutGitIndexRequest(gitIndexUri + "test.txt");
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    // TODO: don't create URIs out of thin air
    gitDiffUri =
        gitDiffUri.replaceAll(GitConstants.KEY_DIFF_DEFAULT, GitConstants.KEY_DIFF_CACHED)
            + "test.txt";
    request = getGetGitDiffRequest(gitDiffUri);
    response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    String[] parts = parseMultiPartResponse(response);

    assertDiffUris(gitDiffUri, new String[] {"test", "stage me", "test"}, new JSONObject(parts[0]));

    StringBuilder sb = new StringBuilder();
    sb.append("diff --git a/test.txt b/test.txt").append("\n");
    sb.append("index 30d74d2..b874aa3 100644").append("\n");
    sb.append("--- a/test.txt").append("\n");
    sb.append("+++ b/test.txt").append("\n");
    sb.append("@@ -1 +1 @@").append("\n");
    sb.append("-test").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    sb.append("+stage me").append("\n");
    sb.append("\\ No newline at end of file").append("\n");
    assertEquals(sb.toString(), parts[1]);
  }
  @Test
  public void testReadDirectoryChildren()
      throws CoreException, IOException, SAXException, JSONException {
    String dirName = "path" + System.currentTimeMillis();
    String directoryPath = "sample/directory/" + dirName;
    createDirectory(directoryPath);

    String subDirectory = "subdirectory";
    createDirectory(directoryPath + "/" + subDirectory);

    String subFile = "subfile.txt";
    createFile(directoryPath + "/" + subFile, "Sample file");

    WebRequest request = getGetFilesRequest(directoryPath + "?depth=1");
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());

    List<JSONObject> children = getDirectoryChildren(new JSONObject(response.getText()));

    assertEquals("Wrong number of directory children", 2, children.size());

    for (JSONObject child : children) {
      if (child.getBoolean("Directory")) {
        checkDirectoryMetadata(child, subDirectory, null, null, null, null, null);
      } else {
        checkFileMetadata(child, subFile, null, null, null, null, null, null, null);
      }
    }
  }
  @Test
  public void testCloneEmptyPathBadUrl() throws Exception {
    URI workspaceLocation = createWorkspace(getMethodName());
    IPath workspacePath =
        new Path("workspace").append(getWorkspaceId(workspaceLocation)).makeAbsolute();

    AuthorizationService.removeUserRight("test", "/");
    AuthorizationService.removeUserRight("test", "/*");

    // /workspace/{id} + {methodName}
    WebRequest request =
        new PostGitCloneRequest()
            .setURIish("I'm//bad!")
            .setWorkspacePath(workspacePath)
            .setName(getMethodName())
            .getWebRequest();
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, response.getResponseCode());

    // no project should be created
    request = new GetMethodWebRequest(workspaceLocation.toString());
    setAuthentication(request);
    response = webConversation.getResponse(request);
    JSONObject workspace = new JSONObject(response.getText());
    assertEquals(0, workspace.getJSONArray(ProtocolConstants.KEY_CHILDREN).length());
  }
  @Test
  public void testGetCloneAndPull() throws Exception {
    // see bug 339254
    URI workspaceLocation = createWorkspace(getMethodName());
    String workspaceId = getWorkspaceId(workspaceLocation);

    JSONObject project = createProjectOrLink(workspaceLocation, getMethodName(), null);
    IPath clonePath =
        new Path("file").append(project.getString(ProtocolConstants.KEY_ID)).makeAbsolute();
    String contentLocation = clone(clonePath).getString(ProtocolConstants.KEY_CONTENT_LOCATION);

    // get clones for workspace
    WebRequest request = listGitClonesRequest(workspaceId, null);
    WebResponse response = webConversation.getResponse(request);
    assertEquals(HttpURLConnection.HTTP_OK, response.getResponseCode());
    JSONObject clones = new JSONObject(response.getText());
    JSONArray clonesArray = clones.getJSONArray(ProtocolConstants.KEY_CHILDREN);
    assertEquals(1, clonesArray.length());

    Git git = new Git(getRepositoryForContentLocation(contentLocation));
    // TODO: replace with RESTful API when ready, see bug 339114
    PullResult pullResult = git.pull().call();
    assertEquals(pullResult.getMergeResult().getMergeStatus(), MergeStatus.ALREADY_UP_TO_DATE);
    assertEquals(RepositoryState.SAFE, git.getRepository().getRepositoryState());
  }
  public void testViewIssueNotFound() throws Exception {
    administration.restoreBlankInstance();

    WebResponse resp123 = GET("rest/api/2/issue/1");
    assertEquals(404, resp123.getResponseCode());
    assertNoLongerExistsError(resp123);

    WebResponse resp123Xml =
        GET("rest/api/2/issue/1", singletonMap("Accept", "application/xml;q=0.9,*/*;q=0.8"));
    assertEquals(404, resp123Xml.getResponseCode());
    assertNoLongerExistsError(resp123Xml);

    WebResponse resp415 =
        GET("rest/api/2/issue/1", singletonMap("Accept", "application/xml;q=0.9"));
    assertEquals(406, resp415.getResponseCode());
  }