def test_name(self):
self.assertEqual(
'bar', git_address_util.name('https://foohub.com/myproj/bar.git'))
self.assertEqual('foo-bar-baz',
git_address_util.name('git@git:foo-bar-baz.git'))
r = git_temp_repo(debug=self.DEBUG)
self.assertEqual(path.basename(r.root), git_address_util.name(r.root))
def test_tags(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
tmp_output_file = self.make_temp_file(suffix='.txt')
args = [
'git',
'tags',
'--root-dir',
r.root,
'--output',
tmp_output_file,
'--style',
'brief',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_text_file_equal_fuzzy(
'''\
rel/1.0.0
rel/1.0.1
rel/1.0.2
''', tmp_output_file)
def test_one_script_with_dry_run(self):
r = git_temp_repo(debug = self.DEBUG)
if host.is_windows():
script = self.native_filename('fruits/kiwi.bat')
content = '''\
@echo off
echo {} %*
exit 0
'''.format(script)
elif host.is_unix():
script = self.native_filename('fruits/kiwi.sh')
content = '''\
#!/bin/bash
echo {} ${{1+"$@"}}
exit 0
'''.format(script)
else:
assert False
xp_script = self.native_filename(script)
r.add_file(self.native_filename(xp_script), content, mode = 0o0755)
r.push('origin', 'master')
r.tag('1.0.0')
r.push_tag('1.0.0')
options = git_repo_script_options(dry_run = True)
scripts = [
git_util.script(xp_script, [ 'arg1', 'arg2' ]),
]
rv = git_util.repo_run_scripts(r.address, scripts, options = options)
self.assertEqual( [ None ], rv.results )
def test_bump_tag_component_major_reset_lower(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
'--component', 'major',
'--reset-lower',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '2.0.0', rv.output.strip() )
def test_conflict_retry(self):
# Create a fresh repo with a master branch.
repo = git_temp_repo(debug=self.DEBUG)
repo.add_file('dummy.txt', 'dummy')
repo.push('origin', 'master')
#try_count = []
from conflict_retry_worker import worker
# This test runs numerous threads that all attempt to access the repository
# at the same time. The repository code will only do 10 retries, so if you
# try to do more than 9 jobs or so, updates will start to fail and the test
# will not pass.
num_jobs = 9
jobs = []
for i in range(num_jobs):
p = multiprocessing.Process(target=worker,
args=(i, repo.address, self.DEBUG))
jobs.append(p)
#try_count.append(0)
p.start()
for job in jobs:
job.join()
# Now get the file from the remote into the main thread's local repo and
# check the results.
repo.pull()
contents = repo.read_file('retries.txt')
actual = sorted(contents.split(line_break.DEFAULT_LINE_BREAK))
expected = [str(n) for n in range(num_jobs)]
self.assertEqual(actual, expected)
def test_repo_status(self):
NUM_REPOS = 9
NUM_THREADS = 3
options = git_repo_status_options(num_threads = NUM_THREADS)
repos = []
repo_index_map = {}
for i in range(0, NUM_REPOS):
config = '''\
add commit1 commit1
kiwi{index}.txt: this is kiwi{index}.txt
add commit2 commit2
lemon{index}.txt: this is lemon{index}.txt
'''.format(index = i)
r = git_temp_repo(remote = True, debug = self.DEBUG, config = config, prefix = 'status')
repos.append(r.repo)
repo_index_map[r.repo] = i
for item in git_status_getter.get_status(repos, options = options):
repo = item.repo
status = item.status
index = repo_index_map[repo]
self.assertEqual( 'master', status.active_branch )
self.assertEqual( repo.last_commit_hash(), status.last_commit.commit_hash_long )
self.assertEqual( 'add lemon{index}.txt'.format(index = index), status.last_commit.message )
self.assertEqual( 'unittest', status.last_commit.author )
self.assertEqual( '*****@*****.**', status.last_commit.email )
self.assertEqual( False, status.last_commit.is_merge_commit )
self.assertEqual( ( 0, 0 ), status.branch_status )
def test_delete_tags(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
self.assertEqual(['rel/1.0.0', 'rel/1.0.1', 'rel/1.0.2'],
r.list_local_tags().names())
self.assertEqual(['rel/1.0.0', 'rel/1.0.1', 'rel/1.0.2'],
r.list_remote_tags().names())
args = [
'git',
'delete_tags',
'--root-dir',
r.root,
'rel/1.0.1',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual(['rel/1.0.0', 'rel/1.0.2'],
r.list_local_tags().names())
self.assertEqual(['rel/1.0.0', 'rel/1.0.2'],
r.list_remote_tags().names())
def test_create_git_tgz(self):
content = [
'file a/b/c/foo.txt "foo content" 755',
'file d/e/bar.txt "bar content" 644',
'dir baz "" 700',
]
r = git_temp_repo(content = content, prefix = 'test_archive_', debug = self.DEBUG)
commit = r.last_commit_hash(short_hash = True)
tmp_archive = self.make_temp_file(suffix = '.tgz')
prefix = 'foo-{}'.format(commit)
args = [
'archive',
'create_git',
'--root-dir', r.root,
'--format', 'tgz',
prefix,
commit,
tmp_archive,
]
rv = self.run_program(self._program, args)
self.assertEqual( 0, rv.exit_code )
self.assertEqual( 'tgz', archiver.format_name(tmp_archive) )
expected = [
'{}/a/b/c/foo.txt'.format(prefix),
'{}/d/e/bar.txt'.format(prefix),
]
actual = archiver.members(tmp_archive)
self.assert_filename_list_equal( expected, actual )
def test_basic(self):
# This is the document to write to the repository.
tmp_source_doc = self.make_temp_file(content='abc', suffix='-doc.txt')
# Here's a repository to put it in.
r = git_temp_repo(debug=self.DEBUG)
r.add_file('dummy.txt', content='dummy')
r.push('origin', 'master')
tmp_db_dir = self.make_temp_dir()
args = [
'git_repo_document',
'update',
tmp_source_doc,
r.address,
'master',
'--working-dir',
tmp_db_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
# Also check doc is in repo. It will have the same name as the source doc.
filename = path.basename(tmp_source_doc)
r.pull()
contents = r.read_file(filename)
self.assertEqual(contents, 'abc')
# Since we now have a file in the repo, let's also test whether load_document can read it.
# Here's an auto-delete temp directory for the document DB's local repository.
tmp_db_dir2 = temp_file.make_temp_dir(delete=not self.DEBUG)
# By default, the CLI will put the output file in a file with the same name as the file in
# the repo, in the current directory.
tmp_target_filepath = path.join(getcwd(), filename)
if path.exists(tmp_target_filepath):
remove(tmp_target_filepath)
# Run the CLI.
args = [
'git_repo_document',
'load',
filename,
r.address,
'master',
'--working-dir',
tmp_db_dir2,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
# See if the file and contents are there.
actual = file_util.read(tmp_target_filepath)
self.assertEqual(actual, b'abc')
# This will cause an exception and fail the test if the file wasn't created by the CLI.
remove(tmp_target_filepath)
def test_basic(self):
r = git_temp_repo(debug = self.DEBUG)
r.add_file('kiwi.txt', content = 'this is kiwi.txt', mode = 0o0644)
r.push('origin', 'master')
def _op(repo):
r.add_file('melon.txt', content = 'this is melon.txt', mode = 0o0644,
commit = False, push = False)
git_util.repo_run_operation(r.address, _op, 'add melon.txt', options = None)
self.assertEqual( 'this is melon.txt', r.read_file('melon.txt') )
def test_parse_local_bare(self):
items = [
'file foo.txt "foo.txt"',
]
r = git_temp_repo(remote=True,
content=items,
debug=self.DEBUG,
prefix='.repo')
self.assertEqual(('bare_local', None, None, r.address),
git_remote.parse(r.address))
def _make_repo(self,
remote=True,
content=None,
prefix=None,
commit_message=None):
return git_temp_repo(remote=remote,
content=content,
prefix=prefix,
debug=self.DEBUG,
commit_message=commit_message)
def _make_test_repo(clazz):
repo = git_temp_repo(debug=clazz.DEBUG)
src_dir = path.normpath(
path.join(path.dirname(__file__), '../../../../bes_bash'))
dst_dir = path.join(repo.root, 'bash/bes_bash_one_file')
tar_util.copy_tree(src_dir, dst_dir)
repo.add(['bash'])
repo.commit('add', ['bash'])
repo.push('-u', 'origin', 'master')
return repo
def test_apply_config_text(self):
config = '''\
file something.txt
content: this is my content
it can be multi line
or not
perm: 644
add commit1 commit1
foo.txt: this is a multi line
content
subdir/bar.txt: this is subdir/bar.txt
scripts/go.sh[perm=655]: \\#!/bin/bash
echo hello
exit 0
copy_of_something1.txt: @something.txt
copy_of_something2.txt: @something.txt
message: first commit
tag rel/1.0.0 tag1
from_commit: @commit1
tag rel/1.0.1 tag2
from_commit: @commit1
annotation: first release
branch b1 b1
start_point: @commit1
branch b2 b2
start_point: b1
remove remove1
filename: copy_of_something1.txt
'''
r = git_temp_repo(remote=True)
self.assertEqual([], r.find_all_files())
r.apply_config_text(config)
self.assertEqual(
self.native_filename_list([
'copy_of_something2.txt',
'foo.txt',
'scripts/go.sh',
'subdir/bar.txt',
]), r.find_all_files())
expected = '''\
this is my content
it can be multi line
or not'''
self.assert_text_file_equal(expected,
r.file_path('copy_of_something2.txt'),
codec='utf-8',
native_line_breaks=True)
def test_basic_dry_run(self):
r = git_temp_repo(debug = self.DEBUG)
r.add_file('kiwi.txt', content = 'this is kiwi.txt', mode = 0o0644)
r.push('origin', 'master')
def _op(repo):
r.add_file('melon.txt', content = 'this is melon.txt', mode = 0o0644,
commit = False, push = False)
options = git_repo_operation_options(dry_run = True)
git_util.repo_run_operation(r.address, _op, 'add melon.txt', options = options)
r.pull()
self.assertFalse( r.has_file('melon.txt') )
def test_remote_print(self):
r = git_temp_repo(remote=True)
args = [
'git',
'remote_print',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual(r.address, rv.output.strip())
def test_many_scripts_with_push(self):
r1 = git_temp_repo(debug = self.DEBUG)
if host.is_windows():
script1 = self.native_filename('scripts/script1.bat')
script2 = self.native_filename('scripts/script2.bat')
content1 = '''\
@echo off
echo %1% > color.txt
git add color.txt
git commit -madd color.txt
exit 0
'''
content2 = '''\
@echo off
echo %1% > fruit.txt
git add fruit.txt
git commit -madd fruit.txt
exit 0
'''
elif host.is_unix():
script1 = self.native_filename('scripts/script1.sh')
script2 = self.native_filename('scripts/script2.sh')
content1 = '''\
#!/bin/bash
echo ${1} > color.txt
git add color.txt
git commit -madd color.txt
exit 0
'''
content2 = '''\
#!/bin/bash
echo ${1} > fruit.txt
git add fruit.txt
git commit -madd fruit.txt
exit 0
'''
else:
assert False
r1.add_file(script1, content1, mode = 0o0755)
r1.add_file(script2, content2, mode = 0o0755)
r1.push('origin', 'master')
r1.tag('1.0.0')
r1.push_tag('1.0.0')
scripts = [
git_util.script(script1, [ 'yellow' ]),
git_util.script(script2, [ 'kiwi' ]),
]
options = git_repo_script_options(push = True)
rv = git_util.repo_run_scripts(r1.address, scripts, options = options)
r2 = r1.make_temp_cloned_repo()
self.assertEqual( 'yellow', r2.read_file('color.txt').strip() )
self.assertEqual( 'kiwi', r2.read_file('fruit.txt').strip() )
def test_push_conflict(self):
r1 = git_temp_repo(debug = self.DEBUG)
if host.is_windows():
script = self.native_filename('fruits/kiwi.bat')
content = '''\
@echo off
echo %1 > %1
git add %1
git commit -m"add %1" %1
exit 0
'''
elif host.is_unix():
script = self.native_filename('fruits/kiwi.sh')
content = '''\
#!/bin/bash
echo ${1} > ${1}
git add ${1}
git commit -m"add ${1}" ${1}
exit 0
'''
else:
assert False
xp_script = self.native_filename(script)
r1.add_file(self.native_filename(xp_script), content, mode = 0o0755)
r1.push('origin', 'master')
jobs = []
for fruit in self._FRUITS:
p = multiprocessing.Process(target = self._worker_test_push_conflict, args = ( fruit, r1.address, xp_script ) )
jobs.append(p)
p.start()
for job in jobs:
job.join()
r2 = git_repo(self.make_temp_dir(), address = r1.address)
r2.clone_or_pull()
self.assertEqual( {
xp_script,
'apple',
'blueberry',
'kiwi',
'lemon',
'melon',
'orange',
'papaya',
'pineapple',
'watermelon',
}, set(r2.find_all_files()) )
'''
def test_remote_replace(self):
new_url = git_temp_repo(remote=True, debug=self.DEBUG).address
r = git_temp_repo(remote=True, debug=self.DEBUG)
args = [
'git',
'remote_replace',
'--root-dir',
r.root,
new_url,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git',
'remote_print',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_filename_equal(new_url, rv.output.strip())
def test_the_basics(self):
# Create an empty temporary repo for the test. You've got to add a
# dummy file, otherwise the push won't work and the master branch won't
# be created. add_file does the commit.
repo = git_temp_repo(debug=self.DEBUG)
repo.add_file('dummy.txt', 'dummy')
repo.push('origin', 'master')
tmp_working_dir = self.make_temp_dir()
# Set up the test DB.
db = git_repo_document_db(tmp_working_dir, repo.address, 'master')
# Use the DB to store a change to the file.
db.update_document('testdoc.txt', lambda content: content + 'a\n',
'test commit message')
# Now retrieve what we stored.
content = db.load_document('testdoc.txt')
self.assertEqual(content, 'a\n')
# And check that the file really exists via the repo interface and has the
# content in it. The repo file side effect is part of the contract.
repo.pull()
self.assert_text_file_equal('a',
repo.file_path('testdoc.txt'),
codec='utf-8',
strip=True,
native_line_breaks=True)
# Now modify the file further and retrieve it again.
db.update_document('testdoc.txt', lambda content: content + 'b\n',
'test commit message 2')
expected = '''\
a
b
'''
repo.pull()
self.assert_string_equal(expected,
db.load_document('testdoc.txt'),
strip=True,
native_line_breaks=True)
# Try replacing everything.
db.update_document('testdoc.txt', lambda content: 'foo',
'test commit message 3')
content = db.load_document('testdoc.txt')
self.assertEqual(content, 'foo')
repo.pull()
self.assertEqual('foo', repo.read_file('testdoc.txt'))
def test_simple(self):
r1 = git_temp_repo(debug=self.DEBUG)
r1.add_file('coconut', 'coconut')
r1.push('origin', 'master')
r2 = git_repo(self.make_temp_dir(), address=r1.address)
r2.clone_or_pull()
r2.add_file('kiwi', 'kiwi')
r1.add_file('lemon', 'lemon')
r1.push()
r2.push_with_rebase()
r3 = git_repo(self.make_temp_dir(), address=r1.address)
r3.clone_or_pull()
self.assertEqual(['coconut', 'kiwi', 'lemon'], r3.find_all_files())
def xtest_list_dir_persistent(self):
items = [
'file foo.txt "foo.txt"',
]
r = git_temp_repo(remote = True, content = items, debug = self.DEBUG, prefix = '.repo')
config_dir1 = self.make_temp_dir(suffix = '.config.dir')
fs = vfs_git_repo(r.address, config_dir1, False)
t = vfs_tester(fs)
self.assertEqual( 'foo.txt file 7 ddab29ff2c393ee52855d21a240eb05f775df88e3ce347df759f0c4b80356c35\n',
t.list_dir('/', False, tester.OPTIONS) )
r.add_file('bar.txt', 'bar.txt')
r.push()
config_dir2 = self.make_temp_dir(suffix = '.config.dir')
fs = vfs_git_repo(r.address, config_dir2, False)
t = vfs_tester(fs)
expected = '''\
bar.txt file 7 08bd2d247cc7aa38b8c4b7fd20ee7edad0b593c3debce92f595c9d016da40bae
foo.txt file 7 ddab29ff2c393ee52855d21a240eb05f775df88e3ce347df759f0c4b80356c35
'''
self.assertEqual( expected, t.list_dir('/', False, tester.OPTIONS) )
def test_tag(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
self.assertEqual('1.0.0', r.greatest_local_tag().name)
args = [
'git',
'tag',
'--root-dir',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assert_string_equal_fuzzy('''\
local: 1.0.0
remote: 1.0.0
''', rv.output)
def test_greatest_tag(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/1.0.2 tag3 @commit3
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( 'rel/1.0.2', rv.output.strip() )
def test_bump_tag_with_prefix(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag rel/v2/1.0.0 tag1 @commit1
add commit2 commit2
lemon.txt: lemon.txt
tag rel/v2/1.0.1 tag2 @commit2
add commit3 commit3
melon.txt: melon.txt
tag rel/v2/1.0.2 tag3 @commit3
add commit4 commit4
potato.txt: potato.txt
tag test/v3/1.0.0 tag4 @commit4
tag test/v3/1.0.1 tag5 @commit4
'''
r = git_temp_repo(remote=True, config=config, debug=self.DEBUG)
args = [
'git',
'bump_tag',
'--root-dir',
r.root,
'--component',
'revision',
'--prefix',
'rel/v2/',
]
self.assertEqual('rel/v2/1.0.2',
r.greatest_local_tag(prefix='rel/v2/').name)
self.assertEqual('test/v3/1.0.1',
r.greatest_local_tag(prefix='test/v3/').name)
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual('rel/v2/1.0.3',
r.greatest_local_tag(prefix='rel/v2/').name)
self.assertEqual('test/v3/1.0.1',
r.greatest_local_tag(prefix='test/v3/').name)
def test_one_script_with_bump_tag(self):
r1 = git_temp_repo(debug = self.DEBUG)
if host.is_windows():
script = 'nothing.bat'
content = '''\
@echo off
exit 0
'''.format(script)
elif host.is_unix():
script = './nothing.sh'
content = '''\
#!/bin/bash
exit 0
'''.format(script)
else:
assert False
xp_script = self.native_filename(script)
r1.add_file(xp_script, content, mode = 0o0755)
r1.push('origin', 'master')
r1.tag('1.0.0')
r1.push_tag('1.0.0')
options = git_repo_script_options(bump_tag_component = 'revision')
scripts = [
git_util.script(xp_script, []),
]
rv = git_util.repo_run_scripts(r1.address, scripts, options = options)
self.assertEqual( 1, len(rv.results) )
r2 = r1.make_temp_cloned_repo()
self.assertEqual( '1.0.1', r2.greatest_local_tag().name )
options = git_repo_script_options(bump_tag_component = 'major')
scripts = [
git_util.script(xp_script, []),
]
rv = git_util.repo_run_scripts(r1.address, scripts, options = options)
self.assertEqual( 1, len(rv.results) )
self.assertEqual( '2.0.1', r2.greatest_remote_tag().name )
def test_bump_tag(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.0 tag1 @commit1
'''
r = git_temp_repo(remote = True, debug = self.DEBUG)
r.apply_config_text(config)
args = [
'git_repo',
'bump_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
args = [
'git_repo',
'greatest_tag',
r.root,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
self.assertEqual( '1.0.1', rv.output.strip() )
def test_sync(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
push origin master
'''
r1 = git_temp_repo(remote = True, debug = self.DEBUG)
r1.apply_config_text(config)
tmp_dir = self.make_temp_dir(suffix = '-tmp-sync-dir')
args = [
'git_repo',
'sync',
r1.address,
tmp_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2 = git_repo(tmp_dir)
self.assertEqual( '1.0.1', r2.greatest_local_tag().name )
self.assertEqual( [
'kiwi.txt',
], r2.find_all_files() )
def test_bump_tag_major(self):
'Just a smoke test bes.git has more test cases for bump_tag'
content = [
'file foo.txt "this is foo.txt" 644',
'file bar.txt "this is bar.txt" 644',
]
r1 = git_temp_repo(content=content, debug=self.DEBUG)
r2 = r1.make_temp_cloned_repo()
self.assertEqual(None, r1.greatest_local_tag())
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'revision',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('1.0.0', r2.greatest_local_tag().name)
args = [
'git',
'bump_tag',
'--root-dir',
r1.root,
'--component',
'major',
'--reset-lower',
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2.pull()
self.assertEqual('2.0.0', r2.greatest_local_tag().name)
def test_many_concurrent(self):
'''
Create a bunch of processes trying to push to the same repo simulataneously.
This creates git locking issues and exercises the safe_push retry code.
'''
r1 = git_temp_repo(debug=self.DEBUG)
initial_content = self._make_content('coconut')
r1.add_file('coconut', initial_content)
r1.push('origin', 'master')
jobs = []
for fruit in self._FRUITS:
p = multiprocessing.Process(
target=self._test_many_concurrent_worker,
args=(self.__class__, fruit, r1.address))
jobs.append(p)
p.start()
for job in jobs:
job.join()
r2 = git_repo(self.make_temp_dir(), address=r1.address)
r2.clone_or_pull()
self.assertEqual([
'apple',
'blueberry',
'coconut',
'kiwi',
'lemon',
'melon',
'orange',
'papaya',
'pineapple',
'watermelon',
], r2.find_all_files())
