From a12a7618a1f6f61a4c97ddf4cc422158c3fa72ba Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Thu, 7 Apr 2011 20:17:00 +0200
Subject: 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

---
 git/test/objects/test_blob.py      |  23 ++
 git/test/objects/test_commit.py    | 275 +++++++++++++++++++
 git/test/objects/test_submodule.py | 547 +++++++++++++++++++++++++++++++++++++
 git/test/objects/test_tree.py      | 144 ++++++++++
 4 files changed, 989 insertions(+)
 create mode 100644 git/test/objects/test_blob.py
 create mode 100644 git/test/objects/test_commit.py
 create mode 100644 git/test/objects/test_submodule.py
 create mode 100644 git/test/objects/test_tree.py

(limited to 'git/test/objects')

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
+  
-- 
cgit v1.2.3


From acf5e6ea64a2f24117f1d419c208ed1c38c43690 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Fri, 6 May 2011 15:03:14 +0200
Subject: replaced all gitdb strings with git

---
 git/test/objects/test_blob.py      | 2 +-
 git/test/objects/test_commit.py    | 4 ++--
 git/test/objects/test_submodule.py | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/test_blob.py b/git/test/objects/test_blob.py
index 661c0501..7041010f 100644
--- a/git/test/objects/test_blob.py
+++ b/git/test/objects/test_blob.py
@@ -6,7 +6,7 @@
 
 from git.test.lib import *
 from git import *
-from gitdb.util import hex_to_bin
+from git.util import hex_to_bin
 
 class TestBlob(TestBase):
 	
diff --git a/git/test/objects/test_commit.py b/git/test/objects/test_commit.py
index 4a8d8b87..b2cc5b27 100644
--- a/git/test/objects/test_commit.py
+++ b/git/test/objects/test_commit.py
@@ -7,8 +7,8 @@
 
 from git.test.lib import *
 from git import *
-from gitdb import IStream
-from gitdb.util import hex_to_bin
+from git import IStream
+from git.util import hex_to_bin
 
 from cStringIO import StringIO
 import time
diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index adb4fb82..d6062be9 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -40,9 +40,9 @@ class TestSubmodule(TestBase):
 		# 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 == 'git/ext/git'
 		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.url == 'git://github.com/gitpython-developers/git.git'
 		assert sm.branch_path == 'refs/heads/master'			# the default ...
 		assert sm.branch_name == 'master'
 		assert sm.parent_commit == rwrepo.head.commit
@@ -384,9 +384,9 @@ class TestSubmodule(TestBase):
 		rm.config_reader()
 		rm.config_writer()
 		
-		# deep traversal gitdb / async
+		# deep traversal git / async
 		rsmsp = [sm.path for sm in rm.traverse()]
-		assert len(rsmsp) == 2			# gitdb and async, async being a child of gitdb
+		assert len(rsmsp) == 2			# git and async, async being a child of git
 		
 		# cannot set the parent commit as root module's path didn't exist
 		self.failUnlessRaises(ValueError, rm.set_parent_commit, 'HEAD')
-- 
cgit v1.2.3


From 7ae36c3e019a5cc16924d1b6007774bfb625036f Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Fri, 6 May 2011 18:53:59 +0200
Subject: Started to fix imports - tests still have no chance to work as
 database changed drastically. Now the actual work begins

---
 git/test/objects/test_blob.py      | 2 +-
 git/test/objects/test_commit.py    | 2 +-
 git/test/objects/test_submodule.py | 2 +-
 git/test/objects/test_tree.py      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/test_blob.py b/git/test/objects/test_blob.py
index 7041010f..a6de7fb7 100644
--- a/git/test/objects/test_blob.py
+++ b/git/test/objects/test_blob.py
@@ -4,7 +4,7 @@
 # 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.test.lib import TestBase
 from git import *
 from git.util import hex_to_bin
 
diff --git a/git/test/objects/test_commit.py b/git/test/objects/test_commit.py
index b2cc5b27..3ccff228 100644
--- a/git/test/objects/test_commit.py
+++ b/git/test/objects/test_commit.py
@@ -5,7 +5,7 @@
 # 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.test.lib import TestBase
 from git import *
 from git import IStream
 from git.util import hex_to_bin
diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index d6062be9..cb5fd33f 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -1,7 +1,7 @@
 # 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.test.lib import TestBase
 from git.exc import *
 from git.objects.submodule.base import Submodule
 from git.objects.submodule.root import RootModule, RootUpdateProgress
diff --git a/git/test/objects/test_tree.py b/git/test/objects/test_tree.py
index ec10e962..af32aeb9 100644
--- a/git/test/objects/test_tree.py
+++ b/git/test/objects/test_tree.py
@@ -5,7 +5,7 @@
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
 import os
-from git.test.lib import *
+from git.test.lib import TestBase
 from git import *
 from git.objects.fun import (
 								traverse_tree_recursive,
-- 
cgit v1.2.3


From 7fab60c596cdd2588f9c7b2b4eb9f93f8736b915 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Mon, 30 May 2011 20:10:47 +0200
Subject: Fixed all of the object tests, except for the submodule handling
 which needs more work as the amount of submodules changed in fact. Maybe I
 should just generate a test repository with gitpython as submodule to get the
 recursion depth required to satisfy the test

---
 git/test/objects/lib.py            | 18 ++++++++++++++++++
 git/test/objects/test_blob.py      |  6 +++---
 git/test/objects/test_commit.py    | 14 +++++++++-----
 git/test/objects/test_submodule.py |  5 +++--
 git/test/objects/test_tree.py      | 10 ++++++----
 5 files changed, 39 insertions(+), 14 deletions(-)
 create mode 100644 git/test/objects/lib.py

(limited to 'git/test/objects')

diff --git a/git/test/objects/lib.py b/git/test/objects/lib.py
new file mode 100644
index 00000000..c146833d
--- /dev/null
+++ b/git/test/objects/lib.py
@@ -0,0 +1,18 @@
+"""Provide customized obhject testing facilities"""
+
+from git.test.lib import (
+							rorepo_dir,
+							TestBase,
+							assert_equal,
+							assert_not_equal,
+							with_rw_repo,
+							StringProcessAdapter,
+						)
+from git.repo import Repo
+
+class TestObjectBase(TestBase):
+	"""Provides a default read-only repository in the rorepo member"""
+	
+	@classmethod
+	def setUpAll(cls):
+		cls.rorepo = Repo(rorepo_dir())
diff --git a/git/test/objects/test_blob.py b/git/test/objects/test_blob.py
index a6de7fb7..58ac25b7 100644
--- a/git/test/objects/test_blob.py
+++ b/git/test/objects/test_blob.py
@@ -4,11 +4,11 @@
 # 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 TestBase
-from git import *
+from lib import *
+from git.objects.blob import *
 from git.util import hex_to_bin
 
-class TestBlob(TestBase):
+class TestBlob(TestObjectBase):
 	
 	def test_mime_type_should_return_mime_type_for_known_types(self):
 		blob = Blob(self.rorepo, **{'binsha': Blob.NULL_BIN_SHA, 'path': 'foo.png'})
diff --git a/git/test/objects/test_commit.py b/git/test/objects/test_commit.py
index 3ccff228..80326fe9 100644
--- a/git/test/objects/test_commit.py
+++ b/git/test/objects/test_commit.py
@@ -5,10 +5,14 @@
 # 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 TestBase
-from git import *
-from git import IStream
-from git.util import hex_to_bin
+from lib import *
+from git.objects.commit import *
+from git.base import IStream
+
+from git.util import (
+						hex_to_bin,
+						Actor,
+					)
 
 from cStringIO import StringIO
 import time
@@ -65,7 +69,7 @@ def assert_commit_serialization(rwrepo, commit_id, print_performance_info=False)
 	# END handle performance info
 	
 
-class TestCommit(TestBase):
+class TestCommit(TestObjectBase):
 
 	def test_bake(self):
 
diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index cb5fd33f..b3405a96 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -1,11 +1,12 @@
 # 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 TestBase
+from 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
@@ -18,7 +19,7 @@ class TestRootProgress(RootUpdateProgress):
 		
 prog = TestRootProgress()
 
-class TestSubmodule(TestBase):
+class TestSubmodule(TestObjectBase):
 
 	k_subm_current = "468cad66ff1f80ddaeee4123c24e4d53a032c00d"
 	k_subm_changed = "394ed7006ee5dc8bddfd132b64001d5dfc0ffdd3"
diff --git a/git/test/objects/test_tree.py b/git/test/objects/test_tree.py
index af32aeb9..bc8d3f97 100644
--- a/git/test/objects/test_tree.py
+++ b/git/test/objects/test_tree.py
@@ -4,16 +4,18 @@
 # 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 TestBase
-from git import *
+
+from lib import *
 from git.objects.fun import (
 								traverse_tree_recursive,
 								traverse_trees_recursive
 							)
+from git.objects.blob import Blob
+from git.objects.tree import Tree
 from cStringIO import StringIO
+import os
 
-class TestTree(TestBase):
+class TestTree(TestObjectBase):
 	
 	def test_serializable(self):
 		# tree at the given commit contains a submodule as well
-- 
cgit v1.2.3


From 6f960586feccff8c1f2c717765eb0a5e8b9cd6f3 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Mon, 30 May 2011 21:14:22 +0200
Subject: Fixed remaining tests as good as possible. remote/fetch/pull and
 submodule tests need some more work. Also, the tests need to be reorganized
 and move closer to their actual location within gitpython. Hence the refs
 tests go to git.test.refs, etc

---
 git/test/objects/lib.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/lib.py b/git/test/objects/lib.py
index c146833d..fe1d9f9d 100644
--- a/git/test/objects/lib.py
+++ b/git/test/objects/lib.py
@@ -8,11 +8,7 @@ from git.test.lib import (
 							with_rw_repo,
 							StringProcessAdapter,
 						)
-from git.repo import Repo
 
 class TestObjectBase(TestBase):
 	"""Provides a default read-only repository in the rorepo member"""
-	
-	@classmethod
-	def setUpAll(cls):
-		cls.rorepo = Repo(rorepo_dir())
+	pass
-- 
cgit v1.2.3


From 79b9dbd63f3b1ec3f1ae9269ff44f9c07eeab9fa Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Mon, 6 Jun 2011 19:56:17 +0200
Subject: Fixed performance commit object testing

---
 git/test/objects/__init__.py | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 git/test/objects/__init__.py

(limited to 'git/test/objects')

diff --git a/git/test/objects/__init__.py b/git/test/objects/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/git/test/objects/__init__.py
@@ -0,0 +1 @@
+
-- 
cgit v1.2.3


From f7ca1ce511b535b088ffcbd764415fe0d33f368e Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 7 Jun 2011 17:14:57 +0200
Subject: Submodule tests are nearly working. Only root module needs more
 attention

---
 git/test/objects/test_submodule.py | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index b3405a96..8f7eba35 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -10,6 +10,7 @@ from git.util import to_native_path_linux, join_path_native
 import shutil
 import git
 import os
+import sys
 
 class TestRootProgress(RootUpdateProgress):
 	"""Just prints messages, for now without checking the correctness of the states"""
@@ -25,6 +26,10 @@ class TestSubmodule(TestObjectBase):
 	k_subm_changed = "394ed7006ee5dc8bddfd132b64001d5dfc0ffdd3"
 	k_no_subm_tag = "0.1.6"
 	
+	env_gitdb_local_path = "GITPYTHON_TEST_GITDB_LOCAL_PATH"
+	
+	def _generate_async_local_path(self):
+		return to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, 'git/ext/async'))
 
 	def _do_base_tests(self, rwrepo):
 		"""Perform all tests in the given repository, it may be bare or nonbare"""
@@ -41,9 +46,9 @@ class TestSubmodule(TestObjectBase):
 		# at a different time, there is None
 		assert len(Submodule.list_items(rwrepo, self.k_no_subm_tag)) == 0
 		
-		assert sm.path == 'git/ext/git'
+		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/git.git'
+		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
@@ -74,13 +79,21 @@ class TestSubmodule(TestObjectBase):
 		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
+			# Note: This is nice but doesn't work anymore with the latest git-python
+			# version. This would also mean we need internet for this to work which 
+			# is why we allow an override using an environment variable
+			new_smclone_path = os.environ.get(self.env_gitdb_local_path)
+			if new_smclone_path is not None:
+				writer = sm.config_writer()
+				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
+			else:
+				sys.stderr.write("Submodule tests need the gitdb repository. You can specify a local source setting the %s environment variable. Otherwise it will be downloaded from the internet" % self.env_gitdb_local_path)
+			#END handle submodule path 
+			
 		# END handle bare repo
 		smold.config_reader()
 		
@@ -176,7 +189,8 @@ class TestSubmodule(TestObjectBase):
 			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))
+			# In the current gitpython version, async is used directly by gitpython
+			new_csmclone_path = self._generate_async_local_path()
 			csm.config_writer().set_value('url', new_csmclone_path)
 			assert csm.url == new_csmclone_path
 			
@@ -248,6 +262,10 @@ class TestSubmodule(TestObjectBase):
 			self.failUnlessRaises(InvalidGitRepositoryError, sm.remove, dry_run=True)
 			sm.module().index.reset(working_tree=True)
 			
+			# make sure sub-submodule is not modified by forcing it to update
+			# to the revision it is supposed to point to.
+			csm.update()
+			
 			# this would work
 			assert sm.remove(dry_run=True) is sm
 			assert sm.module_exists()
-- 
cgit v1.2.3


From 82793e5d0d36329880931369b728d62522a76d08 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 7 Jun 2011 18:05:07 +0200
Subject: Submodule tests are fully back and working

---
 git/test/objects/test_submodule.py | 46 +++++++++++++++++++++++---------------
 1 file changed, 28 insertions(+), 18 deletions(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index 8f7eba35..94675a10 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -25,12 +25,28 @@ class TestSubmodule(TestObjectBase):
 	k_subm_current = "468cad66ff1f80ddaeee4123c24e4d53a032c00d"
 	k_subm_changed = "394ed7006ee5dc8bddfd132b64001d5dfc0ffdd3"
 	k_no_subm_tag = "0.1.6"
-	
+	k_github_gitdb_url = 'git://github.com/gitpython-developers/gitdb.git'
 	env_gitdb_local_path = "GITPYTHON_TEST_GITDB_LOCAL_PATH"
 	
 	def _generate_async_local_path(self):
 		return to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, 'git/ext/async'))
 
+	def _rewrite_gitdb_to_local_path(self, smgitdb):
+		"""Rewrites the given submodule to point to the local path of the gitdb repository, if possible.
+		Otherwise it leaves it unchanged
+		:return: new clone path, or None if no new path was set"""
+		new_smclone_path = os.environ.get(self.env_gitdb_local_path)
+		if new_smclone_path is not None:
+			writer = smgitdb.config_writer()
+			writer.set_value('url', new_smclone_path)
+			del(writer)
+			assert smgitdb.config_reader().get_value('url') == new_smclone_path
+			assert smgitdb.url == new_smclone_path
+		else:
+			sys.stderr.write("Submodule tests need the gitdb repository. You can specify a local source setting the %s environment variable. Otherwise it will be downloaded from the internet" % self.env_gitdb_local_path)
+		#END handle submodule path
+		return new_smclone_path
+
 	def _do_base_tests(self, rwrepo):
 		"""Perform all tests in the given repository, it may be bare or nonbare"""
 		# manual instantiation
@@ -48,7 +64,7 @@ class TestSubmodule(TestObjectBase):
 		
 		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.url == self.k_github_gitdb_url
 		assert sm.branch_path == 'refs/heads/master'			# the default ...
 		assert sm.branch_name == 'master'
 		assert sm.parent_commit == rwrepo.head.commit
@@ -83,17 +99,7 @@ class TestSubmodule(TestObjectBase):
 			# Note: This is nice but doesn't work anymore with the latest git-python
 			# version. This would also mean we need internet for this to work which 
 			# is why we allow an override using an environment variable
-			new_smclone_path = os.environ.get(self.env_gitdb_local_path)
-			if new_smclone_path is not None:
-				writer = sm.config_writer()
-				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
-			else:
-				sys.stderr.write("Submodule tests need the gitdb repository. You can specify a local source setting the %s environment variable. Otherwise it will be downloaded from the internet" % self.env_gitdb_local_path)
-			#END handle submodule path 
-			
+			new_smclone_path = self._rewrite_gitdb_to_local_path(sm)
 		# END handle bare repo
 		smold.config_reader()
 		
@@ -405,7 +411,7 @@ class TestSubmodule(TestObjectBase):
 		
 		# deep traversal git / async
 		rsmsp = [sm.path for sm in rm.traverse()]
-		assert len(rsmsp) == 2			# git and async, async being a child of git
+		assert len(rsmsp) == 1			# git and async, async being a child of git
 		
 		# cannot set the parent commit as root module's path didn't exist
 		self.failUnlessRaises(ValueError, rm.set_parent_commit, 'HEAD')
@@ -425,8 +431,8 @@ class TestSubmodule(TestObjectBase):
 		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)))
+		# assure we clone from a local source
+		self._rewrite_gitdb_to_local_path(sm)
 		
 		# dry-run does nothing
 		sm.update(recursive=False, dry_run=True, progress=prog)
@@ -459,7 +465,7 @@ class TestSubmodule(TestObjectBase):
 		#================
 		nsmn = "newsubmodule"
 		nsmp = "submrepo"
-		async_url = to_native_path_linux(join_path_native(self.rorepo.working_tree_dir, rsmsp[0], rsmsp[1]))
+		async_url = self._generate_async_local_path()
 		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)
@@ -501,7 +507,11 @@ class TestSubmodule(TestObjectBase):
 		# 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]))
+		nsmurl = os.environ.get(self.env_gitdb_local_path, self.k_github_gitdb_url)
+		
+		# Note: We would have liked to have a different url, but we cannot 
+		# provoke this case
+		assert nsm.url != nsmurl
 		nsm.config_writer().set_value('url', nsmurl)
 		csmpathchange = rwrepo.index.commit("changed url")
 		nsm.set_parent_commit(csmpathchange)
-- 
cgit v1.2.3


From f6897c78be5a5530129df50742cb6cabfb8609c9 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 7 Jun 2011 20:06:33 +0200
Subject: Added additional opcodes to remote progress to make it compatible to
 newer git versions. This bug existed for quite a while but didn't show up as
 progress wasn't sent most of the time. All methods that could use a progress
 will only activate it if a progress is actually given

---
 git/test/objects/test_submodule.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'git/test/objects')

diff --git a/git/test/objects/test_submodule.py b/git/test/objects/test_submodule.py
index 94675a10..14cb074c 100644
--- a/git/test/objects/test_submodule.py
+++ b/git/test/objects/test_submodule.py
@@ -15,7 +15,7 @@ import sys
 class TestRootProgress(RootUpdateProgress):
 	"""Just prints messages, for now without checking the correctness of the states"""
 	
-	def update(self, op, index, max_count, message=''):
+	def update(self, op, index, max_count, message='', input=''):
 		print message
 		
 prog = TestRootProgress()
-- 
cgit v1.2.3