From 3d9e7f1121d3bdbb08291c7164ad622350544a21 Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 22 Oct 2009 18:01:52 +0200 Subject: Index now behaves more like the default index if no explicit stream is given. It will lazily read its data on first access --- test/git/test_index.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'test/git') diff --git a/test/git/test_index.py b/test/git/test_index.py index 10ffb79d..8baf408c 100644 --- a/test/git/test_index.py +++ b/test/git/test_index.py @@ -101,4 +101,7 @@ class TestTree(TestBase): # END for each blob assert num_blobs == len(three_way_index.entries) - + def test_from_index(self): + # default Index instance points to our index + index = Index(self.rorepo) + assert len(index.entries) -- cgit v1.2.3 From 36f838e7977e62284d2928f65cacf29771f1952f Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 22 Oct 2009 19:05:00 +0200 Subject: utils: Added LockFile including test GitConfigFile is now derived from LockFile using its capabilities Implemented ConcurrentWriteOperation, test is yet to be done --- test/git/test_utils.py | 37 ++++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) (limited to 'test/git') diff --git a/test/git/test_utils.py b/test/git/test_utils.py index 6852d0ad..61527758 100644 --- a/test/git/test_utils.py +++ b/test/git/test_utils.py @@ -5,11 +5,15 @@ # the BSD License: http://www.opensource.org/licenses/bsd-license.php import os +import tempfile + from test.testlib import * +from git.utils import * from git import * from git.cmd import dashify -class TestUtils(object): + +class TestUtils(TestCase): def setup(self): self.testdict = { "string": "42", @@ -20,3 +24,34 @@ class TestUtils(object): def test_it_should_dashify(self): assert_equal('this-is-my-argument', dashify('this_is_my_argument')) assert_equal('foo', dashify('foo')) + + + def test_lock_file(self): + my_file = tempfile.mktemp() + lock_file = LockFile(my_file) + assert not lock_file._has_lock() + # release lock we don't have - fine + lock_file._release_lock() + + # get lock + lock_file._obtain_lock_or_raise() + assert lock_file._has_lock() + + # concurrent access + other_lock_file = LockFile(my_file) + assert not other_lock_file._has_lock() + self.failUnlessRaises(IOError, other_lock_file._obtain_lock_or_raise) + + lock_file._release_lock() + assert not lock_file._has_lock() + + other_lock_file._obtain_lock_or_raise() + self.failUnlessRaises(IOError, lock_file._obtain_lock_or_raise) + + # auto-release on destruction + del(other_lock_file) + lock_file._obtain_lock_or_raise() + lock_file._release_lock() + + def test_safe_operation(self): + self.fail("todo") -- cgit v1.2.3 From 7184340f9d826a52b9e72fce8a30b21a7c73d5be Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 22 Oct 2009 19:23:21 +0200 Subject: Added test for ConcurrentWriteOperation --- test/git/test_utils.py | 51 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) (limited to 'test/git') diff --git a/test/git/test_utils.py b/test/git/test_utils.py index 61527758..029d2054 100644 --- a/test/git/test_utils.py +++ b/test/git/test_utils.py @@ -53,5 +53,54 @@ class TestUtils(TestCase): lock_file._obtain_lock_or_raise() lock_file._release_lock() + def _cmp_contents(self, file_path, data): + # raise if data from file at file_path + # does not match data string + fp = open(file_path, "r") + try: + assert fp.read() == data + finally: + fp.close() + def test_safe_operation(self): - self.fail("todo") + my_file = tempfile.mktemp() + orig_data = "hello" + new_data = "world" + my_file_fp = open(my_file, "w") + my_file_fp.write(orig_data) + my_file_fp.close() + + try: + cwrite = ConcurrentWriteOperation(my_file) + + # didn't start writing, doesnt matter + cwrite._end_writing(False) + cwrite._end_writing(True) + assert not cwrite._is_writing() + + # write data and fail + stream = cwrite._begin_writing() + assert cwrite._is_writing() + stream.write(new_data) + cwrite._end_writing(successful=False) + self._cmp_contents(my_file, orig_data) + assert not os.path.exists(stream.name) + + # write data - concurrently + ocwrite = ConcurrentWriteOperation(my_file) + stream = cwrite._begin_writing() + self.failUnlessRaises(IOError, ocwrite._begin_writing) + + stream.write("world") + cwrite._end_writing(successful=True) + self._cmp_contents(my_file, new_data) + assert not os.path.exists(stream.name) + + # could test automatic _end_writing on destruction + finally: + os.remove(my_file) + # END final cleanup + + + + -- cgit v1.2.3 From 1496979cf7e9692ef869d2f99da6141756e08d25 Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 22 Oct 2009 19:43:01 +0200 Subject: default index writing now writes the index of the current repository in a fashion comparable to the native implementation --- test/git/test_index.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'test/git') diff --git a/test/git/test_index.py b/test/git/test_index.py index 8baf408c..5c643a67 100644 --- a/test/git/test_index.py +++ b/test/git/test_index.py @@ -101,7 +101,13 @@ class TestTree(TestBase): # END for each blob assert num_blobs == len(three_way_index.entries) - def test_from_index(self): + @with_rw_repo('0.1.6') + def test_from_index(self, rw_repo): # default Index instance points to our index - index = Index(self.rorepo) + index = Index(rw_repo) assert len(index.entries) + + # write the file back + index.write() + + # could sha it, or check stats -- cgit v1.2.3 From ea33fe8b21d2b02f902b131aba0d14389f2f8715 Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Thu, 22 Oct 2009 22:14:02 +0200 Subject: Index: Is now diffable and appears to properly implement diffing against other items as well as the working tree Diff.Diffable: added callback allowing superclasses to preprocess diff arguments Diff.Diff: added eq, ne and hash methods, string methods would be nice --- test/git/test_diff.py | 13 +++++++++---- test/git/test_index.py | 35 ++++++++++++++++++++++++++++++++++- 2 files changed, 43 insertions(+), 5 deletions(-) (limited to 'test/git') diff --git a/test/git/test_diff.py b/test/git/test_diff.py index d7505987..ead231e5 100644 --- a/test/git/test_diff.py +++ b/test/git/test_diff.py @@ -59,6 +59,14 @@ class TestDiff(TestBase): assertion_map.setdefault(key, 0) assertion_map[key] = assertion_map[key]+len(list(diff_index.iter_change_type(ct))) # END for each changetype + + # check entries + diff_set = set() + diff_set.add(diff_index[0]) + diff_set.add(diff_index[0]) + assert len(diff_set) == 1 + assert diff_index[0] == diff_index[0] + assert not (diff_index[0] != diff_index[0]) # END diff index checking # END for each patch option # END for each path option @@ -71,7 +79,4 @@ class TestDiff(TestBase): for key,value in assertion_map.items(): assert value, "Did not find diff for %s" % key # END for each iteration type - - def test_diff_index_working_tree(self): - self.fail("""Find a good way to diff an index against the working tree -which is not possible with the current interface""") + diff --git a/test/git/test_index.py b/test/git/test_index.py index 5c643a67..257acf10 100644 --- a/test/git/test_index.py +++ b/test/git/test_index.py @@ -102,12 +102,45 @@ class TestTree(TestBase): assert num_blobs == len(three_way_index.entries) @with_rw_repo('0.1.6') - def test_from_index(self, rw_repo): + def test_from_index_and_diff(self, rw_repo): # default Index instance points to our index index = Index(rw_repo) + assert index.path is not None assert len(index.entries) # write the file back index.write() # could sha it, or check stats + + # test diff + # resetting the head will leave the index in a different state, and the + # diff will yield a few changes + cur_head_commit = rw_repo.head.commit + ref = rw_repo.head.reset(rw_repo, 'HEAD~6', index=True, working_tree=False) + + # diff against same index is 0 + diff = index.diff() + assert len(diff) == 0 + + # against HEAD as string, must be the same as it matches index + diff = index.diff('HEAD') + assert len(diff) == 0 + + # against previous head, there must be a difference + diff = index.diff(cur_head_commit) + assert len(diff) + + # we reverse the result + adiff = index.diff(str(cur_head_commit), R=True) + odiff = index.diff(cur_head_commit, R=False) # now its not reversed anymore + assert adiff != odiff + assert odiff == diff # both unreversed diffs against HEAD + + # against working copy - its still at cur_commit + wdiff = index.diff(None) + assert wdiff != adiff + assert wdiff != odiff + + # against something unusual + self.failUnlessRaises(ValueError, index.diff, int) -- cgit v1.2.3