def _testSSH(self, user, name=None):
    self.repository.initialize()

    remoteRepository = self.createTemporaryRepository(name, self.repository.path, True)

    self.repository.addRemote("origin", formatRemote("ssh", self.ssh, remoteRepository.path.split('/')[-1], user))
    self.generateComplicatedCommit()

    return remoteRepository
Ejemplo n.º 2
0
  def _testHTTP(self, user):
    self.repository.initialize()

    remoteRepository = self.createTemporaryRepository(None, self.repository.path, True)

    self.repository.addRemote("origin", formatRemote("http", self.http, remoteRepository.path.split('/')[-1], user))
    self.generateComplicatedCommit()

    return remoteRepository
Ejemplo n.º 3
0
    def testHTTPError(self):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(None, self.repository.path, True)

        self.repository.addRemote("origin", formatRemote("http", self.http, remoteRepository.path.split("/")[-1]))
        self.generateComplicatedCommit()

        def processEnded(result):
            self.assertError("Hello world")
            self.assertNotEqual(self.repository, remoteRepository)

        return self.pushRepository(self.repository).addCallback(processEnded)
  def testHTTPPush(self):
    self.repository.initialize()

    remoteRepository = self.createTemporaryRepository(None, self.repository.path, True)

    self.repository.addRemote("origin", formatRemote("http", self.http, remoteRepository.path.split('/')[-1]))
    self.generateComplicatedCommit()

    def processEnded(result):
      self.assertNoError()
      self.assertEqual(self.repository, remoteRepository)

    return self.pushRepository(self.repository).addCallback(processEnded)
    def _testHTTP(self, user):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(
            None, self.repository.path, True)

        self.repository.addRemote(
            "origin",
            formatRemote("http", self.http,
                         remoteRepository.path.split('/')[-1], user))
        self.generateComplicatedCommit()

        return remoteRepository
Ejemplo n.º 6
0
    def _testSSH(self, user, name=None):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(
            name, self.repository.path, True)

        self.repository.addRemote(
            "origin",
            formatRemote("ssh", self.ssh,
                         remoteRepository.path.split('/')[-1], user))
        self.generateComplicatedCommit()

        return remoteRepository
Ejemplo n.º 7
0
    def testSSHPush(self):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(None, self.repository.path, True)

        self.repository.addRemote("origin", formatRemote("ssh", self.ssh, remoteRepository.path.split("/")[-1]))
        self.generateComplicatedCommit()

        def processEnded(result):
            self.assertNoError()
            self.assertEqual(self.repository, remoteRepository)

        return self.pushRepository(self.repository, "derp").addCallback(processEnded)
Ejemplo n.º 8
0
  def testHTTPUnauthorizedPush(self):
    self.repository.initialize()

    remoteRepository = self.createTemporaryRepository(None, self.repository.path, True)

    self.repository.addRemote("origin", formatRemote("http", self.http, remoteRepository.path.split('/')[-1]))
    self.generateComplicatedCommit()

    def processEnded(result):
      self.assertError("You are not allowed to PUSH to second-branch.")
      self.assertNotEqual(self.repository, remoteRepository)

    return self.pushRepository(self.repository).addCallback(processEnded)
  def testHTTPPull(self):
    self.repository.initialize()

    otherRepository = self.createTemporaryRepository(None, self.repository.path, False)

    self.repository.addRemote("origin", formatRemote("http", self.http, otherRepository.path.split('/')[-1]) + "/.git")
    self.generateComplicatedCommit(otherRepository)

    def processEnded(result):
      self.assertNoError()
      self.assertEqual(self.repository, otherRepository)

    self.assertNotEqual(self.repository, otherRepository)

    return self.pullRepository(self.repository).addCallback(processEnded)
Ejemplo n.º 10
0
    def testSSHPull(self):
        self.repository.initialize()

        otherRepository = self.createTemporaryRepository(None, self.repository.path, False)

        self.repository.addRemote("origin", formatRemote("ssh", self.ssh, otherRepository.path.split("/")[-1]))
        self.generateComplicatedCommit(otherRepository)

        def processEnded(result):
            self.assertNoError()
            self.assertEqual(self.repository, otherRepository)

        self.assertNotEqual(self.repository, otherRepository)

        return self.pullRepository(self.repository).addCallback(processEnded)
Ejemplo n.º 11
0
  def testHTTPAuthorizedPull(self):
    self.repository.initialize()

    otherRepository = self.createTemporaryRepository(None, self.repository.path, False)

    self.repository.addRemote("origin", formatRemote("http", self.http, otherRepository.path.split('/')[-1]) + "/.git")
    self.generateComplicatedCommit(otherRepository)

    def processEnded(result):
      self.assertNoError()
      self.assertEqual(self.repository, otherRepository)

    self.assertNotEqual(self.repository, otherRepository)

    return self.pullRepository(self.repository).addCallback(processEnded)
    def testHTTPUnauthorizedPush(self):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(
            None, self.repository.path, True)

        self.repository.addRemote(
            "origin",
            formatRemote("http", self.http,
                         remoteRepository.path.split('/')[-1]))
        self.generateComplicatedCommit()

        def processEnded(result):
            self.assertError("You are not allowed to PUSH to second-branch.")
            self.assertNotEqual(self.repository, remoteRepository)

        return self.pushRepository(self.repository).addCallback(processEnded)
    def testSSHUnauthorizedPush(self):
        self.repository.initialize()

        remoteRepository = self.createTemporaryRepository(
            None, self.repository.path, True)

        self.repository.addRemote(
            "origin",
            formatRemote("ssh", self.ssh,
                         remoteRepository.path.split('/')[-1]))
        self.generateComplicatedCommit()

        def processEnded(result):
            self.assertNotSuccess()
            self.assertNotEqual(self.repository, remoteRepository)

        return self.pushRepository(self.repository, "derp",
                                   keyFile="test").addCallback(processEnded)
    def testSSHAuthorizedPull(self):
        self.repository.initialize()

        otherRepository = self.createTemporaryRepository(
            None, self.repository.path, False)

        self.repository.addRemote(
            "origin",
            formatRemote("ssh", self.ssh,
                         otherRepository.path.split('/')[-1]))
        self.generateComplicatedCommit(otherRepository)

        def processEnded(result):
            self.assertNoError()
            self.assertEqual(self.repository, otherRepository)

        self.assertNotEqual(self.repository, otherRepository)

        return self.pullRepository(self.repository,
                                   keyFile="test").addCallback(processEnded)