Merge branch 'index' into improvements

* index:
  Index: Is now diffable and appears to properly implement diffing against other items as well as the working tree
  default index writing now writes the index of the current repository in a fashion comparable to the native implementation
  Added test for ConcurrentWriteOperation
  utils: Added LockFile including test
  Index now behaves more like the default index if no explicit stream is given. It will lazily read its data on first access

3 files changed, 137 insertions, 6 deletions

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 10ffb79d..257acf10 100644
--- a/test/git/test_index.py
+++ b/test/git/test_index.py
@@ -101,4 +101,46 @@ class TestTree(TestBase):
 		# END for each blob
 		assert num_blobs == len(three_way_index.entries)
 	
-	
+	@with_rw_repo('0.1.6')
+	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)
diff --git a/test/git/test_utils.py b/test/git/test_utils.py
index 6852d0ad..029d2054 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,83 @@ 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 _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):
+		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
+		
+		
+		
+