diff --git a/Makefile b/Makefile
index 372be39f..706ab0ac 100644
--- a/Makefile
+++ b/Makefile
@@ -1,71 +1,71 @@
 PYTHON = python -Werror
 PYFLAKES = pyflakes
 PEP8 = pep8
 FLAKE8 ?= flake8
 SETUP = $(PYTHON) setup.py
 PYDOCTOR ?= pydoctor
 TESTRUNNER ?= unittest
-RUNTEST = PYTHONHASHSEED=random PYTHONPATH=$(shell pwd):$(PYTHONPATH) $(PYTHON) -m $(TESTRUNNER) $(TEST_OPTIONS)
+RUNTEST = PYTHONHASHSEED=random PYTHONPATH=$(shell pwd)$(if $(PYTHONPATH),:$(PYTHONPATH),) $(PYTHON) -m $(TESTRUNNER) $(TEST_OPTIONS)
 COVERAGE = python3-coverage
 
 DESTDIR=/
 
 all: build
 
 doc:: pydoctor
 doc:: sphinx
 
 sphinx::
 	$(MAKE) -C docs html
 
 pydoctor::
 	$(PYDOCTOR) --make-html -c dulwich.cfg
 
 build::
 	$(SETUP) build
 	$(SETUP) build_ext -i
 
 install::
 	$(SETUP) install --root="$(DESTDIR)"
 
 check:: build
 	$(RUNTEST) dulwich.tests.test_suite
 
 check-tutorial:: build
 	$(RUNTEST) dulwich.tests.tutorial_test_suite
 
 check-nocompat:: build
 	$(RUNTEST) dulwich.tests.nocompat_test_suite
 
 check-compat:: build
 	$(RUNTEST) dulwich.tests.compat_test_suite
 
 check-pypy:: clean
 	$(MAKE) check-noextensions PYTHON=pypy
 
 check-noextensions:: clean
 	$(RUNTEST) dulwich.tests.test_suite
 
 check-all: check check-pypy check-noextensions
 
 clean::
 	$(SETUP) clean --all
 	rm -f dulwich/*.so
 
 flakes:
 	$(PYFLAKES) dulwich
 
 pep8:
 	$(PEP8) dulwich
 
 style:
 	$(FLAKE8) --exclude=build,.git,build-pypy,.tox
 
 before-push: check
 	git diff origin/master | $(PEP8) --diff
 
 coverage:
 	$(COVERAGE) run --source=dulwich -m unittest dulwich.tests.test_suite dulwich.contrib.test_suite
 
 coverage-html: coverage
 	$(COVERAGE) html
diff --git a/dulwich/tests/__init__.py b/dulwich/tests/__init__.py
index daed1f11..41656041 100644
--- a/dulwich/tests/__init__.py
+++ b/dulwich/tests/__init__.py
@@ -1,184 +1,193 @@
 # __init__.py -- The tests for dulwich
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for Dulwich."""
 
 import doctest
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 
 
 # If Python itself provides an exception, use that
 import unittest
 from unittest import (  # noqa: F401
     SkipTest,
     TestCase as _TestCase,
     skipIf,
     expectedFailure,
     )
 
 
 class TestCase(_TestCase):
 
     def setUp(self):
         super(TestCase, self).setUp()
         self._old_home = os.environ.get("HOME")
         os.environ["HOME"] = "/nonexistant"
 
     def tearDown(self):
         super(TestCase, self).tearDown()
         if self._old_home:
             os.environ["HOME"] = self._old_home
         else:
             del os.environ["HOME"]
 
 
 class BlackboxTestCase(TestCase):
     """Blackbox testing."""
 
     # TODO(jelmer): Include more possible binary paths.
     bin_directories = [os.path.abspath(os.path.join(
             os.path.dirname(__file__), "..", "..", "bin")), '/usr/bin',
             '/usr/local/bin']
 
     def bin_path(self, name):
         """Determine the full path of a binary.
 
         :param name: Name of the script
         :return: Full path
         """
         for d in self.bin_directories:
             p = os.path.join(d, name)
             if os.path.isfile(p):
                 return p
         else:
             raise SkipTest("Unable to find binary %s" % name)
 
     def run_command(self, name, args):
         """Run a Dulwich command.
 
         :param name: Name of the command, as it exists in bin/
         :param args: Arguments to the command
         """
         env = dict(os.environ)
         env["PYTHONPATH"] = os.pathsep.join(sys.path)
 
         # Since they don't have any extensions, Windows can't recognize
         # executablility of the Python files in /bin. Even then, we'd have to
         # expect the user to set up file associations for .py files.
         #
         # Save us from all that headache and call python with the bin script.
         argv = [sys.executable, self.bin_path(name)] + args
         return subprocess.Popen(
                 argv,
                 stdout=subprocess.PIPE,
                 stdin=subprocess.PIPE, stderr=subprocess.PIPE,
                 env=env)
 
 
 def self_test_suite():
     names = [
         'archive',
         'blackbox',
         'client',
         'config',
         'diff_tree',
         'fastexport',
         'file',
         'grafts',
         'greenthreads',
         'hooks',
         'ignore',
         'index',
         'lru_cache',
         'mailmap',
         'objects',
         'objectspec',
         'object_store',
         'missing_obj_finder',
         'pack',
         'patch',
         'porcelain',
         'protocol',
         'reflog',
         'refs',
         'repository',
         'server',
         'utils',
         'walk',
         'web',
         ]
     module_names = ['dulwich.tests.test_' + name for name in names]
     loader = unittest.TestLoader()
     return loader.loadTestsFromNames(module_names)
 
 
 def tutorial_test_suite():
+    import dulwich.client
+    import dulwich.config
+    import dulwich.index
+    import dulwich.reflog
+    import dulwich.repo
+    import dulwich.server
+    import dulwich.patch
     tutorial = [
         'introduction',
         'file-format',
         'repo',
         'object-store',
         'remote',
         'conclusion',
         ]
     tutorial_files = ["../../docs/tutorial/%s.txt" % name for name in tutorial]
 
     def setup(test):
         test.__old_cwd = os.getcwd()
-        test.__dulwich_tempdir = tempfile.mkdtemp()
-        os.chdir(test.__dulwich_tempdir)
+        test.tempdir = tempfile.mkdtemp()
+        test.globs.update({'tempdir': test.tempdir})
+        os.chdir(test.tempdir)
 
     def teardown(test):
         os.chdir(test.__old_cwd)
-        shutil.rmtree(test.__dulwich_tempdir)
+        shutil.rmtree(test.tempdir)
     return doctest.DocFileSuite(
+            module_relative=True, package='dulwich.tests',
             setUp=setup, tearDown=teardown, *tutorial_files)
 
 
 def nocompat_test_suite():
     result = unittest.TestSuite()
     result.addTests(self_test_suite())
     result.addTests(tutorial_test_suite())
     from dulwich.contrib import test_suite as contrib_test_suite
     result.addTests(contrib_test_suite())
     return result
 
 
 def compat_test_suite():
     result = unittest.TestSuite()
     from dulwich.tests.compat import test_suite as compat_test_suite
     result.addTests(compat_test_suite())
     return result
 
 
 def test_suite():
     result = unittest.TestSuite()
     result.addTests(self_test_suite())
     if sys.platform != 'win32':
         result.addTests(tutorial_test_suite())
     from dulwich.tests.compat import test_suite as compat_test_suite
     result.addTests(compat_test_suite())
     from dulwich.contrib import test_suite as contrib_test_suite
     result.addTests(contrib_test_suite())
     return result