def test_clone_from_bare_repository(self):
bare_repo_name = '%s_bare' % (self.id(),)
bare_repo_path = os.path.join(self.WORKING_DIR, bare_repo_name)
bare_repo = EG.init_repo(bare_repo_path, bare=True)
self.assertEqual(bare_repo.bare, True)
if self.destroy:
self.addCleanup(lambda: shutil.rmtree(bare_repo_path))
cloned_repo_path = '%s_clone' % (bare_repo_path,)
EG.clone_repo(bare_repo_path, cloned_repo_path)
new_workspace = EG.workspace(cloned_repo_path)
if self.destroy:
self.addCleanup(new_workspace.destroy)
# create an initial commit
initial_commit = new_workspace.sm.store_data(
'README.md', '# Hello World', 'Initial commit')
repo = new_workspace.repo
# NOTE: this is a bare remote repo and so it doesn't have a working
# copy checked out, there's nothing on the remote.
[origin] = repo.remotes
origin.push('refs/heads/master:refs/heads/master')
# Now pull in the changes in a remote repo to ensure we've
# succesfully are able to push & pull things around
second_cloned_repo_path = '%s_second_clone' % (bare_repo_path,)
EG.clone_repo(bare_repo_path, second_cloned_repo_path)
second_workspace = EG.workspace(second_cloned_repo_path)
second_workspace.fast_forward()
self.addCleanup(second_workspace.destroy)
[found_commit] = second_workspace.repo.iter_commits()
self.assertEqual(found_commit, initial_commit)
def setUp(self):
self.remote_workspace = self.mk_workspace(
name='%s_remote' % (self.id().lower(),))
# there needs to be an initial commit for diffs to work
index = self.remote_workspace.repo.index
index.commit('Initial Commit')
# cloning ensures initial commit is on both and sets up remote
EG.clone_repo(
repo_url=self.remote_workspace.repo.working_dir,
workdir='.test_repos/%s' % self.id().lower())
self.local_workspace = self.mk_workspace(name=self.id().lower())
self.config = testing.setUp()
self.app = self.mk_app(self.local_workspace)
def clone_repo(self, repo_name, repo_url,
repo_dir='repos', clobber=False, verbose=False):
self.verbose = verbose
workdir = os.path.join(repo_dir, repo_name)
self.emit('Cloning %s to %s.' % (repo_url, workdir))
if os.path.isdir(workdir) and not clobber:
self.emit('Destination already exists, skipping.')
return workdir, EG.read_repo(workdir)
elif os.path.isdir(workdir):
self.emit('Clobbering existing repository.')
shutil.rmtree(workdir)
repo = EG.clone_repo(repo_url, workdir)
return workdir, repo
def test_clone_from(self):
workspace = self.workspace
person = TestPerson({
'age': 1,
'name': 'Test Kees 1'
})
workspace.save(person, 'Saving a person')
clone_source = workspace.working_dir
clone_dest = '%s_clone' % (workspace.working_dir,)
cloned_repo = EG.clone_repo(clone_source, clone_dest)
workspace = EG.workspace(cloned_repo.working_dir)
self.addCleanup(workspace.destroy)
sm = StorageManager(cloned_repo)
[cloned_person] = sm.iterate(TestPerson)
self.assertEqual(person, cloned_person)
def collection_post(self):
storage_path = self.config.get('repo.storage_path')
repo_url = self.request.validated['repo_url']
repo_name = self.request.validated['repo_name']
if not repo_name:
repo_url_info = urlparse(repo_url)
repo_name_dot_git = os.path.basename(repo_url_info.path)
repo_name = repo_name_dot_git.partition('.git')[0]
try:
repo = EG.clone_repo(repo_url,
os.path.join(storage_path, repo_name))
self.request.registry.notify(
RepositoryCloned(config=self.config, repo=repo))
self.request.response.headers['Location'] = self.request.route_url(
'repositoryresource', name=repo_name)
self.request.response.status = 301
return ''
except (GitCommandError, ), e:
self.request.errors.status = 400
self.request.errors.add('body', 'repo_url', e.stderr)
