divmod-dev team mailing list archive
-
divmod-dev team
-
Mailing list archive
-
Message #00488
[Merge] lp:~divmod-dev/divmod.org/848493-remove-epsilon-release into lp:divmod.org
Tristan Seligmann has proposed merging lp:~divmod-dev/divmod.org/848493-remove-epsilon-release into lp:divmod.org.
Requested reviews:
Divmod-dev (divmod-dev)
Related bugs:
Bug #848493 in Divmod Axiom: "Incorrect extension of PYTHONPATH"
https://bugs.launchpad.net/divmod-axiom/+bug/848493
For more details, see:
https://code.launchpad.net/~divmod-dev/divmod.org/848493-remove-epsilon-release/+merge/178441
--
https://code.launchpad.net/~divmod-dev/divmod.org/848493-remove-epsilon-release/+merge/178441
Your team Divmod-dev is requested to review the proposed merge of lp:~divmod-dev/divmod.org/848493-remove-epsilon-release into lp:divmod.org.
=== 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'))])
-
-
Follow ups
