Updated objects to use the ones defined in gitdb as basis. Only the submodule implementation is left in git-python as it requires some advanced features. No tests where run yet

4 files changed, 989 insertions, 0 deletions

diff --git a/git/test/objects/test_blob.py b/git/test/objects/test_blob.py
new file mode 100644
index 00000000..661c0501
--- /dev/null
+++ b/git/test/objects/test_blob.py
@@ -0,0 +1,23 @@
+# test_blob.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from git.test.lib import *
+from git import *
+from gitdb.util import hex_to_bin
+
+class TestBlob(TestBase):
+	
+	def test_mime_type_should_return_mime_type_for_known_types(self):
+		blob = Blob(self.rorepo, **{'binsha': Blob.NULL_BIN_SHA, 'path': 'foo.png'})
+		assert_equal("image/png", blob.mime_type)
+  
+	def test_mime_type_should_return_text_plain_for_unknown_types(self):
+		blob = Blob(self.rorepo, **{'binsha': Blob.NULL_BIN_SHA,'path': 'something'})
+		assert_equal("text/plain", blob.mime_type)
+  
+	def test_nodict(self):
+		self.failUnlessRaises(AttributeError, setattr, self.rorepo.tree()['AUTHORS'], 'someattr', 2)
+	  
diff --git a/git/test/objects/test_commit.py b/git/test/objects/test_commit.py
new file mode 100644
index 00000000..4a8d8b87
--- /dev/null
+++ b/git/test/objects/test_commit.py
@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+# test_commit.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from git.test.lib import *
+from git import *
+from gitdb import IStream
+from gitdb.util import hex_to_bin
+
+from cStringIO import StringIO
+import time
+import sys
+
+
+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 = StringIO()
+		cm._serialize(stream)
+		ns += 1
+		streamlen = stream.tell()
+		stream.seek(0)
+		
+		istream = rwrepo.odb.store(IStream(Commit.type, streamlen, stream))
+		assert istream.hexsha == cm.hexsha
+		
+		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 nc.parents == cm.parents
+		stream = StringIO()
+		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 nc.hexsha == cm.hexsha
+	# END check commits
+	elapsed = time.time() - st
+	
+	if print_performance_info:
+		print >> sys.stderr, "Serialized %i and deserialized %i commits in %f s ( (%f, %f) commits / s" % (ns, nds, elapsed, ns/elapsed, nds/elapsed)
+	# END handle performance info
+	
+
+class TestCommit(TestBase):
+
+	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("byronimo@gmail.com", 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_stats(self):
+		commit = self.rorepo.commit('33ebe7acec14b25c5f84f35a664803fcab2f7781')
+		stats = commit.stats
+		
+		def check_entries(d):
+			assert isinstance(d, dict)
+			for key in ("insertions", "deletions", "lines"):
+				assert key in d
+		# END assertion helper 
+		assert stats.files 
+		assert stats.total
+		
+		check_entries(stats.total) 
+		assert "files" in stats.total
+		
+		for filepath, d in stats.files.items():
+			check_entries(d)
+		# END for each stated file
+		
+		# assure data is parsed properly
+		michael = Actor._from_string("Michael Trier <mtrier@gmail.com>")
+		assert commit.author == michael
+		assert commit.committer == michael
+		assert commit.authored_date == 1210193388
+		assert commit.committed_date == 1210193388
+		assert commit.author_tz_offset == 14400, commit.author_tz_offset
+		assert commit.committer_tz_offset == 14400, commit.committer_tz_offset
+		assert commit.message == "initial project\n"
+		
+	def test_unicode_actor(self):
+		# assure we can parse unicode actors correctly
+		name = "Üäöß ÄußÉ".decode("utf-8")
+		assert len(name) == 9
+		special = Actor._from_string(u"%s <something@this.com>" % name)
+		assert special.name == name
+		assert isinstance(special.name, unicode)
+		
+	def test_traversal(self):
+		start = self.rorepo.commit("a4d06724202afccd2b5c54f81bcf2bf26dea7fff")
+		first = self.rorepo.commit("33ebe7acec14b25c5f84f35a664803fcab2f7781")
+		p0 = start.parents[0]
+		p1 = start.parents[1]
+		p00 = p0.parents[0]
+		p10 = p1.parents[0]
+		
+		# basic branch first, depth first
+		dfirst = start.traverse(branch_first=False)
+		bfirst = start.traverse(branch_first=True)
+		assert dfirst.next() == p0
+		assert dfirst.next() == p00
+		
+		assert bfirst.next() == p0
+		assert bfirst.next() == p1
+		assert bfirst.next() == p00
+		assert bfirst.next() == p10
+		
+		# at some point, both iterations should stop
+		assert list(bfirst)[-1] == first
+		stoptraverse = self.rorepo.commit("254d04aa3180eb8b8daf7b7ff25f010cd69b4e7d").traverse(as_edge=True)
+		l = list(stoptraverse)
+		assert len(l[0]) == 2
+		
+		# ignore self
+		assert start.traverse(ignore_self=False).next() == start
+		
+		# depth 
+		assert len(list(start.traverse(ignore_self=False, depth=0))) == 1
+		
+		# prune
+		assert start.traverse(branch_first=1, prune=lambda i,d: i==p0).next() == p1
+		
+		# predicate
+		assert start.traverse(branch_first=1, predicate=lambda i,d: i==p1).next() == p1
+		
+		# traversal should stop when the beginning is reached
+		self.failUnlessRaises(StopIteration, first.traverse().next)
+		
+		# parents of the first commit should be empty ( as the only parent has a null 
+		# sha )
+		assert len(first.parents) == 0
+		
+	def test_iteration(self):
+		# we can iterate commits
+		all_commits = Commit.list_items(self.rorepo, self.rorepo.head)
+		assert all_commits
+		assert all_commits == list(self.rorepo.iter_commits())
+		
+		# this includes merge commits
+		mcomit = self.rorepo.commit('d884adc80c80300b4cc05321494713904ef1df2d')
+		assert mcomit in all_commits
+		
+		# we can limit the result to paths
+		ltd_commits = list(self.rorepo.iter_commits(paths='CHANGES'))
+		assert ltd_commits and len(ltd_commits) < len(all_commits)
+		
+		# show commits of multiple paths, resulting in a union of commits
+		less_ltd_commits = list(Commit.iter_items(self.rorepo, 'master', paths=('CHANGES', 'AUTHORS')))
+		assert len(ltd_commits) < len(less_ltd_commits)
+		
+	def test_iter_items(self):
+		# pretty not allowed
+		self.failUnlessRaises(ValueError, Commit.iter_items, self.rorepo, 'master', pretty="raw")
+		
+	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))
+		expected_ids = (
+			'7156cece3c49544abb6bf7a0c218eb36646fad6d',
+			'1f66cfbbce58b4b552b041707a12d437cc5f400a',
+			'33ebe7acec14b25c5f84f35a664803fcab2f7781',
+			'933d23bf95a5bd1624fbcdf328d904e1fa173474'
+		)
+		for sha1, commit in zip(expected_ids, commits):
+			assert_equal(sha1, commit.hexsha)
+
+	def test_count(self):
+		assert self.rorepo.tag('refs/tags/0.1.5').commit.count( ) == 143
+		
+	def test_list(self):
+		assert isinstance(Commit.list_items(self.rorepo, '0.1.5', max_count=5)[hex_to_bin('5117c9c8a4d3af19a9958677e45cda9269de1541')], Commit)
+
+	def test_str(self):
+		commit = Commit(self.rorepo, Commit.NULL_BIN_SHA)
+		assert_equal(Commit.NULL_HEX_SHA, str(commit))
+
+	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_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_iter_parents(self):
+		# should return all but ourselves, even if skip is defined
+		c = self.rorepo.commit('0.1.5')
+		for skip in (0, 1):
+			piter = c.iter_parents(skip=skip)
+			first_parent = piter.next()
+			assert first_parent != c
+			assert first_parent == c.parents[0]
+		# END for each 
+		
+	def test_base(self):
+		name_rev = self.rorepo.head.commit.name_rev
+		assert isinstance(name_rev, basestring)
+		
+	@with_rw_repo('HEAD', bare=True)
+	def test_serialization(self, rwrepo):
+		# create all commits of our repo
+		assert_commit_serialization(rwrepo, '0.1.6')
+		
+	def test_serialization_unicode_support(self):
+		assert Commit.default_encoding.lower() == 'utf-8'
+		
+		# create a commit with unicode in the message, and the author's name
+		# Verify its serialization and deserialization
+		cmt = self.rorepo.commit('0.1.6')
+		assert isinstance(cmt.message, unicode)		# it automatically decodes it as such
+		assert isinstance(cmt.author.name, unicode)	# same here
+		
+		cmt.message = "üäêèß".decode("utf-8")
+		assert len(cmt.message) == 5
+		
+		cmt.author.name = "äüß".decode("utf-8")
+		assert len(cmt.author.name) == 3
+		
+		cstream = StringIO()
+		cmt._serialize(cstream)
+		cstream.seek(0)
+		assert len(cstream.getvalue())
+		
+		ncmt = Commit(self.rorepo, cmt.binsha)
+		ncmt._deserialize(cstream)
+		
+		assert cmt.author.name == ncmt.author.name
+		assert cmt.message == ncmt.message
+		# actually, it can't be printed in a shell as repr wants to have ascii only
+		# it appears
+		cmt.author.__repr__()
+		
diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
new file mode 100644
index 00000000..adb4fb82
--- /dev/null
+++ b/git/test/objects/test_submodule.py
@@ -0,0 +1,547 @@
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from git.test.lib import *
+from git.exc import *
+from git.objects.submodule.base import Submodule
+from git.objects.submodule.root import RootModule, RootUpdateProgress
+from git.util import to_native_path_linux, join_path_native
+import shutil
+import git
+import os
+
+class TestRootProgress(RootUpdateProgress):
+	"""Just prints messages, for now without checking the correctness of the states"""
+	
+	def update(self, op, index, max_count, message=''):
+		print message
+		
+prog = TestRootProgress()
+
+class TestSubmodule(TestBase):
+
+	k_subm_current = "468cad66ff1f80ddaeee4123c24e4d53a032c00d"
+	k_subm_changed = "394ed7006ee5dc8bddfd132b64001d5dfc0ffdd3"
+	k_no_subm_tag = "0.1.6"
+	
+
+	def _do_base_tests(self, rwrepo):
+		"""Perform all tests in the given repository, it may be bare or nonbare"""
+		# manual instantiation
+		smm = Submodule(rwrepo, "\0"*20)
+		# name needs to be set in advance
+		self.failUnlessRaises(AttributeError, getattr, smm, 'name') 
+		
+		# iterate - 1 submodule
+		sms = Submodule.list_items(rwrepo, self.k_subm_current)
+		assert len(sms) == 1
+		sm = sms[0]
+		
+		# at a different time, there is None
+		assert len(Submodule.list_items(rwrepo, self.k_no_subm_tag)) == 0
+		
+		assert sm.path == 'git/ext/gitdb'
+		assert sm.path != sm.name					# in our case, we have ids there, which don't equal the path
+		assert sm.url == 'git://github.com/gitpython-developers/gitdb.git'
+		assert sm.branch_path == 'refs/heads/master'			# the default ...
+		assert sm.branch_name == 'master'
+		assert sm.parent_commit == rwrepo.head.commit
+		# size is always 0
+		assert sm.size == 0
+		# the module is not checked-out yet
+		self.failUnlessRaises(InvalidGitRepositoryError, sm.module)
+		
+		# which is why we can't get the branch either - it points into the module() repository
+		self.failUnlessRaises(InvalidGitRepositoryError, getattr, sm, 'branch')
+		
+		# branch_path works, as its just a string
+		assert isinstance(sm.branch_path, basestring)
+		
+		# some commits earlier we still have a submodule, but its at a different commit
+		smold = Submodule.iter_items(rwrepo, self.k_subm_changed).next()
+		assert smold.binsha != sm.binsha
+		assert smold != sm					# the name changed
+		
+		# force it to reread its information
+		del(smold._url)
+		smold.url == sm.url
+		
+		# test config_reader/writer methods
+		sm.config_reader()
+		new_smclone_path = None				# keep custom paths for later 
+		new_csmclone_path = None				# 
+		if rwrepo.bare:
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.config_writer)
+		else:
+			writer = sm.config_writer()
+			# for faster checkout, set the url to the local path
+			new_smclone_path = to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, sm.path))
+			writer.set_value('url', new_smclone_path)
+			del(writer)
+			assert sm.config_reader().get_value('url') == new_smclone_path
+			assert sm.url == new_smclone_path
+		# END handle bare repo
+		smold.config_reader()
+		
+		# cannot get a writer on historical submodules
+		if not rwrepo.bare:
+			self.failUnlessRaises(ValueError, smold.config_writer)
+		# END handle bare repo
+		
+		# make the old into a new - this doesn't work as the name changed
+		prev_parent_commit = smold.parent_commit
+		self.failUnlessRaises(ValueError, smold.set_parent_commit, self.k_subm_current)
+		# the sha is properly updated
+		smold.set_parent_commit(self.k_subm_changed+"~1")
+		assert smold.binsha != sm.binsha
+		
+		# raises if the sm didn't exist in new parent - it keeps its 
+		# parent_commit unchanged
+		self.failUnlessRaises(ValueError, smold.set_parent_commit, self.k_no_subm_tag)
+		
+		# TEST TODO: if a path in the gitmodules file, but not in the index, it raises
+		
+		# TEST UPDATE
+		##############
+		# module retrieval is not always possible
+		if rwrepo.bare:
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.module)
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.remove)
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.add, rwrepo, 'here', 'there')
+		else:
+			# its not checked out in our case
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.module)
+			assert not sm.module_exists()
+			
+			# currently there is only one submodule
+			assert len(list(rwrepo.iter_submodules())) == 1
+			assert sm.binsha != "\0"*20
+			
+			# TEST ADD
+			###########
+			# preliminary tests
+			# adding existing returns exactly the existing
+			sma = Submodule.add(rwrepo, sm.name, sm.path)
+			assert sma.path == sm.path
+			
+			# no url and no module at path fails
+			self.failUnlessRaises(ValueError, Submodule.add, rwrepo, "newsubm", "pathtorepo", url=None)
+			
+			# CONTINUE UPDATE
+			#################
+			
+			# lets update it - its a recursive one too
+			newdir = os.path.join(sm.abspath, 'dir')
+			os.makedirs(newdir)
+			
+			# update fails if the path already exists non-empty
+			self.failUnlessRaises(OSError, sm.update)
+			os.rmdir(newdir)
+			
+			# dry-run does nothing
+			sm.update(dry_run=True, progress=prog)
+			assert not sm.module_exists()
+			
+			assert sm.update() is sm
+			sm_repopath = sm.path				# cache for later
+			assert sm.module_exists()
+			assert isinstance(sm.module(), git.Repo)
+			assert sm.module().working_tree_dir == sm.abspath
+			
+			# INTERLEAVE ADD TEST
+			#####################
+			# url must match the one in the existing repository ( if submodule name suggests a new one )
+			# or we raise
+			self.failUnlessRaises(ValueError, Submodule.add, rwrepo, "newsubm", sm.path, "git://someurl/repo.git")
+			
+			
+			# CONTINUE UPDATE
+			#################
+			# we should have setup a tracking branch, which is also active
+			assert sm.module().head.ref.tracking_branch() is not None
+			
+			# delete the whole directory and re-initialize
+			shutil.rmtree(sm.abspath)
+			assert len(sm.children()) == 0
+			# dry-run does nothing
+			sm.update(dry_run=True, recursive=False, progress=prog)
+			assert len(sm.children()) == 0
+			
+			sm.update(recursive=False)
+			assert len(list(rwrepo.iter_submodules())) == 2
+			assert len(sm.children()) == 1			# its not checked out yet
+			csm = sm.children()[0]
+			assert not csm.module_exists()
+			csm_repopath = csm.path
+			
+			# adjust the path of the submodules module to point to the local destination
+			new_csmclone_path = to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, sm.path, csm.path))
+			csm.config_writer().set_value('url', new_csmclone_path)
+			assert csm.url == new_csmclone_path
+			
+			# dry-run does nothing
+			assert not csm.module_exists()
+			sm.update(recursive=True, dry_run=True, progress=prog)
+			assert not csm.module_exists()
+			
+			# update recursively again
+			sm.update(recursive=True)
+			assert csm.module_exists()
+			
+			# tracking branch once again
+			csm.module().head.ref.tracking_branch() is not None
+			
+			# this flushed in a sub-submodule
+			assert len(list(rwrepo.iter_submodules())) == 2
+			
+			
+			# reset both heads to the previous version, verify that to_latest_revision works
+			smods = (sm.module(), csm.module())
+			for repo in smods:
+				repo.head.reset('HEAD~2', working_tree=1)
+			# END for each repo to reset
+			
+			# dry run does nothing 
+			sm.update(recursive=True, dry_run=True, progress=prog)
+			for repo in smods:
+				assert repo.head.commit != repo.head.ref.tracking_branch().commit
+			# END for each repo to check
+			
+			sm.update(recursive=True, to_latest_revision=True)
+			for repo in smods:
+				assert repo.head.commit == repo.head.ref.tracking_branch().commit
+			# END for each repo to check
+			del(smods)
+			
+			# if the head is detached, it still works ( but warns )
+			smref = sm.module().head.ref
+			sm.module().head.ref = 'HEAD~1'
+			# if there is no tracking branch, we get a warning as well
+			csm_tracking_branch = csm.module().head.ref.tracking_branch()
+			csm.module().head.ref.set_tracking_branch(None)
+			sm.update(recursive=True, to_latest_revision=True)
+			
+			# to_latest_revision changes the child submodule's commit, it needs an
+			# update now
+			csm.set_parent_commit(csm.repo.head.commit)
+			
+			# undo the changes
+			sm.module().head.ref = smref
+			csm.module().head.ref.set_tracking_branch(csm_tracking_branch)
+			
+			# REMOVAL OF REPOSITOTRY
+			########################
+			# must delete something
+			self.failUnlessRaises(ValueError, csm.remove, module=False, configuration=False)
+			# We have modified the configuration, hence the index is dirty, and the
+			# deletion will fail
+			# NOTE: As we did  a few updates in the meanwhile, the indices were reset
+			# Hence we create some changes
+			csm.set_parent_commit(csm.repo.head.commit)
+			sm.config_writer().set_value("somekey", "somevalue")
+			csm.config_writer().set_value("okey", "ovalue")
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.remove)
+			# if we remove the dirty index, it would work
+			sm.module().index.reset()
+			# still, we have the file modified
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.remove, dry_run=True)
+			sm.module().index.reset(working_tree=True)
+			
+			# this would work
+			assert sm.remove(dry_run=True) is sm
+			assert sm.module_exists()
+			sm.remove(force=True, dry_run=True)
+			assert sm.module_exists()
+			
+			# but ... we have untracked files in the child submodule
+			fn = join_path_native(csm.module().working_tree_dir, "newfile")
+			open(fn, 'w').write("hi")
+			self.failUnlessRaises(InvalidGitRepositoryError, sm.remove)
+			
+			# forcibly delete the child repository
+			assert csm.remove(force=True) is csm
+			assert not csm.exists()
+			assert not csm.module_exists()
+			assert len(sm.children()) == 0
+			# now we have a changed index, as configuration was altered.
+			# fix this
+			sm.module().index.reset(working_tree=True)
+			
+			# now delete only the module of the main submodule
+			assert sm.module_exists()
+			sm.remove(configuration=False)
+			assert sm.exists()
+			assert not sm.module_exists()
+			assert sm.config_reader().get_value('url')
+			
+			# delete the rest
+			sm.remove()
+			assert not sm.exists()
+			assert not sm.module_exists()
+			
+			assert len(rwrepo.submodules) == 0
+			
+			# ADD NEW SUBMODULE
+			###################
+			# add a simple remote repo - trailing slashes are no problem
+			smid = "newsub"
+			osmid = "othersub"
+			nsm = Submodule.add(rwrepo, smid, sm_repopath, new_smclone_path+"/", None, no_checkout=True)
+			assert nsm.name == smid
+			assert nsm.module_exists()
+			assert nsm.exists()
+			# its not checked out
+			assert not os.path.isfile(join_path_native(nsm.module().working_tree_dir, Submodule.k_modules_file))
+			assert len(rwrepo.submodules) == 1
+			
+			# add another submodule, but into the root, not as submodule
+			osm = Submodule.add(rwrepo, osmid, csm_repopath, new_csmclone_path, Submodule.k_head_default)
+			assert osm != nsm
+			assert osm.module_exists()
+			assert osm.exists()
+			assert os.path.isfile(join_path_native(osm.module().working_tree_dir, 'setup.py'))
+			
+			assert len(rwrepo.submodules) == 2
+			
+			# commit the changes, just to finalize the operation
+			rwrepo.index.commit("my submod commit")
+			assert len(rwrepo.submodules) == 2
+			
+			# needs update as the head changed, it thinks its in the history 
+			# of the repo otherwise
+			nsm.set_parent_commit(rwrepo.head.commit)
+			osm.set_parent_commit(rwrepo.head.commit)
+			
+			# MOVE MODULE
+			#############
+			# invalid inptu
+			self.failUnlessRaises(ValueError, nsm.move, 'doesntmatter', module=False, configuration=False)
+			
+			# renaming to the same path does nothing
+			assert nsm.move(sm.path) is nsm
+			
+			# rename a module
+			nmp = join_path_native("new", "module", "dir") + "/" # new module path
+			pmp = nsm.path
+			abspmp = nsm.abspath
+			assert nsm.move(nmp) is nsm
+			nmp = nmp[:-1]			# cut last /
+			assert nsm.path == nmp
+			assert rwrepo.submodules[0].path == nmp
+			
+			mpath = 'newsubmodule'
+			absmpath = join_path_native(rwrepo.working_tree_dir, mpath)
+			open(absmpath, 'w').write('')
+			self.failUnlessRaises(ValueError, nsm.move, mpath)
+			os.remove(absmpath)
+			
+			# now it works, as we just move it back
+			nsm.move(pmp)
+			assert nsm.path == pmp
+			assert rwrepo.submodules[0].path == pmp
+			
+			# TODO lowprio: test remaining exceptions ... for now its okay, the code looks right
+			
+			# REMOVE 'EM ALL
+			################
+			# if a submodule's repo has no remotes, it can't be added without an explicit url
+			osmod = osm.module()
+			
+			osm.remove(module=False)
+			for remote in osmod.remotes:
+				remote.remove(osmod, remote.name)
+			assert not osm.exists()
+			self.failUnlessRaises(ValueError, Submodule.add, rwrepo, osmid, csm_repopath, url=None)   
+		# END handle bare mode
+		
+		# Error if there is no submodule file here
+		self.failUnlessRaises(IOError, Submodule._config_parser, rwrepo, rwrepo.commit(self.k_no_subm_tag), True)
+		
+	@with_rw_repo(k_subm_current)
+	def test_base_rw(self, rwrepo):
+		self._do_base_tests(rwrepo)
+		
+	@with_rw_repo(k_subm_current, bare=True)
+	def test_base_bare(self, rwrepo):
+		self._do_base_tests(rwrepo)
+		
+	@with_rw_repo(k_subm_current, bare=False)
+	def test_root_module(self, rwrepo):
+		# Can query everything without problems
+		rm = RootModule(self.rorepo)
+		assert rm.module() is self.rorepo
+		
+		# try attributes
+		rm.binsha
+		rm.mode
+		rm.path
+		assert rm.name == rm.k_root_name
+		assert rm.parent_commit == self.rorepo.head.commit
+		rm.url
+		rm.branch
+		
+		assert len(rm.list_items(rm.module())) == 1
+		rm.config_reader()
+		rm.config_writer()
+		
+		# deep traversal gitdb / async
+		rsmsp = [sm.path for sm in rm.traverse()]
+		assert len(rsmsp) == 2			# gitdb and async, async being a child of gitdb
+		
+		# cannot set the parent commit as root module's path didn't exist
+		self.failUnlessRaises(ValueError, rm.set_parent_commit, 'HEAD')
+		
+		# TEST UPDATE
+		#############
+		# setup commit which remove existing, add new and modify existing submodules
+		rm = RootModule(rwrepo)
+		assert len(rm.children()) == 1
+		
+		# modify path without modifying the index entry
+		# ( which is what the move method would do properly )
+		#==================================================
+		sm = rm.children()[0]
+		pp = "path/prefix"
+		fp = join_path_native(pp, sm.path)
+		prep = sm.path
+		assert not sm.module_exists()				# was never updated after rwrepo's clone
+		
+		# assure we clone from a local source 
+		sm.config_writer().set_value('url', to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, sm.path)))
+		
+		# dry-run does nothing
+		sm.update(recursive=False, dry_run=True, progress=prog)
+		assert not sm.module_exists()
+		
+		sm.update(recursive=False)
+		assert sm.module_exists()
+		sm.config_writer().set_value('path', fp)	# change path to something with prefix AFTER url change
+		
+		# update fails as list_items in such a situations cannot work, as it cannot
+		# find the entry at the changed path
+		self.failUnlessRaises(InvalidGitRepositoryError, rm.update, recursive=False)
+		
+		# move it properly - doesn't work as it its path currently points to an indexentry
+		# which doesn't exist ( move it to some path, it doesn't matter here )
+		self.failUnlessRaises(InvalidGitRepositoryError, sm.move, pp)
+		# reset the path(cache) to where it was, now it works
+		sm.path = prep
+		sm.move(fp, module=False)		# leave it at the old location
+		
+		assert not sm.module_exists()
+		cpathchange = rwrepo.index.commit("changed sm path") # finally we can commit
+		
+		# update puts the module into place
+		rm.update(recursive=False, progress=prog)
+		sm.set_parent_commit(cpathchange)
+		assert sm.module_exists()
+		
+		# add submodule
+		#================
+		nsmn = "newsubmodule"
+		nsmp = "submrepo"
+		async_url = to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, rsmsp[0], rsmsp[1]))
+		nsm = Submodule.add(rwrepo, nsmn, nsmp, url=async_url)
+		csmadded = rwrepo.index.commit("Added submodule").hexsha	# make sure we don't keep the repo reference
+		nsm.set_parent_commit(csmadded)
+		assert nsm.module_exists()
+		# in our case, the module should not exist, which happens if we update a parent
+		# repo and a new submodule comes into life
+		nsm.remove(configuration=False, module=True)
+		assert not nsm.module_exists() and nsm.exists()
+		
+		
+		# dry-run does nothing
+		rm.update(recursive=False, dry_run=True, progress=prog)
+		
+		# otherwise it will work
+		rm.update(recursive=False, progress=prog)
+		assert nsm.module_exists()
+		
+		
+		
+		# remove submodule - the previous one
+		#====================================
+		sm.set_parent_commit(csmadded)
+		smp = sm.abspath
+		assert not sm.remove(module=False).exists()
+		assert os.path.isdir(smp)			# module still exists
+		csmremoved = rwrepo.index.commit("Removed submodule")
+		
+		# an update will remove the module
+		# not in dry_run
+		rm.update(recursive=False, dry_run=True)
+		assert os.path.isdir(smp)
+		
+		rm.update(recursive=False)
+		assert not os.path.isdir(smp)
+		
+		
+		# change url 
+		#=============
+		# to the first repository, this way we have a fast checkout, and a completely different 
+		# repository at the different url
+		nsm.set_parent_commit(csmremoved)
+		nsmurl = to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, rsmsp[0]))
+		nsm.config_writer().set_value('url', nsmurl)
+		csmpathchange = rwrepo.index.commit("changed url")
+		nsm.set_parent_commit(csmpathchange)
+		
+		prev_commit = nsm.module().head.commit
+		# dry-run does nothing
+		rm.update(recursive=False, dry_run=True, progress=prog)
+		assert nsm.module().remotes.origin.url != nsmurl
+		
+		rm.update(recursive=False, progress=prog)
+		assert nsm.module().remotes.origin.url == nsmurl
+		# head changed, as the remote url and its commit changed
+		assert prev_commit != nsm.module().head.commit
+		
+		# add the submodule's changed commit to the index, which is what the
+		# user would do
+		# beforehand, update our instance's binsha with the new one
+		nsm.binsha = nsm.module().head.commit.binsha
+		rwrepo.index.add([nsm])
+		
+		# change branch
+		#=================
+		# we only have one branch, so we switch to a virtual one, and back 
+		# to the current one to trigger the difference
+		cur_branch = nsm.branch
+		nsmm = nsm.module()
+		prev_commit = nsmm.head.commit
+		for branch in ("some_virtual_branch", cur_branch.name):
+			nsm.config_writer().set_value(Submodule.k_head_option, git.Head.to_full_path(branch))
+			csmbranchchange = rwrepo.index.commit("changed branch to %s" % branch)
+			nsm.set_parent_commit(csmbranchchange)
+		# END for each branch to change
+		
+		# Lets remove our tracking branch to simulate some changes
+		nsmmh = nsmm.head
+		assert nsmmh.ref.tracking_branch() is None					# never set it up until now
+		assert not nsmmh.is_detached
+		
+		#dry run does nothing
+		rm.update(recursive=False, dry_run=True, progress=prog)
+		assert nsmmh.ref.tracking_branch() is None
+		
+		# the real thing does
+		rm.update(recursive=False, progress=prog)
+		
+		assert nsmmh.ref.tracking_branch() is not None
+		assert not nsmmh.is_detached
+		
+		# recursive update
+		# =================
+		# finally we recursively update a module, just to run the code at least once
+		# remove the module so that it has more work
+		assert len(nsm.children()) == 1
+		assert nsm.exists() and nsm.module_exists() and len(nsm.children()) == 1
+		# assure we pull locally only
+		nsmc = nsm.children()[0] 
+		nsmc.config_writer().set_value('url', async_url)
+		rm.update(recursive=True, progress=prog, dry_run=True)		# just to run the code
+		rm.update(recursive=True, progress=prog)
+		
+		assert len(nsm.children()) == 1 and nsmc.module_exists()
+		
diff --git a/git/test/objects/test_tree.py b/git/test/objects/test_tree.py
new file mode 100644
index 00000000..ec10e962
--- /dev/null
+++ b/git/test/objects/test_tree.py
@@ -0,0 +1,144 @@
+# test_tree.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+import os
+from git.test.lib import *
+from git import *
+from git.objects.fun import (
+								traverse_tree_recursive,
+								traverse_trees_recursive
+							)
+from cStringIO import StringIO
+
+class TestTree(TestBase):
+	
+	def test_serializable(self):
+		# tree at the given commit contains a submodule as well
+		roottree = self.rorepo.tree('6c1faef799095f3990e9970bc2cb10aa0221cf9c')
+		for item in roottree.traverse(ignore_self=False):
+			if item.type != Tree.type:
+				continue
+			# END skip non-trees
+			tree = item
+			# trees have no dict
+			self.failUnlessRaises(AttributeError, setattr, tree, 'someattr', 1)
+			
+			orig_data = tree.data_stream.read()
+			orig_cache = tree._cache
+			
+			stream = StringIO()
+			tree._serialize(stream)
+			assert stream.getvalue() == orig_data
+			
+			stream.seek(0)
+			testtree = Tree(self.rorepo, Tree.NULL_BIN_SHA, 0, '')
+			testtree._deserialize(stream)
+			assert testtree._cache == orig_cache
+			
+			
+			# TEST CACHE MUTATOR
+			mod = testtree.cache
+			self.failUnlessRaises(ValueError, mod.add, "invalid sha", 0, "name")
+			self.failUnlessRaises(ValueError, mod.add, Tree.NULL_HEX_SHA, 0, "invalid mode")
+			self.failUnlessRaises(ValueError, mod.add, Tree.NULL_HEX_SHA, tree.mode, "invalid/name")
+			
+			# add new item
+			name = "fake_dir"
+			mod.add(testtree.NULL_HEX_SHA, tree.mode, name)
+			assert name in testtree
+			
+			# its available in the tree immediately
+			assert isinstance(testtree[name], Tree)
+			
+			# adding it again will not cause multiple of them to be presents
+			cur_count = len(testtree)
+			mod.add(testtree.NULL_HEX_SHA, tree.mode, name)
+			assert len(testtree) == cur_count
+			
+			# fails with a different sha - name exists
+			hexsha = "1"*40
+			self.failUnlessRaises(ValueError, mod.add, hexsha, tree.mode, name)
+			
+			# force it - replace existing one
+			mod.add(hexsha, tree.mode, name, force=True)
+			assert testtree[name].hexsha == hexsha
+			assert len(testtree) == cur_count
+			
+			# unchecked addition always works, even with invalid items
+			invalid_name = "hi/there"
+			mod.add_unchecked(hexsha, 0, invalid_name)
+			assert len(testtree) == cur_count + 1
+			
+			del(mod[invalid_name])
+			assert len(testtree) == cur_count
+			# del again, its fine
+			del(mod[invalid_name])
+			
+			# have added one item, we are done
+			mod.set_done()
+			mod.set_done()		# multiple times are okay
+			
+			# serialize, its different now
+			stream = StringIO()
+			testtree._serialize(stream)
+			stream.seek(0)
+			assert stream.getvalue() != orig_data
+			
+			# replaces cache, but we make sure of it
+			del(testtree._cache)
+			testtree._deserialize(stream)
+			assert name in testtree
+			assert invalid_name not in testtree
+		# END for each item in tree
+	
+	def test_traverse(self):
+		root = self.rorepo.tree('0.1.6')
+		num_recursive = 0
+		all_items = list()
+		for obj in root.traverse():
+			if "/" in obj.path:
+				num_recursive += 1
+				
+			assert isinstance(obj, (Blob, Tree))
+			all_items.append(obj)
+		# END for each object
+		assert all_items == root.list_traverse()
+		
+		# limit recursion level to 0 - should be same as default iteration
+		assert all_items
+		assert 'CHANGES' in root
+		assert len(list(root)) == len(list(root.traverse(depth=1)))
+		
+		# only choose trees
+		trees_only = lambda i,d: i.type == "tree"
+		trees = list(root.traverse(predicate = trees_only))
+		assert len(trees) == len(list( i for i in root.traverse() if trees_only(i,0) ))
+		
+		# test prune
+		lib_folder = lambda t,d: t.path == "lib"
+		pruned_trees = list(root.traverse(predicate = trees_only,prune = lib_folder))
+		assert len(pruned_trees) < len(trees)
+		
+		# trees and blobs
+		assert len(set(trees)|set(root.trees)) == len(trees)
+		assert len(set(b for b in root if isinstance(b, Blob)) | set(root.blobs)) == len( root.blobs )
+		subitem = trees[0][0]
+		assert "/" in subitem.path
+		assert subitem.name == os.path.basename(subitem.path)
+		
+		# assure that at some point the traversed paths have a slash in them
+		found_slash = False
+		for item in root.traverse():
+			assert os.path.isabs(item.abspath)
+			if '/' in item.path:
+				found_slash = True
+			# END check for slash
+			
+			# slashes in paths are supported as well 
+			assert root[item.path] == item == root/item.path
+		# END for each item
+		assert found_slash
+