test_blob: removed many redundant tests that would fail now as the mock cannot handle the complexity of the command backend

All objects but Tree now use the persistent command to read their object information - Trees get binary data and would need their own pretty-printing or they need to parse the data themselves which is my favorite

Author: Byron

lib/git/objects/base.py

@@ -48,9 +48,13 @@ def _set_cache_(self, attr):
 		Retrieve object information
 		"""
 		if attr  == "size":
-			self.size = int(self.repo.git.cat_file(self.id, s=True).rstrip())
+			typename, self.size = self.repo.git.get_object_header(self.id)
+			assert typename == self.type, "Created object whose python type %r disagrees with the acutal git object type %r" % (typename, self.type)
 		elif attr == "data":
-			self.data = self.repo.git.cat_file(self.id, p=True, with_raw_output=True)
+			typename, self.size, self.data = self.repo.git.get_object_data(self.id)
+			assert typename == self.type, "Created object whose python type %r disagrees with the acutal git object type %r" % (typename, self.type)
+		else:
+			super(Object,self)._set_cache_(attr)
 
 	def __eq__(self, other):
 		"""

lib/git/objects/commit.py

@@ -81,7 +81,10 @@ def _set_cache_(self, attr):
 		We set all values at once.
 		"""
 		if attr in Commit.__slots__:
-			temp = Commit.list_items(self.repo, self.id, max_count=1)[0]
+			# prepare our data lines to match rev-list
+			data_lines = self.data.splitlines()
+			data_lines.insert(0, "commit %s" % self.id)
+			temp = self._iter_from_process_or_stream(self.repo, iter(data_lines)).next()
 			self.parents = temp.parents
 			self.tree = temp.tree
 			self.author = temp.author
@@ -147,10 +150,10 @@ def iter_items(cls, repo, ref, path='', **kwargs):
 
 		# the test system might confront us with string values - 
 		proc = repo.git.rev_list(ref, '--', path, **options)
-		return cls._iter_from_process(repo, proc)
+		return cls._iter_from_process_or_stream(repo, proc)
 
 	@classmethod
-	def _iter_from_process(cls, repo, proc):
+	def _iter_from_process_or_stream(cls, repo, proc_or_stream):
 		"""
 		Parse out commit information into a list of Commit objects
 
@@ -163,7 +166,10 @@ def _iter_from_process(cls, repo, proc):
 		Returns
 			iterator returning Commit objects
 		"""
-		stream = proc.stdout
+		stream = proc_or_stream
+		if not hasattr(stream,'next'):
+			stream = proc_or_stream.stdout
+			
 		for line in stream:
 			id = line.split()[1]
 			assert line.split()[0] == "commit"

lib/git/objects/tag.py

@@ -49,8 +49,7 @@ def _set_cache_(self, attr):
 		Cache all our attributes at once
 		"""
 		if attr in TagObject.__slots__:
-			output = self.repo.git.cat_file(self.type,self.id)
-			lines = output.split("\n")
+			lines = self.data.splitlines()
 
 			obj, hexsha = lines[0].split(" ")		# object <hexsha>
 			type_token, type_name = lines[1].split(" ") # type <type_name>

lib/git/refs.py

@@ -38,8 +38,10 @@ def _set_cache_(self, attr):
 		if attr == "object":
 			# have to be dynamic here as we may be a tag which can point to anything
 			# it uses our path to stay dynamic
-			type_string = self.repo.git.cat_file(self.path, t=True).rstrip() 
-			self.object = get_object_type_by_name(type_string)(self.repo, self.path)
+			typename, size = self.repo.git.get_object_header(self.path)
+			# explicitly do not set the size as it may change if the our ref path points 
+			# at some other place when the head changes for instance ... 
+			self.object = get_object_type_by_name(typename)(self.repo, self.path)
 		else:
 			super(Ref, self)._set_cache_(attr)
 
@@ -124,9 +126,14 @@ def _from_string(cls, repo, line):
 			id: [0-9A-Fa-f]{40}
 		Returns git.Head """
 		full_path, hexsha, type_name, object_size = line.split("\x00")
-		obj = get_object_type_by_name(type_name)(repo, hexsha)
-		obj.size = object_size
-		return cls(repo, full_path, obj)
+		
+		# No, we keep the object dynamic by allowing it to be retrieved by
+		# our path on demand - due to perstent commands it is fast
+		return cls(repo, full_path)
+		
+		# obj = get_object_type_by_name(type_name)(repo, hexsha)
+		# obj.size = object_size
+		# return cls(repo, full_path, obj)
 
 
 class Head(Ref):

test/git/test_base.py

@@ -73,6 +73,16 @@ def test_tags(self):
 		assert len(s) == ref_count
 		assert len(s|s) == ref_count
 
+	def test_heads(self):
+		# see how it dynmically updates its object
+		for head in self.repo.heads:
+			head.name
+			head.path
+			cur_obj = head.object
+			del( head.object )
+			assert cur_obj == head.object
+		# END for each head
+		
 	def test_get_object_type_by_name(self):
 		for tname in base.Object.TYPES:
 			assert base.Object in get_object_type_by_name(tname).mro()

test/git/test_blob.py

@@ -12,51 +12,14 @@ class TestBlob(object):
 	def setup(self):
 		self.repo = Repo(GIT_REPO)
 
-	@patch_object(Git, '_call_process')
-	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, 'with_raw_output': True}))
-
-	@patch_object(Git, '_call_process')
-	def test_should_return_blob_contents_with_newline(self, git):
-		git.return_value = fixture('cat_file_blob_nl')
-		blob = Blob(self.repo, **{'id': 'abc'})
-		assert_equal("Hello world\n", blob.data)
-		assert_true(git.called)
-		assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-	
-	@patch_object(Git, '_call_process')
-	def test_should_cache_data(self, git):
-		git.return_value = fixture('cat_file_blob')
-		bid = '787b92b63f629398f3d2ceb20f7f0c2578259e84'
+	def test_should_cache_data(self):
+		bid = 'a802c139d4767c89dcad79d836d05f7004d39aac'
 		blob = Blob(self.repo, bid)
 		blob.data
-		blob.data
-		assert_true(git.called)
-		assert_equal(git.call_count, 1)
-		assert_equal(git.call_args, (('cat_file', bid), {'p': True, 'with_raw_output': True}))
-
-	@patch_object(Git, '_call_process')
-	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, blob.size)
-		assert_true(git.called)
-		assert_equal(git.call_args, (('cat_file', 'abc'), {'s': True}))
-
-	@patch_object(Git, '_call_process')
-	def test_should_cache_file_size(self, git):
-		git.return_value = fixture('cat_file_blob_size')
-		blob = Blob(self.repo, **{'id': 'abc'})
-		assert_equal(11, blob.size)
-		assert_equal(11, blob.size)
-		assert_true(git.called)
-		assert_equal(git.call_count, 1)
-		assert_equal(git.call_args, (('cat_file', 'abc'), {'s': True}))
-  
+		assert blob.data
+		blob.size
+		blob.size
+		
 	def test_mime_type_should_return_mime_type_for_known_types(self):
 		blob = Blob(self.repo, **{'id': 'abc', 'path': 'foo.png'})
 		assert_equal("image/png", blob.mime_type)

test/git/test_commit.py

@@ -204,7 +204,7 @@ def test_rev_list_bisect_all(self, git):
 									  bisect_all=True)
 		assert_true(git.called)
 
-		commits = Commit._iter_from_process(self.repo, ListProcessAdapter(revs))
+		commits = Commit._iter_from_process_or_stream(self.repo, ListProcessAdapter(revs))
 		expected_ids = (
 			'cf37099ea8d1d8c7fbf9b6d12d7ec0249d3acb8b',
 			'33ebe7acec14b25c5f84f35a664803fcab2f7781',

test/git/test_repo.py

@@ -96,16 +96,6 @@ def test_tree(self, git):
 
 		assert_true(git.called)
 
-	@patch_object(Git, '_call_process')
-	def test_blob(self, git):
-		git.return_value = fixture('cat_file_blob')
-
-		blob = Blob(self.repo,"abc")
-		assert_equal("Hello world", blob.data)
-
-		assert_true(git.called)
-		assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-
 	@patch_object(Repo, '__init__')
 	@patch_object(Git, '_call_process')
 	def test_init_bare(self, git, repo):