@Test
  public void testInitialClone_Packed() throws Exception {
    new TestRepository<Repository>(remoteRepository).packAndPrune();

    Repository dst = createBareRepository();
    assertFalse(dst.hasObject(A_txt));

    Transport t = Transport.open(dst, remoteURI);
    ((TransportHttp) t).setUseSmartHttp(false);
    try {
      t.fetch(NullProgressMonitor.INSTANCE, mirror(master));
    } finally {
      t.close();
    }

    assertTrue(dst.hasObject(A_txt));
    assertEquals(B, dst.getRef(master).getObjectId());
    fsck(dst, B);

    List<AccessEvent> req;

    req = getRequests(loose(remoteURI, B));
    assertEquals(1, req.size());
    assertEquals("GET", req.get(0).getMethod());
    assertEquals(0, req.get(0).getParameters().size());
    assertEquals(404, req.get(0).getStatus());

    req = getRequests(join(remoteURI, "objects/info/packs"));
    assertEquals(1, req.size());
    assertEquals("GET", req.get(0).getMethod());
    assertEquals(0, req.get(0).getParameters().size());
    assertEquals(200, req.get(0).getStatus());
    assertEquals("text/plain;charset=UTF-8", req.get(0).getResponseHeader(HDR_CONTENT_TYPE));
  }
  @Test
  public void testListRemote_Smart_WithQueryParameters() throws Exception {
    URIish myURI = toURIish("/snone/do?r=1&p=test.git");
    Repository dst = createBareRepository();
    Transport t = Transport.open(dst, myURI);
    try {
      try {
        t.openFetch();
        fail("test did not fail to find repository as expected");
      } catch (NoRemoteRepositoryException err) {
        // expected
      }
    } finally {
      t.close();
    }

    List<AccessEvent> requests = getRequests();
    assertEquals(1, requests.size());

    AccessEvent info = requests.get(0);
    assertEquals("GET", info.getMethod());
    assertEquals("/snone/do", info.getPath());
    assertEquals(3, info.getParameters().size());
    assertEquals("1", info.getParameter("r"));
    assertEquals("test.git/info/refs", info.getParameter("p"));
    assertEquals("git-upload-pack", info.getParameter("service"));
    assertEquals(404, info.getStatus());
  }
  @Test
  public void testInitialClone_Small() throws Exception {
    Repository dst = createBareRepository();
    assertFalse(dst.hasObject(A_txt));

    Transport t = Transport.open(dst, remoteURI);
    ((TransportHttp) t).setUseSmartHttp(false);
    try {
      t.fetch(NullProgressMonitor.INSTANCE, mirror(master));
    } finally {
      t.close();
    }

    assertTrue(dst.hasObject(A_txt));
    assertEquals(B, dst.getRef(master).getObjectId());
    fsck(dst, B);

    List<AccessEvent> loose = getRequests(loose(remoteURI, A_txt));
    assertEquals(1, loose.size());
    assertEquals("GET", loose.get(0).getMethod());
    assertEquals(0, loose.get(0).getParameters().size());
    assertEquals(200, loose.get(0).getStatus());
    assertEquals(
        "application/x-git-loose-object", loose.get(0).getResponseHeader(HDR_CONTENT_TYPE));
  }
  @Test
  public void testListRemote() throws IOException {
    Repository dst = createBareRepository();

    assertEquals("http", remoteURI.getScheme());

    Map<String, Ref> map;
    Transport t = Transport.open(dst, remoteURI);
    ((TransportHttp) t).setUseSmartHttp(false);
    try {
      // I didn't make up these public interface names, I just
      // approved them for inclusion into the code base. Sorry.
      // --spearce
      //
      assertTrue("isa TransportHttp", t instanceof TransportHttp);
      assertTrue("isa HttpTransport", t instanceof HttpTransport);

      FetchConnection c = t.openFetch();
      try {
        map = c.getRefsMap();
      } finally {
        c.close();
      }
    } finally {
      t.close();
    }

    assertNotNull("have map of refs", map);
    assertEquals(2, map.size());

    assertNotNull("has " + master, map.get(master));
    assertEquals(B, map.get(master).getObjectId());

    assertNotNull("has " + Constants.HEAD, map.get(Constants.HEAD));
    assertEquals(B, map.get(Constants.HEAD).getObjectId());

    List<AccessEvent> requests = getRequests();
    assertEquals(2, requests.size());
    assertEquals(0, getRequests(remoteURI, "git-upload-pack").size());

    AccessEvent info = requests.get(0);
    assertEquals("GET", info.getMethod());
    assertEquals(join(remoteURI, "info/refs"), info.getPath());
    assertEquals(0, info.getParameters().size());
    assertNull("no service parameter", info.getParameter("service"));
    assertEquals("no-cache", info.getRequestHeader(HDR_PRAGMA));
    assertNotNull("has user-agent", info.getRequestHeader(HDR_USER_AGENT));
    assertTrue("is jgit agent", info.getRequestHeader(HDR_USER_AGENT).startsWith("JGit/"));
    assertEquals("*/*", info.getRequestHeader(HDR_ACCEPT));
    assertEquals(200, info.getStatus());
    assertEquals("text/plain;charset=UTF-8", info.getResponseHeader(HDR_CONTENT_TYPE));

    AccessEvent head = requests.get(1);
    assertEquals("GET", head.getMethod());
    assertEquals(join(remoteURI, "HEAD"), head.getPath());
    assertEquals(0, head.getParameters().size());
    assertEquals(200, head.getStatus());
    assertEquals("text/plain", head.getResponseHeader(HDR_CONTENT_TYPE));
  }
Exemple #5
0
 private FetchResult runFetch() throws URISyntaxException, IOException {
   final Transport tn = Transport.open(db, remoteName);
   final FetchResult r;
   try {
     tn.setTagOpt(TagOpt.FETCH_TAGS);
     r = tn.fetch(new TextProgressMonitor(), null);
   } finally {
     tn.close();
   }
   showFetchResult(r);
   return r;
 }
 @Test
 public void testListRemote_Dumb_Auth() throws Exception {
   Repository dst = createBareRepository();
   Transport t = Transport.open(dst, dumbAuthBasicURI);
   t.setCredentialsProvider(
       new UsernamePasswordCredentialsProvider(AppServer.username, AppServer.password));
   try {
     t.openFetch();
   } finally {
     t.close();
   }
   t = Transport.open(dst, dumbAuthBasicURI);
   t.setCredentialsProvider(new UsernamePasswordCredentialsProvider(AppServer.username, ""));
   try {
     t.openFetch();
     fail("connection opened even info/refs needs auth basic and we provide wrong password");
   } catch (TransportException err) {
     String exp = dumbAuthBasicURI + ": " + JGitText.get().notAuthorized;
     assertEquals(exp, err.getMessage());
   } finally {
     t.close();
   }
 }
 @Test
 public void testListRemote_Smart_UploadPackNeedsAuth() throws Exception {
   Repository dst = createBareRepository();
   Transport t = Transport.open(dst, smartAuthBasicURI);
   try {
     try {
       t.openFetch();
       fail("connection opened even though service disabled");
     } catch (TransportException err) {
       String exp = smartAuthBasicURI + ": " + JGitText.get().notAuthorized;
       assertEquals(exp, err.getMessage());
     }
   } finally {
     t.close();
   }
 }
 @Test
 public void testListRemote_Dumb_NeedsAuth() throws Exception {
   Repository dst = createBareRepository();
   Transport t = Transport.open(dst, dumbAuthBasicURI);
   try {
     try {
       t.openFetch();
       fail("connection opened even info/refs needs auth basic");
     } catch (TransportException err) {
       String exp = dumbAuthBasicURI + ": " + JGitText.get().notAuthorized;
       assertEquals(exp, err.getMessage());
     }
   } finally {
     t.close();
   }
 }
 @Test
 public void testRepositoryNotFound_Smart() throws Exception {
   URIish uri = toURIish("/smart.none/not-found");
   Repository dst = createBareRepository();
   Transport t = Transport.open(dst, uri);
   try {
     try {
       t.openFetch();
       fail("connection opened to not found repository");
     } catch (NoRemoteRepositoryException err) {
       String exp = uri + ": " + uri + "/info/refs?service=git-upload-pack not found";
       assertEquals(exp, err.getMessage());
     }
   } finally {
     t.close();
   }
 }
  /**
   * @param pm the monitor to be used for reporting progress and responding to cancellation. The
   *     monitor is never <code>null</code>
   * @throws InvocationTargetException
   * @throws InterruptedException
   */
  public void run(IProgressMonitor pm) throws InvocationTargetException, InterruptedException {
    Transport transport = null;
    Connection connection = null;
    try {
      transport = Transport.open(localDb, uri);

      if (pm != null) pm.beginTask(CoreText.ListRemoteOperation_title, IProgressMonitor.UNKNOWN);
      connection = transport.openFetch();
      remoteRefsMap = connection.getRefsMap();
    } catch (NotSupportedException e) {
      throw new InvocationTargetException(e);
    } catch (TransportException e) {
      throw new InvocationTargetException(e);
    } finally {
      if (connection != null) connection.close();
      if (transport != null) transport.close();
      if (pm != null) pm.done();
    }
  }
  @Test
  public void testPushNotSupported() throws Exception {
    final TestRepository src = createTestRepository();
    final RevCommit Q = src.commit().create();
    final Repository db = src.getRepository();

    Transport t = Transport.open(db, remoteURI);
    ((TransportHttp) t).setUseSmartHttp(false);
    try {
      try {
        t.push(NullProgressMonitor.INSTANCE, push(src, Q));
        fail("push incorrectly completed against a smart server");
      } catch (NotSupportedException nse) {
        String exp = "smart HTTP push disabled";
        assertEquals(exp, nse.getMessage());
      }
    } finally {
      t.close();
    }
  }
  @Test
  public void testListRemote_Smart_UploadPackDisabled() throws Exception {
    FileRepository src = remoteRepository.getRepository();
    final FileBasedConfig cfg = src.getConfig();
    cfg.setBoolean("http", null, "uploadpack", false);
    cfg.save();

    Repository dst = createBareRepository();
    Transport t = Transport.open(dst, smartAuthNoneURI);
    try {
      try {
        t.openFetch();
        fail("connection opened even though service disabled");
      } catch (TransportException err) {
        String exp = smartAuthNoneURI + ": git-upload-pack not permitted";
        assertEquals(exp, err.getMessage());
      }
    } finally {
      t.close();
    }
  }
  @Test
  public void testListRemote_Dumb_NoHEAD() throws Exception {
    FileRepository src = remoteRepository.getRepository();
    File headref = new File(src.getDirectory(), Constants.HEAD);
    assertTrue("HEAD used to be present", headref.delete());
    assertFalse("HEAD is gone", headref.exists());

    Repository dst = createBareRepository();
    Ref head;
    Transport t = Transport.open(dst, dumbAuthNoneURI);
    try {
      FetchConnection c = t.openFetch();
      try {
        head = c.getRef(Constants.HEAD);
      } finally {
        c.close();
      }
    } finally {
      t.close();
    }
    assertNull("has no " + Constants.HEAD, head);
  }
 /**
  * Creates a push operation specification for the given push uris to the given push operation
  * specification.
  *
  * @param pushURIs the push uri's
  * @param pushRefSpecs the push ref specs
  * @param repository the repository
  * @return the push operation specification
  * @throws CoreException the core exception
  */
 private static PushOperationSpecification createPushSpec(
     Collection<URIish> pushURIs, Collection<RefSpec> pushRefSpecs, Repository repository)
     throws CoreException {
   try {
     PushOperationSpecification pushSpec = new PushOperationSpecification();
     for (URIish uri : pushURIs) {
       Collection<RemoteRefUpdate> remoteRefUpdates =
           Transport.open(repository, uri).findRemoteRefUpdatesFor(pushRefSpecs);
       pushSpec.addURIRefUpdates(uri, remoteRefUpdates);
     }
     return pushSpec;
   } catch (NotSupportedException e) {
     throw new CoreException(
         createStatus(
             e, "Could not connect repository \"{0}\" to a remote", repository.toString()));
   } catch (IOException e) {
     throw new CoreException(
         createStatus(
             e,
             "Could not convert remote specifications for repository \"{0}\" to a remote",
             repository.toString()));
   }
 }
  @Test
  public void testListRemote_Smart_DetachedHEAD() throws Exception {
    Repository src = remoteRepository.getRepository();
    RefUpdate u = src.updateRef(Constants.HEAD, true);
    RevCommit Q = remoteRepository.commit().message("Q").create();
    u.setNewObjectId(Q);
    assertEquals(RefUpdate.Result.FORCED, u.forceUpdate());

    Repository dst = createBareRepository();
    Ref head;
    Transport t = Transport.open(dst, smartAuthNoneURI);
    try {
      FetchConnection c = t.openFetch();
      try {
        head = c.getRef(Constants.HEAD);
      } finally {
        c.close();
      }
    } finally {
      t.close();
    }
    assertNotNull("has " + Constants.HEAD, head);
    assertEquals(Q, head.getObjectId());
  }