def test_list_from_string_new_mode(self):
output = StringProcessAdapter(fixture('diff_new_mode'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
assert_equal(10, len(diffs[0].diff.splitlines()))
def test_diff_with_change_in_type(self):
output = StringProcessAdapter(fixture('diff_change_in_type'))
diffs = Diff._index_from_patch_format(self.rorepo, output)
self._assert_diff_format(diffs)
assert_equal(2, len(diffs))
diff = diffs[0]
self.assertIsNotNone(diff.deleted_file)
assert_equal(diff.a_path, 'this')
assert_equal(diff.b_path, 'this')
assert isinstance(str(diff), str)
diff = diffs[1]
assert_equal(diff.a_path, None)
assert_equal(diff.b_path, 'this')
self.assertIsNotNone(diff.new_file)
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_change_in_type_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output)
self.assertEqual(len(diffs), 1)
diff = diffs[0]
self.assertEqual(diff.rename_from, None)
self.assertEqual(diff.rename_to, None)
self.assertEqual(diff.change_type, 'T')
self.assertEqual(len(list(diffs.iter_change_type('T'))), 1)
def test_call_unpack_args(self):
args = Git._Git__unpack_args(["git", "log", "--", u"Unicode€™"])
if PY3:
mangled_value = "Unicode\u20ac\u2122"
else:
mangled_value = "Unicode\xe2\x82\xac\xe2\x84\xa2"
assert_equal(args, ["git", "log", "--", mangled_value])
def test_clone_from_keeps_env(self, rw_dir):
original_repo = Repo.init(osp.join(rw_dir, "repo"))
environment = {"entry1": "value", "another_entry": "10"}
cloned = Repo.clone_from(original_repo.git_dir, osp.join(rw_dir, "clone"), env=environment)
assert_equal(environment, cloned.git.environment())
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed_file)
assert_true(diff.renamed)
assert_equal(diff.rename_from, u'Jérôme')
assert_equal(diff.rename_to, u'müller')
assert_equal(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
assert_equal(diff.raw_rename_to, b'm\xc3\xbcller')
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output)
self.assertEqual(len(diffs), 1)
diff = diffs[0]
self.assertIsNotNone(diff.renamed_file)
self.assertIsNotNone(diff.renamed)
self.assertEqual(diff.rename_from, 'this')
self.assertEqual(diff.rename_to, 'that')
self.assertEqual(diff.change_type, 'R')
self.assertEqual(diff.score, 100)
self.assertEqual(len(list(diffs.iter_change_type('R'))), 1)
def test_clone_from_keeps_env(self, rw_dir):
original_repo = Repo.init(osp.join(rw_dir, "repo"))
environment = {"entry1": "value", "another_entry": "10"}
cloned = Repo.clone_from(original_repo.git_dir, osp.join(rw_dir, "clone"), env=environment)
assert_equal(environment, cloned.git.environment())
def test_diff_with_change_in_type(self):
output = StringProcessAdapter(fixture('diff_change_in_type'))
diffs = Diff._index_from_patch_format(self.rorepo, output)
self._assert_diff_format(diffs)
assert_equal(2, len(diffs))
diff = diffs[0]
self.assertIsNotNone(diff.deleted_file)
assert_equal(diff.a_path, 'this')
assert_equal(diff.b_path, 'this')
assert isinstance(str(diff), str)
diff = diffs[1]
assert_equal(diff.a_path, None)
assert_equal(diff.b_path, 'this')
self.assertIsNotNone(diff.new_file)
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_change_in_type_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output)
self.assertEqual(len(diffs), 1)
diff = diffs[0]
self.assertEqual(diff.rename_from, None)
self.assertEqual(diff.rename_to, None)
self.assertEqual(diff.change_type, 'T')
self.assertEqual(len(list(diffs.iter_change_type('T'))), 1)
def test_list_from_string_new_mode(self):
output = StringProcessAdapter(fixture('diff_new_mode'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
assert_equal(8, len(diffs[0].diff.splitlines()))
def test_call_unpack_args(self):
args = Git._Git__unpack_args(['git', 'log', '--', u'Unicode€™'])
if PY3:
mangled_value = 'Unicode\u20ac\u2122'
else:
mangled_value = 'Unicode\xe2\x82\xac\xe2\x84\xa2'
assert_equal(args, ['git', 'log', '--', mangled_value])
def test_call_unpack_args_unicode(self):
args = Git._Git__unpack_args(u'Unicode€™')
if PY3:
mangled_value = 'Unicode\u20ac\u2122'
else:
mangled_value = 'Unicode\xe2\x82\xac\xe2\x84\xa2'
assert_equal(args, [mangled_value])
def test_call_unpack_args_unicode(self):
args = Git._Git__unpack_args(u'Unicode€™')
if PY3:
mangled_value = 'Unicode\u20ac\u2122'
else:
mangled_value = 'Unicode\xe2\x82\xac\xe2\x84\xa2'
assert_equal(args, [mangled_value])
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed_file)
assert_true(diff.renamed)
assert_equal(diff.rename_from, u'Jérôme')
assert_equal(diff.rename_to, u'müller')
assert_equal(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
assert_equal(diff.raw_rename_to, b'm\xc3\xbcller')
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output)
self.assertEqual(len(diffs), 1)
diff = diffs[0]
self.assertIsNotNone(diff.renamed_file)
self.assertIsNotNone(diff.renamed)
self.assertEqual(diff.rename_from, 'this')
self.assertEqual(diff.rename_to, 'that')
self.assertEqual(diff.change_type, 'R')
self.assertEqual(diff.score, 100)
self.assertEqual(len(list(diffs.iter_change_type('R'))), 1)
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed_file)
assert_true(diff.renamed)
assert_equal(diff.rename_from, u'Jérôme')
assert_equal(diff.rename_to, u'müller')
assert_equal(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
assert_equal(diff.raw_rename_to, b'm\xc3\xbcller')
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output.stdout)
assert len(diffs) == 1
diff = diffs[0]
assert diff.renamed_file
assert diff.renamed
assert diff.rename_from == 'this'
assert diff.rename_to == 'that'
assert len(list(diffs.iter_change_type('R'))) == 1
def test_call_unpack_args(self):
args = Git._Git__unpack_args(['git', 'log', '--', u'Unicode€™'])
if PY3:
mangled_value = 'Unicode\u20ac\u2122'
else:
mangled_value = 'Unicode\xe2\x82\xac\xe2\x84\xa2'
assert_equal(args, ['git', 'log', '--', mangled_value])
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed_file)
assert_true(diff.renamed)
assert_equal(diff.rename_from, u'Jérôme')
assert_equal(diff.rename_to, u'müller')
assert_equal(diff.raw_rename_from, b'J\xc3\xa9r\xc3\xb4me')
assert_equal(diff.raw_rename_to, b'm\xc3\xbcller')
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output.stdout)
assert len(diffs) == 1
diff = diffs[0]
assert diff.renamed_file
assert diff.renamed
assert diff.rename_from == 'this'
assert diff.rename_to == 'that'
assert len(list(diffs.iter_change_type('R'))) == 1
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
assert_equal(["--max-count"], self.git.transform_kwargs(**{'max_count': True}))
assert_equal(["--max-count=5"], self.git.transform_kwargs(**{'max_count': 5}))
assert_equal(["-s", "-t"], self.git.transform_kwargs(**{'s': True, 't': True}))
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
assert_equal(["--max-count"], self.git.transform_kwargs(**{'max_count': True}))
assert_equal(["--max-count=5"], self.git.transform_kwargs(**{'max_count': 5}))
assert_equal(["-s", "-t"], self.git.transform_kwargs(**{'s': True, 't': True}))
def test_from_string_should_separate_name_and_email(self):
a = Actor._from_string("Michael Trier <*****@*****.**>")
assert_equal("Michael Trier", a.name)
assert_equal("*****@*****.**", a.email)
# base type capabilities
assert a == a
assert not (a != a)
m = set()
m.add(a)
m.add(a)
assert len(m) == 1
def test_from_string_should_separate_name_and_email(self):
a = Actor._from_string("Michael Trier <*****@*****.**>")
assert_equal("Michael Trier", a.name)
assert_equal("*****@*****.**", a.email)
# base type capabilities
assert a == a
assert not (a != a)
m = set()
m.add(a)
m.add(a)
assert len(m) == 1
def test_bake(self):
commit = self.rorepo.commit('2454ae89983a4496a445ce347d7a41c0bb0ea7ae')
# commits have no dict
self.failUnlessRaises(AttributeError, setattr, commit, 'someattr', 1)
commit.author # bake
assert_equal("Sebastian Thiel", commit.author.name)
assert_equal("*****@*****.**", commit.author.email)
assert commit.author == commit.committer
assert isinstance(commit.authored_date, int) and isinstance(commit.committed_date, int)
assert isinstance(commit.author_tz_offset, int) and isinstance(commit.committer_tz_offset, int)
assert commit.message == "Added missing information to docstrings of commit and stats module\n"
def test_it_accepts_environment_variables(self):
filename = fixture_path("ls_tree_empty")
with open(filename, 'r') as fh:
tree = self.git.mktree(istream=fh)
env = {
'GIT_AUTHOR_NAME': 'Author Name',
'GIT_AUTHOR_EMAIL': '*****@*****.**',
'GIT_AUTHOR_DATE': '1400000000+0000',
'GIT_COMMITTER_NAME': 'Committer Name',
'GIT_COMMITTER_EMAIL': '*****@*****.**',
'GIT_COMMITTER_DATE': '1500000000+0000',
}
commit = self.git.commit_tree(tree, m='message', env=env)
assert_equal(commit, '4cfd6b0314682d5a58f80be39850bad1640e9241')
def test_it_accepts_environment_variables(self):
filename = fixture_path("ls_tree_empty")
with open(filename, 'r') as fh:
tree = self.git.mktree(istream=fh)
env = {
'GIT_AUTHOR_NAME': 'Author Name',
'GIT_AUTHOR_EMAIL': '*****@*****.**',
'GIT_AUTHOR_DATE': '1400000000+0000',
'GIT_COMMITTER_NAME': 'Committer Name',
'GIT_COMMITTER_EMAIL': '*****@*****.**',
'GIT_COMMITTER_DATE': '1500000000+0000',
}
commit = self.git.commit_tree(tree, m='message', env=env)
assert_equal(commit, '4cfd6b0314682d5a58f80be39850bad1640e9241')
def test_multi_line_config(self):
file_obj = self._to_memcache(fixture_path("git_config_with_comments"))
config = GitConfigParser(file_obj, read_only=False)
ev = "ruby -e '\n"
ev += " system %(git), %(merge-file), %(--marker-size=%L), %(%A), %(%O), %(%B)\n"
ev += " b = File.read(%(%A))\n"
ev += " b.sub!(/^<+ .*\\nActiveRecord::Schema\\.define.:version => (\\d+). do\\n=+\\nActiveRecord::Schema\\."
ev += "define.:version => (\\d+). do\\n>+ .*/) do\n"
ev += " %(ActiveRecord::Schema.define(:version => #{[$1, $2].max}) do)\n"
ev += " end\n"
ev += " File.open(%(%A), %(w)) {|f| f.write(b)}\n"
ev += " exit 1 if b.include?(%(<)*%L)'"
assert_equal(config.get('merge "railsschema"', 'driver'), ev)
assert_equal(config.get('alias', 'lg'),
"log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset'"
" --abbrev-commit --date=relative")
assert len(config.sections()) == 23
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
assert_equal(["--max-count"], self.git.transform_kwargs(**{'max_count': True}))
assert_equal(["--max-count=5"], self.git.transform_kwargs(**{'max_count': 5}))
# order is undefined
res = self.git.transform_kwargs(**{'s': True, 't': True})
assert ['-s', '-t'] == res or ['-t', '-s'] == res
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{"s": True}))
assert_equal(["-s5"], self.git.transform_kwargs(**{"s": 5}))
assert_equal(["--max-count"], self.git.transform_kwargs(**{"max_count": True}))
assert_equal(["--max-count=5"], self.git.transform_kwargs(**{"max_count": 5}))
# order is undefined
res = self.git.transform_kwargs(**{"s": True, "t": True})
assert ["-s", "-t"] == res or ["-t", "-s"] == res
def test_rev_list_bisect_all(self):
"""
'git rev-list --bisect-all' returns additional information
in the commit header. This test ensures that we properly parse it.
"""
revs = self.rorepo.git.rev_list('933d23bf95a5bd1624fbcdf328d904e1fa173474',
first_parent=True,
bisect_all=True)
commits = Commit._iter_from_process_or_stream(self.rorepo, StringProcessAdapter(revs.encode('ascii')))
expected_ids = (
'7156cece3c49544abb6bf7a0c218eb36646fad6d',
'1f66cfbbce58b4b552b041707a12d437cc5f400a',
'33ebe7acec14b25c5f84f35a664803fcab2f7781',
'933d23bf95a5bd1624fbcdf328d904e1fa173474'
)
for sha1, commit in zip(expected_ids, commits):
assert_equal(sha1, commit.hexsha)
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
assert_equal(["--max-count"],
self.git.transform_kwargs(**{'max_count': True}))
assert_equal(["--max-count=5"],
self.git.transform_kwargs(**{'max_count': 5}))
# order is undefined
res = self.git.transform_kwargs(**{'s': True, 't': True})
assert ['-s', '-t'] == res or ['-t', '-s'] == res
def test_diff_with_copied_file(self):
output = StringProcessAdapter(fixture('diff_copied_mode'))
diffs = Diff._index_from_patch_format(self.rorepo, output)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.copied_file)
assert_true(diff.a_path, u'test1.txt')
assert_true(diff.b_path, u'test2.txt')
assert isinstance(str(diff), str)
output = StringProcessAdapter(fixture('diff_copied_mode_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output)
self.assertEqual(len(diffs), 1)
diff = diffs[0]
self.assertEqual(diff.change_type, 'C')
self.assertEqual(diff.score, 100)
self.assertEqual(diff.a_path, u'test1.txt')
self.assertEqual(diff.b_path, u'test2.txt')
self.assertEqual(len(list(diffs.iter_change_type('C'))), 1)
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed)
assert_equal(diff.rename_from, 'AUTHORS')
assert_equal(diff.rename_to, 'CONTRIBUTORS')
def test_diff_with_rename(self):
output = StringProcessAdapter(fixture('diff_rename'))
diffs = Diff._index_from_patch_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
assert_equal(1, len(diffs))
diff = diffs[0]
assert_true(diff.renamed)
assert_equal(diff.rename_from, 'AUTHORS')
assert_equal(diff.rename_to, 'CONTRIBUTORS')
def test_diff_with_rename_raw(self):
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
diffs = filter(lambda d: d.renamed, diffs)
assert_equal(3, len(diffs))
diff = diffs[0]
assert_true(diff.renamed)
assert_equal(diff.rename_from, 'git/test/test_reflog.py')
assert_equal(diff.rename_to, 'git/test/refs/test_reflog.py')
def test_diff_with_rename_raw(self):
output = StringProcessAdapter(fixture('diff_rename_raw'))
diffs = Diff._index_from_raw_format(self.rorepo, output.stdout)
self._assert_diff_format(diffs)
diffs = filter(lambda d: d.renamed, diffs)
assert_equal(3, len(diffs))
diff = diffs[0]
assert_true(diff.renamed)
assert_equal(diff.rename_from, 'git/test/test_reflog.py')
assert_equal(diff.rename_to, 'git/test/refs/test_reflog.py')
def assert_commit_serialization(rwrepo,
commit_id,
print_performance_info=False):
"""traverse all commits in the history of commit identified by commit_id and check
if the serialization works.
:param print_performance_info: if True, we will show how fast we are"""
ns = 0 # num serializations
nds = 0 # num deserializations
st = time.time()
for cm in rwrepo.commit(commit_id).traverse():
nds += 1
# assert that we deserialize commits correctly, hence we get the same
# sha on serialization
stream = BytesIO()
cm._serialize(stream)
ns += 1
streamlen = stream.tell()
stream.seek(0)
istream = rwrepo.odb.store(IStream(Commit.type, streamlen, stream))
assert_equal(istream.hexsha, cm.hexsha.encode('ascii'))
nc = Commit(rwrepo, Commit.NULL_BIN_SHA, cm.tree, cm.author,
cm.authored_date, cm.author_tz_offset, cm.committer,
cm.committed_date, cm.committer_tz_offset, cm.message,
cm.parents, cm.encoding)
assert_equal(nc.parents, cm.parents)
stream = BytesIO()
nc._serialize(stream)
ns += 1
streamlen = stream.tell()
stream.seek(0)
# reuse istream
istream.size = streamlen
istream.stream = stream
istream.binsha = None
nc.binsha = rwrepo.odb.store(istream).binsha
# if it worked, we have exactly the same contents !
assert_equal(nc.hexsha, cm.hexsha)
# END check commits
elapsed = time.time() - st
if print_performance_info:
print(
"Serialized %i and deserialized %i commits in %f s ( (%f, %f) commits / s"
% (ns, nds, elapsed, ns / elapsed, nds / elapsed),
file=sys.stderr)
def test_clone_from_pathlib_withConfig(self, rw_dir):
if pathlib is None: # pythons bellow 3.4 don't have pathlib
raise SkipTest("pathlib was introduced in 3.4")
original_repo = Repo.init(osp.join(rw_dir, "repo"))
cloned = Repo.clone_from(original_repo.git_dir, pathlib.Path(rw_dir) / "clone_pathlib_withConfig",
multi_options=["--recurse-submodules=repo",
"--config core.filemode=false",
"--config submodule.repo.update=checkout"])
assert_equal(cloned.config_reader().get_value('submodule', 'active'), 'repo')
assert_equal(cloned.config_reader().get_value('core', 'filemode'), False)
assert_equal(cloned.config_reader().get_value('submodule "repo"', 'update'), 'checkout')
def assert_commit_serialization(rwrepo, commit_id, print_performance_info=False):
"""traverse all commits in the history of commit identified by commit_id and check
if the serialization works.
:param print_performance_info: if True, we will show how fast we are"""
ns = 0 # num serializations
nds = 0 # num deserializations
st = time.time()
for cm in rwrepo.commit(commit_id).traverse():
nds += 1
# assert that we deserialize commits correctly, hence we get the same
# sha on serialization
stream = BytesIO()
cm._serialize(stream)
ns += 1
streamlen = stream.tell()
stream.seek(0)
istream = rwrepo.odb.store(IStream(Commit.type, streamlen, stream))
assert_equal(istream.hexsha, cm.hexsha.encode('ascii'))
nc = Commit(rwrepo, Commit.NULL_BIN_SHA, cm.tree,
cm.author, cm.authored_date, cm.author_tz_offset,
cm.committer, cm.committed_date, cm.committer_tz_offset,
cm.message, cm.parents, cm.encoding)
assert_equal(nc.parents, cm.parents)
stream = BytesIO()
nc._serialize(stream)
ns += 1
streamlen = stream.tell()
stream.seek(0)
# reuse istream
istream.size = streamlen
istream.stream = stream
istream.binsha = None
nc.binsha = rwrepo.odb.store(istream).binsha
# if it worked, we have exactly the same contents !
assert_equal(nc.hexsha, cm.hexsha)
# END check commits
elapsed = time.time() - st
if print_performance_info:
print("Serialized %i and deserialized %i commits in %f s ( (%f, %f) commits / s"
% (ns, nds, elapsed, ns / elapsed, nds / elapsed), file=sys.stderr)
def test_description(self):
txt = "Test repository"
self.rorepo.description = txt
assert_equal(self.rorepo.description, txt)
def test_call_process_calls_execute(self, git):
git.return_value = ''
self.git.version()
assert_true(git.called)
assert_equal(git.call_args, ((['git', 'version'], ), {}))
def test_commits(self):
mc = 10
commits = list(self.rorepo.iter_commits('0.1.6', max_count=mc))
self.assertEqual(len(commits), mc)
c = commits[0]
assert_equal('9a4b1d4d11eee3c5362a4152216376e634bd14cf', c.hexsha)
assert_equal(["c76852d0bff115720af3f27acdb084c59361e5f6"],
[p.hexsha for p in c.parents])
assert_equal("ce41fc29549042f1aa09cc03174896cf23f112e3", c.tree.hexsha)
assert_equal("Michael Trier", c.author.name)
assert_equal("*****@*****.**", c.author.email)
assert_equal(1232829715, c.authored_date)
assert_equal(5 * 3600, c.author_tz_offset)
assert_equal("Michael Trier", c.committer.name)
assert_equal("*****@*****.**", c.committer.email)
assert_equal(1232829715, c.committed_date)
assert_equal(5 * 3600, c.committer_tz_offset)
assert_equal("Bumped version 0.1.6\n", c.message)
c = commits[1]
self.assertIsInstance(c.parents, tuple)
def test_should_display_blame_information(self, git):
git.return_value = fixture('blame')
b = self.rorepo.blame('master', 'lib/git.py')
assert_equal(13, len(b))
assert_equal(2, len(b[0]))
# assert_equal(25, reduce(lambda acc, x: acc + len(x[-1]), b))
assert_equal(hash(b[0][0]), hash(b[9][0]))
c = b[0][0]
assert_true(git.called)
assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', c.hexsha)
assert_equal('Tom Preston-Werner', c.author.name)
assert_equal('*****@*****.**', c.author.email)
assert_equal(1191997100, c.authored_date)
assert_equal('Tom Preston-Werner', c.committer.name)
assert_equal('*****@*****.**', c.committer.email)
assert_equal(1191997100, c.committed_date)
self.assertRaisesRegexp(
ValueError, "634396b2f541a9f2d58b00be1a07f0c358b999b3 missing",
lambda: c.message)
# test the 'lines per commit' entries
tlist = b[0][1]
assert_true(tlist)
assert_true(isinstance(tlist[0], string_types))
assert_true(
len(tlist) < sum(len(t)
for t in tlist)) # test for single-char bug
# BINARY BLAME
git.return_value = fixture('blame_binary')
blames = self.rorepo.blame('master', 'rps')
self.assertEqual(len(blames), 2)
def test_heads_should_return_array_of_head_objects(self):
for head in self.rorepo.heads:
assert_equal(Head, head.__class__)
def test_heads_should_return_array_of_head_objects(self):
for head in self.rorepo.heads:
assert_equal(Head, head.__class__)
def test_repr(self):
commit = Commit(self.rorepo, Commit.NULL_BIN_SHA)
assert_equal('<git.Commit "%s">' % Commit.NULL_HEX_SHA, repr(commit))
def test_it_transforms_kwargs_into_git_command_arguments(self):
assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
assert_equal(["-s", "5"], self.git.transform_kwargs(**{'s': 5}))
assert_equal(["--max-count"],
self.git.transform_kwargs(**{'max_count': True}))
assert_equal(["--max-count=5"],
self.git.transform_kwargs(**{'max_count': 5}))
# Multiple args are supported by using lists/tuples
assert_equal(["-L", "1-3", "-L", "12-18"],
self.git.transform_kwargs(**{'L': ('1-3', '12-18')}))
assert_equal(["-C", "-C"],
self.git.transform_kwargs(**{'C': [True, True]}))
# order is undefined
res = self.git.transform_kwargs(**{'s': True, 't': True})
self.assertEqual(set(['-s', '-t']), set(res))
def test_commits(self):
mc = 10
commits = list(self.rorepo.iter_commits('0.1.6', max_count=mc))
assert len(commits) == mc
c = commits[0]
assert_equal('9a4b1d4d11eee3c5362a4152216376e634bd14cf', c.hexsha)
assert_equal(["c76852d0bff115720af3f27acdb084c59361e5f6"], [p.hexsha for p in c.parents])
assert_equal("ce41fc29549042f1aa09cc03174896cf23f112e3", c.tree.hexsha)
assert_equal("Michael Trier", c.author.name)
assert_equal("*****@*****.**", c.author.email)
assert_equal(1232829715, c.authored_date)
assert_equal(5 * 3600, c.author_tz_offset)
assert_equal("Michael Trier", c.committer.name)
assert_equal("*****@*****.**", c.committer.email)
assert_equal(1232829715, c.committed_date)
assert_equal(5 * 3600, c.committer_tz_offset)
assert_equal("Bumped version 0.1.6\n", c.message)
c = commits[1]
assert isinstance(c.parents, tuple)
def test_str(self):
commit = Commit(self.rorepo, Commit.NULL_BIN_SHA)
assert_equal(Commit.NULL_HEX_SHA, str(commit))
def test_should_display_blame_information(self, git):
git.return_value = fixture('blame')
b = self.rorepo.blame('master', 'lib/git.py')
assert_equal(13, len(b))
assert_equal(2, len(b[0]))
# assert_equal(25, reduce(lambda acc, x: acc + len(x[-1]), b))
assert_equal(hash(b[0][0]), hash(b[9][0]))
c = b[0][0]
assert_true(git.called)
assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', c.hexsha)
assert_equal('Tom Preston-Werner', c.author.name)
assert_equal('*****@*****.**', c.author.email)
assert_equal(1191997100, c.authored_date)
assert_equal('Tom Preston-Werner', c.committer.name)
assert_equal('*****@*****.**', c.committer.email)
assert_equal(1191997100, c.committed_date)
assert_equal('initial grit setup', c.message)
# test the 'lines per commit' entries
tlist = b[0][1]
assert_true(tlist)
assert_true(isinstance(tlist[0], string_types))
assert_true(len(tlist) < sum(len(t) for t in tlist)) # test for single-char bug
# BINARY BLAME
git.return_value = fixture('blame_binary')
blames = self.rorepo.blame('master', 'rps')
assert len(blames) == 2
def test_description(self):
txt = "Test repository"
self.rorepo.description = txt
assert_equal(self.rorepo.description, txt)
def test_it_accepts_stdin(self):
filename = fixture_path("cat_file_blob")
fh = open(filename, 'r')
assert_equal("70c379b63ffa0795fdbfbc128e5a2818397b7ef8",
self.git.hash_object(istream=fh, stdin=True))
fh.close()
def test_it_should_dashify(self):
assert_equal('this-is-my-argument', dashify('this_is_my_argument'))
assert_equal('foo', dashify('foo'))
def test_equality(self):
commit1 = Commit(self.rorepo, Commit.NULL_BIN_SHA)
commit2 = Commit(self.rorepo, Commit.NULL_BIN_SHA)
commit3 = Commit(self.rorepo, "\1" * 20)
assert_equal(commit1, commit2)
assert_not_equal(commit2, commit3)
def test__list_from_string(self):
output = fixture('diff_numstat')
stats = Stats._list_from_string(self.rorepo, output)
assert_equal(2, stats.total['files'])
assert_equal(52, stats.total['lines'])
assert_equal(29, stats.total['insertions'])
assert_equal(23, stats.total['deletions'])
assert_equal(29, stats.files["a.txt"]['insertions'])
assert_equal(18, stats.files["a.txt"]['deletions'])
assert_equal(0, stats.files["b.txt"]['insertions'])
assert_equal(5, stats.files["b.txt"]['deletions'])
def test_call_unpack_args(self):
args = Git._Git__unpack_args(['git', 'log', '--', u'Unicode' + unichr(40960)])
assert_equal(args, ['git', 'log', '--', 'Unicode\xea\x80\x80'])
def test_it_accepts_stdin(self):
filename = fixture_path("cat_file_blob")
with open(filename, 'r') as fh:
assert_equal("70c379b63ffa0795fdbfbc128e5a2818397b7ef8",
self.git.hash_object(istream=fh, stdin=True))
def test_call_process_calls_execute(self, git):
git.return_value = ''
self.git.version()
assert_true(git.called)
assert_equal(git.call_args, ((['git', 'version'],), {}))
