Merge lp:~divmod-dev/divmod.org/848493-remove-epsilon-release into lp:divmod.org

[Tristan Seligmann]

[Laurens Van Houtven (lvh)]

LGTM, merging.

review: Approve

=== removed file 'Epsilon/bin/release-divmod'
--- Epsilon/bin/release-divmod	2007-09-25 12:21:26 +0000
+++ Epsilon/bin/release-divmod	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-#!/usr/bin/python
-# Copyright 2007 Divmod, Inc.  See LICENSE file for details
-
-from epsilon.release import main
-main()

=== removed file 'Epsilon/epsilon/release.py'
--- Epsilon/epsilon/release.py	2007-12-03 23:40:32 +0000
+++ Epsilon/epsilon/release.py	1970-01-01 00:00:00 +0000
@@ -1,446 +0,0 @@
-# -*- test-case-name: epsilon.test.test_release -*-
-
-"""
-Automation for most of the release process for Divmod projects.
-"""
-
-import sys, re
-from os import chdir
-
-from twisted.python.reflect import namedModule
-from twisted.python.versions import Version
-from twisted.python.usage import Options
-from twisted.python.filepath import FilePath
-from twisted.python.release import sh, runChdirSafe
-
-from combinator.branchmgr import theBranchManager
-from epsilon.structlike import record
-
-class Project(record("name initPath package version")):
-    """
-    Container for information about a particular Divmod project being released.
-
-    @ivar name: The name of the project.
-    @ivar initPath: A C{FilePath} to the Python package of the project.
-    @ivar package: A module object, the package for this project.
-    @ivar version: The current version of this project.
-    """
-
-verstringMatcher = re.compile(r"^([0-9]+)\.([0-9]+)\.([0-9]+)$")
-
-
-def replaceProjectVersion(filename, newversion):
-    """
-    Write version specification code into the given filename, which
-    sets the version to the given version number.
-
-    @param filename: A filename which is most likely a "_version.py"
-    under some Twisted project.
-    @param newversion: A sequence of three numbers.
-    """
-    f = open(filename, 'w')
-    f.write('''\
-# This is an auto-generated file. Use Epsilon/bin/release-divmod to update.
-from twisted.python import versions
-version = versions.Version(__name__[:__name__.rfind('.')], %s, %s, %s)
-''' % tuple(newversion))
-    f.close()
-
-
-
-def namesToPaths(projectNames, verbose=True):
-    """
-    Turn names of projects into project objects.
-
-    @type projectNames: C{list} of C{str}
-    @param projectNames: The names of Python packages in each project to find
-        and for which to create a L{Project} instance.
-
-    @type verbose: C{bool}
-    @param verbose: If true, report some information about what happens to
-        stdout.
-
-    @rtype: C{list} of L{Project}
-    @return: Project instances for each package in C{projectNames}, with
-        C{name}, C{initPath}, and C{package} set.
-    """
-    projectObjects = []
-    for projName in projectNames:
-        for pfx in '', 'x':
-            try:
-                projPackage = namedModule(pfx + projName)
-            except ImportError:
-                pass
-            else:
-                projPackagePath = FilePath(projPackage.__file__)
-                break
-        else:
-            raise SystemExit("Failed to find Python package for %s."
-                             % (projName,))
-
-        realName = projPackagePath.parent().parent().basename()
-        projectObjects.append(Project(name=realName,
-                                      initPath=projPackagePath,
-                                      package=projPackage,
-                                      version=None))
-        if verbose:
-            print 'Found', projName, 'as', realName, 'at', projPackagePath.path
-    return projectObjects
-
-
-
-def inputNewVersionWithDefault(proj, raw_input=raw_input):
-    """
-    Ask the user to input a new version number for the given project.  Default
-    to the top version in NEWS.txt.
-
-    @type proj: L{Project}
-    @param proj: The project for which to get a version.
-
-    @rtype: L{tuple} of C{int}
-    @return: A three-tuple giving the new major, minor, and micro version.
-    """
-    news = proj.initPath.parent().parent().child("NEWS.txt")
-    if news.exists():
-        f = news.open()
-        defaultVersionString = f.read(16).strip().split(' ')[0]
-    else:
-        defaultVersionString = '0.1.0'
-    match = None
-    while match is None:
-        new_vers = (raw_input("New version for %s (default %s)? "
-                             % (proj.name, defaultVersionString)))
-        if not new_vers:
-            new_vers = defaultVersionString
-        match = verstringMatcher.match(new_vers)
-        if match is None:
-            print 'Invalid format. Use e.g. 2.0.0.'
-
-    major, minor, micro = map(int, match.groups())
-    return major, minor, micro
-
-
-
-def updateVersionFiles(projectObjects, verbose=True,
-                       inputNewVersionWithDefault=inputNewVersionWithDefault,
-                       replaceProjectVersion=replaceProjectVersion):
-    """
-    Gather version information and change _version.py files to contain new
-    version number.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects which will have their version
-        information updated.
-
-    @type verbose: C{bool}
-    @param verbose: If true, report some information about what happens to
-        stdout.
-    """
-    for proj in projectObjects:
-        projVersion = inputNewVersionWithDefault(proj)
-        if projVersion is None:
-            projVersion = proj.package.version
-            projVersion = (projVersion.major, projVersion.minor,
-                           projVersion.micro)
-        projVersionFilePath = proj.initPath.sibling('_version.py')
-        replaceProjectVersion(
-            projVersionFilePath.path,
-            projVersion)
-        proj.version = Version(proj.name, *projVersion)
-        if verbose:
-            print 'Updated version in', projVersionFilePath.path
-
-
-
-def doCommit(rootPath, prompt, msg, sh=sh):
-    """
-    Commit version files and probably NEWS.txt files to version control.
-
-    @type rootPath: L{FilePath}
-    @param rootPath: The root path to commit to version control.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-
-    @type msg: C{str}
-    @param msg: Version control commit message.
-    """
-    cmd = 'svn commit %(rootPath)s -m "%(msg)s"'
-    sh(cmd % {'rootPath': rootPath.path, 'msg': msg},
-       null=False,
-       prompt=prompt)
-
-
-
-def doExport(projectName, rootPath, prompt, theBranchManager=theBranchManager, sh=sh):
-    """
-    Export the repo from SVN into a clean directory.
-
-    @type projectName: C{str}
-    @param projectName: The Combinator name of the project to export.
-
-    @type rootPath: L{FilePath}
-    @param rootPath: The working copy of the SVN path to export.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-
-    @rtype: C{tuple} of L{FilePath} and C{str}
-    @return: The path to which the export was done and the URI which was
-        exported.
-    """
-    branchRelativePath = theBranchManager.currentBranchFor(projectName)
-    branchURI = theBranchManager.projectBranchURI(
-        projectName, branchRelativePath)
-    exportPath = FilePath('.release').temporarySibling()
-    cmd = 'svn export -rHEAD %(rootPath)s %(exportPath)s'
-    sh(cmd % {'rootPath': rootPath.path, 'exportPath': exportPath.path},
-       null=False,
-       prompt=prompt)
-    return exportPath, branchURI
-
-
-
-def doSourceDist(projectObjects, exportPath, prompt, sh=sh, chdir=chdir):
-    """
-    Create tarballs with distutils for each project.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects for which to create tarballs.
-
-    @type exportPath: L{FilePath}
-    @param exportPath: The directory which contains svn exports of all of the
-        projects to operate on.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-    """
-    for proj in projectObjects:
-        def makeSourceRelease():
-            chdir(exportPath.child(proj.name).path)
-            cmd = '%(python)s setup.py sdist'
-            sh(cmd % {'python': sys.executable},
-               null=False,
-               prompt=prompt)
-
-        runChdirSafe(makeSourceRelease)
-
-
-
-def doSourceUnpack(projectObjects, exportPath, prompt, sh=sh, chdir=chdir):
-    """
-    Unpack source tarballs for projects.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects for which to unpack tarballs.
-
-    @type exportPath: L{FilePath}
-    @param exportPath: The directory which contains svn exports of all of the
-        projects to operate on.  These should have previously had tarballs
-        created for them with L{doSourceDist}.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-    """
-    for proj in projectObjects:
-        def unpackSourceRelease():
-            projectExport = exportPath.child(proj.name)
-            chdir(projectExport.child('dist').path)
-            cmd = 'tar xzf %(projectName)s-%(projectVersion)s.tar.gz'
-            sh(cmd % {'projectName': proj.name,
-                      'projectVersion': proj.version.short()},
-               null=False,
-               prompt=prompt)
-
-        runChdirSafe(unpackSourceRelease)
-
-
-
-def doInstall(projectObjects, exportPath, prompt, sh=sh, chdir=chdir):
-    """
-    Run distutils installation for each project.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects to install.
-
-    @type exportPath: L{FilePath}
-    @param exportPath: The directory which contains svn exports of all of the
-        projects to operate on.  These should have previously had tarballs
-        created and unpacked with L{doSourceDist} and L{doSourceUnpack}.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-
-    @rtype: L{FilePath}
-    @return: The installation prefix path.
-    """
-    installPath = FilePath('.install').temporarySibling()
-    for proj in projectObjects:
-        def installSourceRelease():
-            projectExport = exportPath.child(proj.name)
-            projectDir = '%s-%s' % (proj.name, proj.version.short())
-            unpackPath = projectExport.child('dist').child(projectDir)
-            chdir(unpackPath.path)
-            cmd = '%(python)s setup.py install --prefix %(installPath)s'
-            sh(cmd % {'python': sys.executable,
-                      'installPath': installPath.path},
-               null=False,
-               prompt=prompt)
-
-        runChdirSafe(installSourceRelease)
-    return installPath
-
-
-
-def runTests(projectObjects, installPath, prompt, sh=sh):
-    """
-    Run unit tests for each project.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects for which to run tests.
-
-    @type installPath: L{FilePath}
-    @param installPath: The installation prefix path which contains the
-        packages for which to run tests.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-    """
-    # distutils.sysconfig.get_python_lib(prefix=...) might be more appropriate
-    libPath = installPath.child('lib')
-    pythonPath = libPath.child('python%d.%d' % sys.version_info[:2])
-    siteInstallPath = pythonPath.child('site-packages')
-    for proj in projectObjects:
-        def testSourceInstall():
-            cmd = 'PYTHONPATH=%(installPath)s:$PYTHONPATH trial %(projectName)s'
-            sh(cmd % {'installPath': siteInstallPath.path,
-                      'projectName': proj.initPath.parent().basename()},
-               null=False,
-               prompt=prompt)
-
-        runChdirSafe(testSourceInstall)
-
-
-
-def makeTags(projectObjects, repo, branchURI, prompt, sh=sh):
-    """
-    Make SVN tags for the code in these projects.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects for which to make tags.
-
-    @type repo: C{str}
-    @param repo: The segment of the repository URI immediately before the
-        {trunk,branches,tags} segment.
-
-    @type branchURI: C{str}
-    @param branchURI: The URI of the branch for which to create a tag.
-
-    @type prompt: C{bool}
-    @param prompt: If true, ask the user before executing any shell commands.
-    """
-    #XXX Maybe this should be a parameter too?
-    tagRootURI = 'svn+ssh://divmod.org/svn/%s/tags/releases' % (repo,)
-    for proj in projectObjects:
-        def tagRelease():
-            source = '%(branchURI)s/%(projectName)s'
-            dest = '%(tagRootURI)s/%(projectName)s-%(projectVersion)s'
-            cmd = 'svn cp %s %s -m "Tagging release"' % (source, dest)
-            sh(cmd % {'branchURI': branchURI,
-                      'projectName': proj.name,
-                      'tagRootURI': tagRootURI,
-                      'projectVersion': proj.version.short()},
-               null=False,
-               prompt=prompt)
-
-        runChdirSafe(tagRelease)
-
-
-
-def collectTarballs(projectObjects, exportPath, releasePath):
-    """
-    Collect tarballs in the releases/ directory.
-
-    @type projectObjects: C{list} of L{Project} instances
-    @param projectObjects: The projects for which to make tags.
-
-    @type exportPath: L{FilePath}
-    @param exportPath: The directory which contains release tarballs previously
-        generated with L{doSourceDist}.
-
-    @type releasePath: L{FilePath}
-    @param releasePath: A directory which will have a I{releases} subdirectory
-        added to it (if one does not already exist) into which the tarballs
-        will be moved.
-    """
-    releasePath = releasePath.child('releases')
-    if not releasePath.isdir():
-        releasePath.makedirs()
-
-    for proj in projectObjects:
-        def collectTarball():
-            projectExport = exportPath.child(proj.name)
-            releaseFile = '%s-%s.tar.gz' % (proj.name,
-                                            proj.version.short())
-            projectPath = projectExport.child('dist').child(releaseFile)
-            projectPath.moveTo(releasePath.child(releaseFile))
-        runChdirSafe(collectTarball)
-
-
-
-def release(rootPath, repo, projectNames, prompt):
-    """
-    Prompt for new versions of the indicated projects and re-write their
-    version information.
-
-    @type rootPath: L{FilePath}
-    @param rootPath: The root of the working copy from which to release.
-
-    @param projectNames: A C{list} of C{str} which name Python modules for
-    projects in the Divmod repository.
-    """
-    if not projectNames:
-        raise SystemExit("Specify some package names to release.")
-
-    projectObjects = namesToPaths(projectNames)
-    updateVersionFiles(projectObjects)
-
-    doCommit(rootPath, prompt, "Version updates for release")
-    exportPath, branchURI = doExport(repo, rootPath, prompt)
-
-    doSourceDist(projectObjects, exportPath, prompt)
-    doSourceUnpack(projectObjects, exportPath, prompt)
-    installPath = doInstall(projectObjects, exportPath, prompt)
-
-    runTests(projectObjects, installPath, prompt)
-    makeTags(projectObjects, repo, branchURI, prompt)
-    collectTarballs(projectObjects, exportPath, FilePath('.'))
-
-
-
-class ReleaseOptions(Options):
-    optParameters = [['project', 'P', 'Divmod',
-                      'The Combinator-managed project name in which to find '
-                      'the packages being released.']]
-
-    def parseArgs(self, *packages):
-        self['packageNames'] = packages
-
-
-
-def main():
-    """
-    Parse options from C{sys.argv} and perform a release based on them.
-
-    The working directory of the process in which this is called should be the
-    base of a working copy of the release branch which is being used to
-    generate the release.
-
-    Version files for packages being released will be updated and committed, a
-    tag will be created, release tarballs will be generated using distutils,
-    and the results will be unpacked, installed, and have their unit tests run
-    using trial.
-    """
-    o = ReleaseOptions()
-    o.parseOptions(sys.argv[1:])
-    release(FilePath('.'), o['project'], o['packageNames'], True)

=== removed file 'Epsilon/epsilon/test/test_release.py'
--- Epsilon/epsilon/test/test_release.py	2007-12-03 23:40:32 +0000
+++ Epsilon/epsilon/test/test_release.py	1970-01-01 00:00:00 +0000
@@ -1,281 +0,0 @@
-"""
-Tests for Divmod package-release automation.
-"""
-from sys import executable, version_info
-
-from twisted.trial.unittest import TestCase
-from twisted.python.versions import Version
-from twisted.python.filepath import FilePath
-
-import epsilon
-
-from epsilon.release import (
-    namesToPaths, inputNewVersionWithDefault, updateVersionFiles, doCommit,
-    doExport, doSourceDist, doSourceUnpack, doInstall, runTests, makeTags,
-    collectTarballs, replaceProjectVersion, Project)
-
-
-class ReleaseTests(TestCase):
-    """
-    Tests for Divmod package-release automation.
-    """
-    def setUp(self):
-        self.currentDirectory = None
-        self.commands = []
-
-    def test_replaceProjectVersion(self):
-        """
-        Test that replaceProjectVersion generates a _version.py correctly.
-        """
-        f = self.mktemp()
-        replaceProjectVersion(f, (7,8,9))
-        self.assertEqual(open(f).read(), """\
-# This is an auto-generated file. Use Epsilon/bin/release-divmod to update.
-from twisted.python import versions
-version = versions.Version(__name__[:__name__.rfind('.')], 7, 8, 9)
-""")
-
-    def test_namesToPaths(self):
-        """
-        Test that package names get resolved to the correct paths.
-        """
-        project = namesToPaths(["epsilon"], False)[0]
-        self.assertEqual(project.name, "Epsilon")
-        self.assertEqual(project.initPath.path, epsilon.__file__)
-        self.assertEqual(project.package, epsilon)
-
-
-    def test_inputNewVersionWithDefault(self):
-        """
-        L{inputNewVersionWithDefault} should prompt for a new version number,
-        using C{raw_input}, finding the current version number in a I{NEWS.txt}
-        file in the grandparent of the C{initPath} of the project it is passed
-        and supplying that as a default.
-        """
-        projectPath = FilePath(self.mktemp()).child('FakeProject')
-        projectPath.makedirs()
-        projectPath.child('NEWS.txt').setContent('0.9.99')
-
-        packagePath = projectPath.child('fakeproject')
-        initPath = packagePath.child('__init__.py')
-        project = Project(name="FakeProject", initPath=initPath,
-                          package=None, version=None)
-
-        def checkPrompt(prompt):
-            self.assertEqual(prompt, "New version for FakeProject (default 0.9.99)? ")
-            return ""
-
-        self.assertEqual(
-            inputNewVersionWithDefault(project, raw_input=checkPrompt),
-            (0, 9, 99))
-        self.assertEqual(
-            inputNewVersionWithDefault(project, raw_input=lambda _: "6.7.89"),
-            (6, 7, 89))
-
-
-    def test_updateVersionFiles(self):
-        """
-        C{updateVersionFiles} should rewrite I{_version.py} for the packages of
-        the projects it is passed so that they include new version information,
-        as provided by repeated calls to L{inputNewVersionWithDefault}.
-        """
-        initPath = FilePath(self.mktemp())
-        project = Project(name="Epsilon", initPath=initPath,
-                          package=None, version=None)
-        def checkReplaceVersion(path, version):
-            self.assertEqual(path, initPath.sibling("_version.py").path)
-
-        updateVersionFiles(
-            [project], False,
-            inputNewVersionWithDefault=lambda _: (4, 5, 6),
-            replaceProjectVersion=checkReplaceVersion)
-
-        self.assertEqual(project.version.package, "Epsilon")
-        self.assertEqual(project.version.major, 4)
-        self.assertEqual(project.version.minor, 5)
-        self.assertEqual(project.version.micro, 6)
-
-
-    def test_doCommit(self):
-        """
-        C{doCommit} should execute a shell command which does an svn commit on
-        the given path with the given commit message.
-        """
-        commands = []
-        def fakeShell(cmd, null, prompt):
-            commands.append((cmd, null, prompt))
-        def checkSVNCommand(cmd, null, prompt):
-            self.assertEqual(cmd,
-                             'svn commit /test/path -m "a great commit"')
-        doCommit(FilePath("/test/path"),
-                 False, "a great commit",
-                 sh=fakeShell)
-        self.assertEqual(
-            commands,
-            [('svn commit /test/path -m "a great commit"', False, False)])
-
-
-    def test_doExport(self):
-        """
-        C{doExport} should execute a shell command which does an svn export of
-        the current branch of the indicated project to the given path.
-        """
-        currentLookups = []
-        branchLookups = []
-        class FakeBranchManager:
-            def currentBranchFor(self, repo):
-                currentLookups.append(repo)
-                return "branch-1"
-
-            def projectBranchURI(self, repo, relpath):
-                branchLookups.append((repo, relpath))
-                return "http://branch/uri/"
-
-        commands = []
-        def fakeShell(cmd, null, prompt):
-            commands.append((cmd, null, prompt))
-
-        exportPath, branchURI = doExport(
-            'Divmod', FilePath("/test/path"), False,
-            theBranchManager=FakeBranchManager(),
-            sh=fakeShell)
-        self.assertEqual(currentLookups, ["Divmod"])
-        self.assertEqual(branchLookups, [("Divmod", "branch-1")])
-        self.assertEqual(branchURI, "http://branch/uri/")
-        self.assertEqual(
-            commands,
-            [('svn export -rHEAD /test/path ' + exportPath.path,
-              False, False)])
-
-
-    def fakeChdir(self, path):
-        # This is a very dumb implementation of chdir
-        if path.startswith('/'):
-            self.currentDirectory = path
-        else:
-            raise NotImplementedError("Sorry - path logic too difficult.")
-
-
-    def fakeShell(self, command, null, prompt):
-        self.commands.append((self.currentDirectory, command, null, prompt))
-
-
-    def test_doSourceDist(self):
-        """
-        C{doSourceDist} should execute a shell command which runs the I{sdist}
-        subcommand of the I{setup.py} for each project given.
-        """
-        project = Project(name="Foo", initPath=FilePath(self.mktemp()),
-                          package=None, version=None)
-        doSourceDist(
-            [project], FilePath("/test/path"), False,
-            sh=self.fakeShell, chdir=self.fakeChdir)
-
-        self.assertEqual(
-            self.commands,
-            [("/test/path/Foo",
-              executable + " setup.py sdist", False, False)])
-
-
-    def test_doSourceUnpack(self):
-        """
-        C{doSourceUnpack} should execute a shell command which runs an untar
-        command on the release tarball for the given projects.  It should run
-        each command in the dist directory of the corresponding project.
-        """
-        project = Project(name="Foo", initPath=FilePath(self.mktemp()),
-                          version=Version("Foo", 1, 2, 3), package=None)
-
-        doSourceUnpack(
-            [project], FilePath("/test/path"), False,
-            sh=self.fakeShell, chdir=self.fakeChdir)
-
-        self.assertEqual(
-            self.commands,
-            [("/test/path/Foo/dist",
-              "tar xzf Foo-1.2.3.tar.gz", False, False)])
-
-
-    def test_doInstall(self):
-        """
-        C{doInstall} should execute a shell command which runs the I{install}
-        subcommand of the I{setup.py} for each project given.  It should run
-        each command in the unpacked source directory of each project.
-        """
-        project = Project(name="Foo", initPath=FilePath(self.mktemp()),
-                          version=Version("Foo", 1, 2, 3), package=None)
-
-        installedPath = doInstall(
-            [project], FilePath("/test/path"), False,
-            sh=self.fakeShell, chdir=self.fakeChdir)
-
-        self.assertEqual(
-            self.commands,
-            [("/test/path/Foo/dist/Foo-1.2.3",
-              executable + " setup.py install --prefix " + installedPath.path,
-              False, False)])
-
-
-    def test_runTests(self):
-        """
-        C{runTests} should execute a shell command which runs the unit tests
-        for all of the given projects.
-        """
-        prefix = "/test/path/lib/python%d.%d/site-packages" % version_info[:2]
-        initPath = FilePath(prefix).child("foo").child("__init__.py")
-        runTests(
-            [Project(name="Foo", initPath=initPath,
-                     package=None, version=None)],
-            FilePath("/test/path"), False,
-            sh=self.fakeShell)
-
-        path = [prefix, '$PYTHONPATH']
-        self.assertEqual(
-            self.commands,
-            [(None,
-              "PYTHONPATH=" + ":".join(path) + " trial foo",
-              False, False)])
-
-
-    def test_makeTags(self):
-        """
-        C{makeTags} should execute a shell command which creates a release tag
-        of the given release branch for each given project.
-        """
-        project = Project(name="Foo", initPath=self.mktemp(),
-                          version=Version("Foo", 1, 2, 3), package=None)
-        makeTags(
-            [project], "Stuff",
-            "svn+ssh://divmod.org/svn/Stuff/branches/release-1",
-            False,
-            sh=self.fakeShell)
-
-        self.assertEqual(
-            self.commands,
-            [(None,
-              "svn cp svn+ssh://divmod.org/svn/Stuff/branches/release-1/Foo "
-              "svn+ssh://divmod.org/svn/Stuff/tags/releases/Foo-1.2.3 "
-              '-m "Tagging release"', False, False)])
-
-
-    def test_collectTarballs(self):
-        """
-        C{collectTarballs} should move the release tarball for each given
-        project into a directory named I{releases} of the current working
-        directory.
-        """
-        moves = []
-        class FakeFilePath(FilePath):
-            def moveTo(self, target):
-                moves.append((self, target))
-        FakeFilePath.clonePath = FakeFilePath
-        project = Project(name="Foo", initPath=FakeFilePath(self.mktemp()),
-                          version=Version("Foo", 1, 2, 3), package=None)
-        releasePath = FilePath(self.mktemp())
-        collectTarballs([project], FakeFilePath("/test/path"), releasePath)
-        self.assertEqual(
-            moves,
-            [(FilePath('/test/path/Foo/dist/Foo-1.2.3.tar.gz'),
-              releasePath.child('releases').child('Foo-1.2.3.tar.gz'))])
-
-