initial project

12 files changed, 824 insertions, 0 deletions

diff --git a/test/git/__init__.py b/test/git/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/test/git/__init__.py
diff --git a/test/git/test_actor.py b/test/git/test_actor.py
new file mode 100644
index 00000000..f045926d
--- /dev/null
+++ b/test/git/test_actor.py
@@ -0,0 +1,23 @@
+import os
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestActor(object):
+    def test_from_string_should_separate_name_and_email(self):
+        a = Actor.from_string("Michael Trier <mtrier@example.com>")
+        assert_equal("Michael Trier", a.name)
+        assert_equal("mtrier@example.com", a.email)
+
+    def test_from_string_should_handle_just_name(self):
+        a = Actor.from_string("Michael Trier")
+        assert_equal("Michael Trier", a.name)
+        assert_equal(None, a.email)
+
+    def test_should_display_representation(self):
+        a = Actor.from_string("Michael Trier <mtrier@example.com>")
+        assert_equal('<GitPython.Actor "Michael Trier <mtrier@example.com>">', repr(a))
+
+    def test_str_should_alias_name(self):
+        a = Actor.from_string("Michael Trier <mtrier@example.com>")
+        assert_equal(a.name, str(a))
\ No newline at end of file
diff --git a/test/git/test_blob.py b/test/git/test_blob.py
new file mode 100644
index 00000000..7091136b
--- /dev/null
+++ b/test/git/test_blob.py
@@ -0,0 +1,67 @@
+import time
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestBlob(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+    
+    @patch(Git, 'method_missing')
+    def test_should_return_blob_contents(self, git):
+        git.return_value = fixture('cat_file_blob')
+        blob = Blob(self.repo, **{'id': 'abc'})
+        assert_equal("Hello world", blob.data)
+        assert_true(git.called)
+        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True}))
+    
+    @patch(Git, 'method_missing')
+    def test_should_cache_data(self, git):
+        git.return_value = fixture('cat_file_blob')
+        blob = Blob(self.repo, **{'id': 'abc'})
+        blob.data
+        blob.data
+        assert_true(git.called)
+        assert_equal(git.call_count, 1)
+        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True}))
+
+    @patch(Git, 'method_missing')
+    def test_should_return_file_size(self, git):
+        git.return_value = fixture('cat_file_blob_size')
+        blob = Blob(self.repo, **{'id': 'abc'})
+        assert_equal(11, len(blob))
+        assert_true(git.called)
+        assert_equal(git.call_args, (('cat_file', 'abc'), {'s': True}))
+  
+    def test_mime_type_should_return_mime_type_for_known_types(self):
+        blob = Blob(self.repo, **{'id': 'abc', 'name': 'foo.png'})
+        assert_equal("image/png", blob.mime_type)
+  
+    def test_mime_type_should_return_text_plain_for_unknown_types(self):
+        blob = Blob(self.repo, **{'id': 'abc'})
+        assert_equal("text/plain", blob.mime_type)
+  
+    @patch(Git, 'method_missing')
+    def test_should_display_blame_information(self, git):
+        git.return_value = fixture('blame')
+        b = Blob.blame(self.repo, 'master', 'lib/git.py')
+        assert_equal(13, len(b))
+        # 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(git.call_args, (('blame', 'master', '--', 'lib/git.py'), {'p': True}))
+        
+        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', c.id)
+        assert_equal('Tom Preston-Werner', c.author.name)
+        assert_equal('tom@mojombo.com', c.author.email)
+        assert_equal(time.gmtime(1191997100), c.authored_date)
+        assert_equal('Tom Preston-Werner', c.committer.name)
+        assert_equal('tom@mojombo.com', c.committer.email)
+        assert_equal(time.gmtime(1191997100), c.committed_date)
+        assert_equal('initial grit setup', c.message)
+  
+    def test_should_return_appropriate_representation(self):
+        blob = Blob(self.repo, **{'id': 'abc'})
+        assert_equal('<GitPython.Blob "abc">', repr(blob))
diff --git a/test/git/test_commit.py b/test/git/test_commit.py
new file mode 100644
index 00000000..d47c37ff
--- /dev/null
+++ b/test/git/test_commit.py
@@ -0,0 +1,191 @@
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestCommit(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+
+    @patch(Git, 'method_missing')
+    def test_bake(self, git):
+        git.return_value = fixture('rev_list_single')
+        
+        commit = Commit(self.repo, **{'id': '4c8124ffcf4039d292442eeccabdeca5af5c5017'})
+        commit.author # bake
+        
+        assert_equal("Tom Preston-Werner", commit.author.name)
+        assert_equal("tom@mojombo.com", commit.author.email)
+ 
+        assert_true(git.called)
+        assert_equal(git.call_args, (('rev_list', '4c8124ffcf4039d292442eeccabdeca5af5c5017'), {'pretty': 'raw', 'max_count': 1}))
+
+    @patch(Git, 'method_missing')
+    def test_id_abbrev(self, git):
+        git.return_value = fixture('rev_list_commit_idabbrev')
+        assert_equal('80f136f', self.repo.commit('80f136f500dfdb8c3e8abf4ae716f875f0a1b57f').id_abbrev)
+
+    @patch(Git, 'method_missing')
+    def test_diff(self, git):
+        git.return_value = fixture('diff_p')
+        
+        diffs = Commit.diff(self.repo, 'master')
+        
+        assert_equal(15, len(diffs))
+        
+        assert_equal('.gitignore', diffs[0].a_path)
+        assert_equal('.gitignore', diffs[0].b_path)
+        assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diffs[0].a_commit.id)
+        assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diffs[0].b_commit.id)
+        assert_equal('100644', diffs[0].b_mode)
+        assert_equal(False, diffs[0].new_file)
+        assert_equal(False, diffs[0].deleted_file)
+        assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diffs[0].diff)
+        
+        assert_equal('lib/grit/actor.rb', diffs[5].a_path)
+        assert_equal(None, diffs[5].a_commit)
+        assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diffs[5].b_commit.id)
+        assert_equal(True, diffs[5].new_file)
+
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', 'master'), {'full_index': True}))
+
+    @patch(Git, 'method_missing')
+    def test_diff_with_two_commits(self, git):
+        git.return_value = fixture('diff_2')
+        
+        diffs = Commit.diff(self.repo, '59ddc32', '13d27d5')
+        
+        assert_equal(3, len(diffs))
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', '59ddc32', '13d27d5', '--', 'master'), {'full_index': True}))
+
+    @patch(Git, 'method_missing')  
+    def test_diff_with_files(self, git):
+        git.return_value = fixture('diff_f')
+        
+        diffs = Commit.diff(self.repo, '59ddc32', ['lib'])
+        
+        assert_equal(1, len(diffs))
+        assert_equal('lib/grit/diff.rb', diffs[0].a_path)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', '59ddc32', '--', 'lib'), {'full_index': True}))
+  
+    @patch(Git, 'method_missing')  
+    def test_diff_with_two_commits_and_files(self, git):
+        git.return_value = fixture('diff_2f')
+        
+        diffs = Commit.diff(self.repo, '59ddc32', '13d27d5', ['lib'])
+    
+        assert_equal(1, len(diffs))
+        assert_equal('lib/grit/commit.rb', diffs[0].a_path)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', '59ddc32', '13d27d5', '--', 'lib'), {'full_index': True}))
+
+    @patch(Git, 'method_missing')
+    def test_diffs(self, git):
+        git.return_value = fixture('diff_p')
+                
+        commit = Commit(self.repo, id='91169e1f5fa4de2eaea3f176461f5dc784796769', parents=['038af8c329ef7c1bae4568b98bd5c58510465493'])
+        diffs = commit.diffs
+        
+        assert_equal(15, len(diffs))
+        
+        assert_equal('.gitignore', diffs[0].a_path)
+        assert_equal('.gitignore', diffs[0].b_path)
+        assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diffs[0].a_commit.id)
+        assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diffs[0].b_commit.id)
+        assert_equal('100644', diffs[0].b_mode)
+        assert_equal(False, diffs[0].new_file)
+        assert_equal(False, diffs[0].deleted_file)
+        assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diffs[0].diff)
+        
+        assert_equal('lib/grit/actor.rb', diffs[5].a_path)
+        assert_equal(None, diffs[5].a_commit)
+        assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diffs[5].b_commit.id)
+        assert_equal(True, diffs[5].new_file)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', '038af8c329ef7c1bae4568b98bd5c58510465493', 
+                                              '91169e1f5fa4de2eaea3f176461f5dc784796769', 
+                                              '--', '59ddc32', '13d27d5', '--', 'master'), {'full_index': True}))        
+
+    @patch(Git, 'method_missing')  
+    def test_diffs_on_initial_import(self, git):
+        git.return_value = fixture('diff_i')
+        
+        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
+        commit.__bake_it__()
+        diffs = commit.diffs
+        
+        assert_equal(10, len(diffs))
+        
+        assert_equal('History.txt', diffs[0].a_path)
+        assert_equal('History.txt', diffs[0].b_path)
+        assert_equal(None, diffs[0].a_commit)
+        assert_equal(None, diffs[0].b_mode)
+        assert_equal('81d2c27608b352814cbe979a6acd678d30219678', diffs[0].b_commit.id)
+        assert_equal(True, diffs[0].new_file)
+        assert_equal(False, diffs[0].deleted_file)
+        assert_equal("--- /dev/null\n+++ b/History.txt\n@@ -0,0 +1,5 @@\n+== 1.0.0 / 2007-10-09\n+\n+* 1 major enhancement\n+  * Birthday!\n+", diffs[0].diff)
+        
+        assert_equal('lib/grit.rb', diffs[5].a_path)
+        assert_equal(None, diffs[5].a_commit)
+        assert_equal('32cec87d1e78946a827ddf6a8776be4d81dcf1d1', diffs[5].b_commit.id)
+        assert_equal(True, diffs[5].new_file)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('show', '634396b2f541a9f2d58b00be1a07f0c358b999b3'), {'full_index': True, 'pretty': 'raw'}))
+  
+    @patch(Git, 'method_missing')  
+    def test_diffs_on_initial_import_with_empty_commit(self, git):
+        git.return_value = fixture('show_empty_commit')
+        
+        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
+        diffs = commit.diffs
+        
+        assert_equal([], diffs)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('show', '634396b2f541a9f2d58b00be1a07f0c358b999b3'), {'full_index': True, 'pretty': 'raw'}))
+  
+    @patch(Git, 'method_missing')  
+    def test_diffs_with_mode_only_change(self, git):
+        git.return_value = fixture('diff_mode_only')
+        
+        commit = Commit(self.repo, id='91169e1f5fa4de2eaea3f176461f5dc784796769')
+        commit.__bake_it__()
+        diffs = commit.diffs
+        
+        assert_equal(23, len(diffs))
+        assert_equal('100644', diffs[0].a_mode)
+        assert_equal('100755', diffs[0].b_mode)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('show', '91169e1f5fa4de2eaea3f176461f5dc784796769'), {'full_index': True, 'pretty': 'raw'}))
+
+    @patch(Git, 'method_missing')  
+    def test_stats(self, git):
+        git.return_value = fixture('diff_numstat')
+        
+        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
+        commit.__bake_it__()
+        stats = commit.stats
+        
+        keys = stats.files.keys()
+        keys.sort()
+        assert_equal(["a.txt", "b.txt"], keys)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', '634396b2f541a9f2d58b00be1a07f0c358b999b3'), {'numstat': True}))
+  
+    def test_str(self):
+        commit = Commit(self.repo, id='abc')
+        assert_equal ("abc", str(commit))
+  
+    def test_repr(self):
+        commit = Commit(self.repo, id='abc')
+        assert_equal('<GitPython.Commit "abc">', repr(commit))
diff --git a/test/git/test_diff.py b/test/git/test_diff.py
new file mode 100644
index 00000000..4c1fa7fb
--- /dev/null
+++ b/test/git/test_diff.py
@@ -0,0 +1,13 @@
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestDiff(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+    
+    def test_list_from_string_new_mode(self):
+        output = fixture('diff_new_mode')
+        diffs = Diff.list_from_string(self.repo, output)
+        assert_equal(1, len(diffs))
+        assert_equal(10, len(diffs[0].diff.splitlines()))
diff --git a/test/git/test_git.py b/test/git/test_git.py
new file mode 100644
index 00000000..dc6f067e
--- /dev/null
+++ b/test/git/test_git.py
@@ -0,0 +1,49 @@
+import os
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestGit(object):
+    def setup(self):
+        base = os.path.join(os.path.dirname(__file__), "../.."),
+        self.git = Git(base)
+        self.git_bin_base = "%s --git-dir=%s" % (Git.git_binary, base)
+
+    @patch(Git, 'execute')
+    def test_method_missing_calls_execute(self, git):
+        git.return_value = ''
+        self.git.version()
+        assert_true(git.called)
+        # assert_equal(git.call_args, ((("%s version " % self.git_bin_base),), {}))
+    
+    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}))
+        
+        assert_equal(["-s", "-t"], self.git.transform_kwargs(**{'s': True, 't': True}))
+
+    def test_it_executes_git_to_shell_and_returns_result(self):
+        assert_match('^git version [\d\.]*$', self.git.execute("%s version" % Git.git_binary))
+
+    def test_it_transforms_kwargs_shell_escapes_arguments(self):
+        assert_equal(["--foo=\"bazz'er\""], self.git.transform_kwargs(**{'foo': "bazz'er"}))
+        assert_equal(["-x \"bazz'er\""], self.git.transform_kwargs(**{'x': "bazz'er"}))
+
+    @patch(Git, 'execute')
+    def test_it_really_shell_escapes_arguments_to_the_git_shell_1(self, git):
+        self.git.foo(**{'bar': "bazz'er"})
+        assert_true(git.called)
+        assert_equal(git.call_args, ((("%s foo --bar=\"bazz'er\"" % self.git_bin_base),), {}))
+
+    @patch(Git, 'execute')
+    def test_it_really_shell_escapes_arguments_to_the_git_shell_2(self, git):
+        self.git.bar(**{'x': "quu'x"})
+        assert_true(git.called)
+        assert_equal(git.call_args, ((("%s bar -x \"quu'x\"" % self.git_bin_base),), {}))
+
+    def test_it_shell_escapes_the_standalone_argument(self):
+        self.git.foo("bar's", {})
diff --git a/test/git/test_head.py b/test/git/test_head.py
new file mode 100644
index 00000000..38b2a5ab
--- /dev/null
+++ b/test/git/test_head.py
@@ -0,0 +1,19 @@
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestHead(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+
+    @patch(Git, 'method_missing')  
+    def test_repr(self, git):
+        git.return_value = fixture('for_each_ref')
+        
+        head = self.repo.heads[0]
+        
+        assert_equal('<GitPython.Head "%s">' % head.name, repr(head))
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('for_each_ref', 'refs/heads'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
diff --git a/test/git/test_repo.py b/test/git/test_repo.py
new file mode 100644
index 00000000..d7a2f271
--- /dev/null
+++ b/test/git/test_repo.py
@@ -0,0 +1,309 @@
+import os
+import time
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestRepo(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+    
+    @raises(InvalidGitRepositoryError)
+    def test_new_should_raise_on_invalid_repo_location(self):
+        Repo("/tmp")
+
+    @raises(NoSuchPathError)
+    def test_new_should_raise_on_non_existant_path(self):
+        Repo("/foobar")
+
+    def test_description(self):
+        assert_equal("Unnamed repository; edit this file to name it for gitweb.", self.repo.description)
+
+    def test_heads_should_return_array_of_head_objects(self):
+        for head in self.repo.heads:
+            assert_equal(Head, head.__class__)
+
+    @patch(Git, 'method_missing')
+    def test_heads_should_populate_head_data(self, git):
+        # Git.any_instance.expects(:for_each_ref).returns(fixture('for_each_ref'))
+        git.return_value = fixture('for_each_ref')
+        
+        head = self.repo.heads[0]
+        assert_equal('master', head.name)
+        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', head.commit.id)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('for_each_ref', 'refs/heads'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+
+    @patch(Git, 'method_missing')  
+    def test_commits(self, git):
+        # Git.any_instance.expects(:rev_list).returns(fixture('rev_list'))
+        git.return_value = fixture('rev_list')
+        
+        commits = self.repo.commits('master', 10)
+    
+        c = commits[0]
+        assert_equal('4c8124ffcf4039d292442eeccabdeca5af5c5017', c.id)
+        assert_equal(["634396b2f541a9f2d58b00be1a07f0c358b999b3"], [p.id for p in c.parents])
+        assert_equal("672eca9b7f9e09c22dcb128c283e8c3c8d7697a4", c.tree.id)
+        assert_equal("Tom Preston-Werner", c.author.name)
+        assert_equal("tom@mojombo.com", c.author.email)
+        assert_equal(time.gmtime(1191999972), c.authored_date)
+        assert_equal("Tom Preston-Werner", c.committer.name)
+        assert_equal("tom@mojombo.com", c.committer.email)
+        assert_equal(time.gmtime(1191999972), c.committed_date)
+        assert_equal("implement Grit#heads", c.message)
+        
+        c = commits[1]
+        assert_equal([], c.parents)
+        
+        c = commits[2]
+        assert_equal(["6e64c55896aabb9a7d8e9f8f296f426d21a78c2c", "7f874954efb9ba35210445be456c74e037ba6af2"], map(lambda p: p.id, c.parents))
+        assert_equal("Merge branch 'site'", c.message)
+
+        assert_true(git.called)
+        assert_equal(git.call_args, (('rev_list',), {}))
+
+    @patch(Git, 'method_missing')
+    def test_commit_count(self, git):
+        # Git.any_instance.expects(:rev_list).with({}, 'master').returns(fixture('rev_list_count'))
+        git.return_value = fixture('rev_list_count')
+        
+        assert_equal(655, self.repo.commit_count('master'))
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('rev_list', 'master'), {}))
+  
+    def test_commit(self):
+        commit = self.repo.commit('634396b2f541a9f2d58b00be1a07f0c358b999b3')
+        
+        assert_equal("634396b2f541a9f2d58b00be1a07f0c358b999b3", commit.id)
+  
+    @patch(Git, 'method_missing')
+    def test_tree(self, git):
+        # Git.any_instance.expects(:ls_tree).returns(fixture('ls_tree_a'))
+        git.return_value = fixture('ls_tree_a')
+        
+        tree = self.repo.tree('master')
+        
+        assert_equal(4, len([c for c in tree.contents if isinstance(c, Blob)]))
+        assert_equal(3, len([c for c in tree.contents if isinstance(c, Tree)]))
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
+
+    @patch(Git, 'method_missing')
+    def test_blob(self, git):
+        # Git.any_instance.expects(:cat_file).returns(fixture('cat_file_blob'))
+        git.return_value = fixture('cat_file_blob')
+        
+        blob = self.repo.blob("abc")
+        assert_equal("Hello world", blob.data)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True}))
+
+    @patch(Repo, '__init__')
+    @patch(Git, 'method_missing')
+    def test_init_bare(self, repo, git):
+        # Git.any_instance.expects(:init).returns(true)
+        # Repo.expects(:new).with("/foo/bar.git")
+        git.return_value = True
+        
+        Repo.init_bare("/foo/bar.git")
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('init',), {}))
+        assert_true(repo.called)
+        assert_equal(repo.call_args, (('/foo/bar.git',), {}))
+
+    @patch(Repo, '__init__')
+    @patch(Git, 'method_missing')
+    def test_init_bare_with_options(self, repo, git):
+        # Git.any_instance.expects(:init).with(
+        # :template => "/baz/sweet").returns(true)
+        # Repo.expects(:new).with("/foo/bar.git")
+        git.return_value = True
+        
+        Repo.init_bare("/foo/bar.git", **{'template': "/baz/sweet"})
+
+        assert_true(git.called)
+        assert_equal(git.call_args, (('init',), {'template': '/baz/sweet'}))
+        assert_true(repo.called)
+        assert_equal(repo.call_args, (('/foo/bar.git',), {}))
+
+    @patch(Repo, '__init__')
+    @patch(Git, 'method_missing')
+    def test_fork_bare(self, repo, git):
+        # Git.any_instance.expects(:clone).with(
+        #           {:bare => true, :shared => false}, 
+        #           "#{absolute_project_path}/.git",
+        #           "/foo/bar.git").returns(nil)
+        # Repo.expects(:new)
+        git.return_value = None
+        
+        self.repo.fork_bare("/foo/bar.git")
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('clone', '%s/.git' % absolute_project_path(), '/foo/bar.git'), {'bare': True, 'shared': False}))
+        assert_true(repo.called)
+
+    @patch(Repo, '__init__')
+    @patch(Git, 'method_missing')
+    def test_fork_bare_with_options(self, repo, git):
+        # Git.any_instance.expects(:clone).with(
+        #       {:bare => true, :shared => false, :template => '/awesome'}, 
+        #       "#{absolute_project_path}/.git",
+        #       "/foo/bar.git").returns(nil)
+        #     Repo.expects(:new)
+        git.return_value = None
+        
+        self.repo.fork_bare("/foo/bar.git", **{'template': '/awesome'})
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('clone', '%s/.git' % absolute_project_path(), '/foo/bar.git'), 
+                                      {'bare': True, 'shared': False, 'template': '/awesome'}))
+        assert_true(repo.called)
+
+    @patch(Git, 'method_missing')
+    def test_diff(self, git):
+        # Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--')
+        self.repo.diff('master^', 'master')
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', 'master^', 'master', '--'), {}))
+
+        # Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--', 'foo/bar')
+        self.repo.diff('master^', 'master', 'foo/bar')
+
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar'), {}))
+        
+        # Git.any_instance.expects(:diff).with({}, 'master^', 'master', '--', 'foo/bar', 'foo/baz')
+        self.repo.diff('master^', 'master', 'foo/bar', 'foo/baz')
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar', 'foo/baz'), {}))
+
+    @patch(Git, 'method_missing')
+    def test_diff(self, git):
+        # Git.any_instance.expects(:diff).returns(fixture('diff_p'))
+        git.return_value = fixture('diff_p')
+        
+        diffs = self.repo.commit_diff('master')
+        assert_equal(15, len(diffs))
+        assert_true(git.called)
+
+    def test_archive_tar(self):
+        self.repo.archive_tar
+  
+    def test_archive_tar_gz(self):
+        self.repo.archive_tar_gz
+
+    @patch('gitalicious.lib.utils', 'touch')
+    def test_enable_daemon_serve(self, touch):
+        # FileUtils.expects(:touch).with(File.join(self.repo.path, '.git', 'git-daemon-export-ok'))
+        self.repo.enable_daemon_serve
+
+    def test_disable_daemon_serve(self):
+        # FileUtils.expects(:rm_f).with(File.join(self.repo.path, '.git', 'git-daemon-export-ok'))
+        self.repo.disable_daemon_serve  
+  
+    @patch(os.path, 'exists')
+    @patch('__builtin__', 'open')
+    def test_alternates_with_two_alternates(self, exists, read):
+        # File.expects(:exist?).with("#{absolute_project_path}/.git/objects/info/alternates").returns(true)
+        # File.expects(:read).returns("/path/to/repo1/.git/objects\n/path/to/repo2.git/objects\n")        
+        exists.return_value = True
+        read.return_value = ("/path/to/repo1/.git/objects\n/path/to/repo2.git/objects\n")
+        
+        assert_equal(["/path/to/repo1/.git/objects", "/path/to/repo2.git/objects"], self.repo.alternates)
+        
+        assert_true(exists.called)
+        assert_true(read.called)
+
+    @patch(os.path, 'exists')
+    def test_alternates_no_file(self, os):
+        os.return_value = False
+        # File.expects(:exist?).returns(false)
+        assert_equal([], self.repo.alternates)
+        
+        assert_true(os.called)
+        
+    @patch(os.path, 'exists')
+    def test_alternates_setter_ok(self, os):
+        os.return_value = True
+        alts = ['/path/to/repo.git/objects', '/path/to/repo2.git/objects']
+        
+        # File.any_instance.expects(:write).with(alts.join("\n"))
+        
+        self.repo.alternates = alts
+        
+        assert_true(os.called)
+        # assert_equal(os.call_args, ((alts,), {}))
+        # for alt in alts:
+            
+    @patch(os.path, 'exists')
+    @raises(NoSuchPathError)
+    def test_alternates_setter_bad(self, os):
+        os.return_value = False
+        
+        alts = ['/path/to/repo.git/objects']
+        # File.any_instance.expects(:write).never
+        self.repo.alternates = alts
+        
+        for alt in alts:
+            assert_true(os.called)
+            assert_equal(os.call_args, (alt, {}))
+    
+    @patch(os, 'remove')
+    def test_alternates_setter_empty(self, os):
+        self.repo.alternates = []
+        assert_true(os.called)
+
+    def test_inspect(self):
+        assert_equal('<GitPython.Repo "%s/.git">' % os.path.abspath(GIT_REPO), repr(self.repo))
+
+    @patch(Git, 'method_missing')
+    def test_log(self, git):
+        git.return_value = fixture('rev_list')
+        assert_equal('4c8124ffcf4039d292442eeccabdeca5af5c5017', self.repo.log()[0].id)
+        assert_equal('ab25fd8483882c3bda8a458ad2965d2248654335', self.repo.log()[-1].id)
+        assert_true(git.called)
+        assert_equal(git.call_count, 2)
+        assert_equal(git.call_args, (('log', 'master'), {'pretty': 'raw'}))
+
+    @patch(Git, 'method_missing')
+    def test_log_with_path_and_options(self, git):
+        git.return_value = fixture('rev_list')
+        self.repo.log('master', 'file.rb', **{'max_count': 1})
+        assert_true(git.called)
+        assert_equal(git.call_args, (('log', 'master', '--', 'file.rb'), {'pretty': 'raw', 'max_count': 1}))
+
+    @patch(Git, 'method_missing')
+    @patch(Git, 'method_missing')
+    def test_commit_deltas_from_nothing_new(self, gitb, gita):
+        gitb.return_value = fixture("rev_list_delta_b")
+        gita.return_value = fixture("rev_list_delta_a")
+        other_repo = Repo(GIT_REPO)
+        # self.repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_b"))
+        # other_repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_a"))
+        
+        delta_commits = self.repo.commit_deltas_from(other_repo)
+        assert_equal(0, len(delta_commits))
+        assert_true(gitb.called)
+        assert_equal(gitb.call_args, (('rev_list', 'master'), {}))
+        assert_true(gita.called)
+        assert_equal(gita.call_args, (('rev_list', 'master'), {}))
+  
+    def test_commit_deltas_from_when_other_has_new(self):
+        other_repo = Repo(GIT_REPO)
+        # self.repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_a"))
+        # other_repo.git.expects(:rev_list).with({}, "master").returns(fixture("rev_list_delta_b"))
+        # for ref in ['4c8124ffcf4039d292442eeccabdeca5af5c5017',
+        #             '634396b2f541a9f2d58b00be1a07f0c358b999b3',
+        #             'ab25fd8483882c3bda8a458ad2965d2248654335']:
+        #     Commit.expects(:find_all).with(other_repo, ref, :max_count => 1).returns([stub()])
+        delta_commits = self.repo.commit_deltas_from(other_repo)
+        assert_equal(3, len(delta_commits))
diff --git a/test/git/test_stats.py b/test/git/test_stats.py
new file mode 100644
index 00000000..b095b47e
--- /dev/null
+++ b/test/git/test_stats.py
@@ -0,0 +1,22 @@
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestStats(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+    
+    def test_list_from_string(self):
+        output = fixture('diff_numstat')
+        stats = Stats.list_from_string(self.repo, 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'])
diff --git a/test/git/test_tag.py b/test/git/test_tag.py
new file mode 100644
index 00000000..15b5bbbe
--- /dev/null
+++ b/test/git/test_tag.py
@@ -0,0 +1,31 @@
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestTag(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+
+    @patch(Git, 'method_missing')
+    def test_list_from_string(self, git):
+        git.return_value = fixture('for_each_ref_tags')
+        
+        tags = self.repo.tags
+        
+        assert_equal(1, len(tags))
+        assert_equal('v0.7.1', tags[0].name)
+        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', tags[0].commit.id)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('for_each_ref', 'refs/tags'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+
+    @patch(Git, 'method_missing')
+    def test_repr(self, git):
+        git.return_value = fixture('for_each_ref')
+        
+        tag = self.repo.tags[0]
+        assert_equal('<GitPython.Tag "%s">' % tag.name, repr(tag))
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('for_each_ref', 'refs/tags'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
diff --git a/test/git/test_tree.py b/test/git/test_tree.py
new file mode 100644
index 00000000..3812f213
--- /dev/null
+++ b/test/git/test_tree.py
@@ -0,0 +1,83 @@
+from mock import *
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestTree(object):
+    def setup(self):
+        self.repo = Repo(GIT_REPO)
+        self.tree = Tree(self.repo)
+
+    @patch(Git, 'method_missing')
+    def test_contents_should_cache(self, git):
+        git.return_value = fixture('ls_tree_a') + fixture('ls_tree_b')
+    
+        tree = self.repo.tree('master')
+
+        child = tree.contents[-1]
+        child.contents
+        child.contents
+        
+        assert_true(git.called)
+        assert_equal(2, git.call_count)
+        assert_equal(git.call_args, (('ls_tree', '34868e6e7384cb5ee51c543a8187fdff2675b5a7'), {}))
+  
+    def test_content_from_string_tree_should_return_tree(self):
+        text = fixture('ls_tree_a').splitlines()[-1]
+        tree = self.tree.content_from_string(None, text)
+
+        assert_equal(Tree, tree.__class__)
+        assert_equal("650fa3f0c17f1edb4ae53d8dcca4ac59d86e6c44", tree.id)
+        assert_equal("040000", tree.mode)
+        assert_equal("test", tree.name)
+  
+    def test_content_from_string_tree_should_return_blob(self):
+        text = fixture('ls_tree_b').split("\n")[0]
+        
+        tree = self.tree.content_from_string(None, text)
+
+        assert_equal(Blob, tree.__class__)
+        assert_equal("aa94e396335d2957ca92606f909e53e7beaf3fbb", tree.id)
+        assert_equal("100644", tree.mode)
+        assert_equal("grit.rb", tree.name)
+  
+    def test_content_from_string_tree_should_return_commit(self):
+        text = fixture('ls_tree_commit').split("\n")[1]
+    
+        tree = self.tree.content_from_string(None, text)
+        assert_none(tree)
+    
+    @raises(TypeError)
+    def test_content_from_string_invalid_type_should_raise(self):
+        self.tree.content_from_string(None, "040000 bogus 650fa3f0c17f1edb4ae53d8dcca4ac59d86e6c44	test")
+
+    @patch(Blob, '__len__')
+    @patch(Git, 'method_missing')
+    def test_slash(self, blob, git):
+        git.return_value = fixture('ls_tree_a')
+        blob.return_value = 1
+        
+        tree = self.repo.tree('master')
+        
+        assert_equal('aa06ba24b4e3f463b3c4a85469d0fb9e5b421cf8', (tree/'lib').id)
+        assert_equal('8b1e02c0fb554eed2ce2ef737a68bb369d7527df', (tree/'README.txt').id)
+        
+        assert_true(git.called)
+        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
+  
+    @patch(Git, 'method_missing')
+    def test_slash_with_commits(self, git):
+        git.return_value = fixture('ls_tree_commit')
+
+        tree = self.repo.tree('master')
+    
+        assert_none(tree/'bar')
+        assert_equal('2afb47bcedf21663580d5e6d2f406f08f3f65f19', (tree/'foo').id)
+        assert_equal('f623ee576a09ca491c4a27e48c0dfe04be5f4a2e', (tree/'baz').id)
+
+        assert_true(git.called)
+        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
+
+    def test_repr(self):
+        self.tree = Tree(self.repo, **{'id': 'abc'})
+        assert_equal('<GitPython.Tree "abc">', repr(self.tree))
diff --git a/test/git/test_utils.py b/test/git/test_utils.py
new file mode 100644
index 00000000..2147e4cb
--- /dev/null
+++ b/test/git/test_utils.py
@@ -0,0 +1,17 @@
+import os
+from gitalicious.test.asserts import *
+from gitalicious.lib import *
+from gitalicious.test.helper import *
+
+class TestUtils(object):
+    def setup(self):
+        base = os.path.join(os.path.dirname(__file__), "../.."),
+        self.git = Git(base)
+        self.git_bin_base = "%s --git-dir='%s'" % (Git.git_binary, base)
+
+    def test_it_escapes_single_quotes_with_shell_escape(self):
+        assert_equal("\\\\'foo", shell_escape("'foo"))
+
+    def test_it_should_dashify(self):
+        assert_equal('this-is-my-argument', dashify('this_is_my_argument'))
+        assert_equal('foo', dashify('foo'))