#! /usr/bin/python import os, sys import posixpath import shutil import tarfile import unittest import tempfile import re from unittest import mock from pathlib import Path from pkg_resources import parse_version sys.path.insert(0, "src") import common from render import render from git import from_vcs, from_keywords from subprocess_helper import run_command DEFAULT_PYPROJECT = """\ [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" """ class ParseGitDescribe(unittest.TestCase): def setUp(self): self.fakeroot = tempfile.mkdtemp() self.fakegit = os.path.join(self.fakeroot, ".git") os.mkdir(self.fakegit) def test_pieces(self): def pv(git_describe, do_error=False, expect_pieces=False, branch_name="master"): def fake_run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): if args[0] == "describe": if do_error == "describe": return None, 0 return git_describe+"\n", 0 if args[0] == "rev-parse": if do_error == "rev-parse": return None, 0 if args[1] == "--abbrev-ref": return "%s\n" % branch_name, 0 else: return "longlong\n", 0 if args[0] == "rev-list": return ">hashhashhashhashhashhashhashhash\n" * 42, 0 if args[0] == "show": if do_error == "show": return "gpg: signature\n12345\n", 0 return "12345\n", 0 if args[0] == "branch": return "* (no branch)\n" \ " contained-branch-1\n" \ " contained-branch-2", 0 self.fail("git called in weird way: %s" % (args,)) return from_vcs.git_pieces_from_vcs( "v", self.fakeroot, verbose=False, runner=fake_run_command) self.assertRaises(from_vcs.NotThisMethod, pv, "ignored", do_error="describe") self.assertRaises(from_vcs.NotThisMethod, pv, "ignored", do_error="rev-parse") self.assertEqual(pv("1f"), {"closest-tag": None, "dirty": False, "error": None, "distance": 42, "long": "longlong", "short": "longlon", "date": "12345", "branch": "master"}) self.assertEqual(pv("1f", do_error="show"), {"closest-tag": None, "dirty": False, "error": None, "distance": 42, "long": "longlong", "short": "longlon", "date": "12345", "branch": "master"}) self.assertEqual(pv("1f-dirty"), {"closest-tag": None, "dirty": True, "error": None, "distance": 42, "long": "longlong", "short": "longlon", "date": "12345", "branch": "master"}) self.assertEqual(pv("v1.0-0-g1f"), {"closest-tag": "1.0", "dirty": False, "error": None, "distance": 0, "long": "longlong", "short": "1f", "date": "12345", "branch": "master"}) self.assertEqual(pv("v1.0-0-g1f-dirty"), {"closest-tag": "1.0", "dirty": True, "error": None, "distance": 0, "long": "longlong", "short": "1f", "date": "12345", "branch": "master"}) self.assertEqual(pv("v1.0-1-g1f"), {"closest-tag": "1.0", "dirty": False, "error": None, "distance": 1, "long": "longlong", "short": "1f", "date": "12345", "branch": "master"}) self.assertEqual(pv("v1.0-1-g1f-dirty"), {"closest-tag": "1.0", "dirty": True, "error": None, "distance": 1, "long": "longlong", "short": "1f", "date": "12345", "branch": "master"}) self.assertEqual(pv("v1.0-1-g1f-dirty", branch_name="feature-branch"), {"closest-tag": "1.0", "dirty": True, "error": None, "distance": 1, "long": "longlong", "short": "1f", "date": "12345", "branch": "feature-branch"}) self.assertEqual(pv("v1.0-1-g1f-dirty", branch_name="HEAD"), {"closest-tag": "1.0", "dirty": True, "error": None, "distance": 1, "long": "longlong", "short": "1f", "date": "12345", "branch": "contained-branch-1"}) def tearDown(self): os.rmdir(self.fakegit) os.rmdir(self.fakeroot) class Keywords(unittest.TestCase): def parse(self, refnames, full, prefix="", date=None): return from_keywords.git_versions_from_keywords( {"refnames": refnames, "full": full, "date": date}, prefix, False) def test_parse(self): v = self.parse(" (HEAD, 2.0,master , otherbranch ) ", " full ") self.assertEqual(v["version"], "2.0") self.assertEqual(v["full-revisionid"], "full") self.assertEqual(v["dirty"], False) self.assertEqual(v["error"], None) self.assertEqual(v["date"], None) def test_prefer_short(self): v = self.parse(" (HEAD, 2.0rc1, 2.0, 2.0rc2) ", " full ") self.assertEqual(v["version"], "2.0") self.assertEqual(v["full-revisionid"], "full") self.assertEqual(v["dirty"], False) self.assertEqual(v["error"], None) self.assertEqual(v["date"], None) def test_prefix(self): v = self.parse(" (HEAD, projectname-2.0) ", " full ", "projectname-") self.assertEqual(v["version"], "2.0") self.assertEqual(v["full-revisionid"], "full") self.assertEqual(v["dirty"], False) self.assertEqual(v["error"], None) self.assertEqual(v["date"], None) def test_unexpanded(self): self.assertRaises(from_keywords.NotThisMethod, self.parse, " $Format$ ", " full ", "projectname-") def test_no_tags(self): v = self.parse("(HEAD, master)", "full") self.assertEqual(v["version"], "0+unknown") self.assertEqual(v["full-revisionid"], "full") self.assertEqual(v["dirty"], False) self.assertEqual(v["error"], "no suitable tags") self.assertEqual(v["date"], None) def test_no_prefix(self): v = self.parse("(HEAD, master, 1.23)", "full", "missingprefix-") self.assertEqual(v["version"], "0+unknown") self.assertEqual(v["full-revisionid"], "full") self.assertEqual(v["dirty"], False) self.assertEqual(v["error"], "no suitable tags") self.assertEqual(v["date"], None) def test_date(self): date = "2017-07-24 16:03:40 +0200" result = "2017-07-24T16:03:40+0200" v = self.parse(" (HEAD, 2.0,master , otherbranch ) ", " full ", date=date) self.assertEqual(v["date"], result) def test_date_gpg(self): date = """ gpg: Signature information gpg: ... 2017-07-24 16:03:40 +0200""" result = "2017-07-24T16:03:40+0200" v = self.parse(" (HEAD, 2.0,master , otherbranch ) ", " full ", date=date) self.assertEqual(v["date"], result) expected_renders = """ closest-tag: 1.0 distance: 0 dirty: False branch: feature pep440: 1.0 pep440-branch: 1.0 pep440-pre: 1.0 pep440-post: 1.0 pep440-post-branch: 1.0 pep440-old: 1.0 git-describe: 1.0 git-describe-long: 1.0-0-g250b7ca closest-tag: 1.0 distance: 0 dirty: True branch: master pep440: 1.0+0.g250b7ca.dirty pep440-branch: 1.0+0.g250b7ca.dirty pep440-pre: 1.0 pep440-post: 1.0.post0.dev0+g250b7ca pep440-post-branch: 1.0.post0+g250b7ca.dirty pep440-old: 1.0.post0.dev0 git-describe: 1.0-dirty git-describe-long: 1.0-0-g250b7ca-dirty closest-tag: 1.0 distance: 1 dirty: False branch: master pep440: 1.0+1.g250b7ca pep440-branch: 1.0+1.g250b7ca pep440-pre: 1.0.post0.dev1 pep440-post: 1.0.post1+g250b7ca pep440-post-branch: 1.0.post1+g250b7ca pep440-old: 1.0.post1 git-describe: 1.0-1-g250b7ca git-describe-long: 1.0-1-g250b7ca closest-tag: 1.0 distance: 1 dirty: True branch: feature pep440: 1.0+1.g250b7ca.dirty pep440-branch: 1.0.dev0+1.g250b7ca.dirty pep440-pre: 1.0.post0.dev1 pep440-post: 1.0.post1.dev0+g250b7ca pep440-post-branch: 1.0.post1.dev0+g250b7ca.dirty pep440-old: 1.0.post1.dev0 git-describe: 1.0-1-g250b7ca-dirty git-describe-long: 1.0-1-g250b7ca-dirty closest-tag: 1.0+plus distance: 1 dirty: False branch: feature pep440: 1.0+plus.1.g250b7ca pep440-branch: 1.0+plus.dev0.1.g250b7ca pep440-pre: 1.0+plus.post0.dev1 pep440-post: 1.0+plus.post1.g250b7ca pep440-post-branch: 1.0+plus.post1.dev0.g250b7ca pep440-old: 1.0+plus.post1 git-describe: 1.0+plus-1-g250b7ca git-describe-long: 1.0+plus-1-g250b7ca closest-tag: 1.0+plus distance: 1 dirty: True branch: master pep440: 1.0+plus.1.g250b7ca.dirty pep440-branch: 1.0+plus.1.g250b7ca.dirty pep440-pre: 1.0+plus.post0.dev1 pep440-post: 1.0+plus.post1.dev0.g250b7ca pep440-post-branch: 1.0+plus.post1.g250b7ca.dirty pep440-old: 1.0+plus.post1.dev0 git-describe: 1.0+plus-1-g250b7ca-dirty git-describe-long: 1.0+plus-1-g250b7ca-dirty closest-tag: None distance: 1 dirty: False branch: master pep440: 0+untagged.1.g250b7ca pep440-branch: 0+untagged.1.g250b7ca pep440-pre: 0.post0.dev1 pep440-post: 0.post1+g250b7ca pep440-post-branch: 0.post1+g250b7ca pep440-old: 0.post1 git-describe: 250b7ca git-describe-long: 250b7ca closest-tag: None distance: 1 dirty: True branch: feature pep440: 0+untagged.1.g250b7ca.dirty pep440-branch: 0.dev0+untagged.1.g250b7ca.dirty pep440-pre: 0.post0.dev1 pep440-post: 0.post1.dev0+g250b7ca pep440-post-branch: 0.post1.dev0+g250b7ca.dirty pep440-old: 0.post1.dev0 git-describe: 250b7ca-dirty git-describe-long: 250b7ca-dirty """ class RenderPieces(unittest.TestCase): def do_render(self, pieces): out = {} for style in ["pep440", "pep440-branch", "pep440-pre", "pep440-post", "pep440-post-branch", "pep440-old", "git-describe", "git-describe-long"]: out[style] = render(pieces, style)["version"] DEFAULT = "pep440" self.assertEqual(render(pieces, ""), render(pieces, DEFAULT)) self.assertEqual(render(pieces, "default"), render(pieces, DEFAULT)) return out def parse_expected(self): base_pieces = {"long": "250b7ca731388d8f016db2e06ab1d6289486424b", "short": "250b7ca", "error": None} more_pieces = {} expected = {} for line in expected_renders.splitlines(): line = line.strip() if not line: if more_pieces and expected: pieces = base_pieces.copy() pieces.update(more_pieces) yield (pieces, expected) more_pieces = {} expected = {} continue name, value = line.split(":") name = name.strip() value = value.strip() if name == "distance": more_pieces["distance"] = int(value) elif name == "dirty": more_pieces["dirty"] = bool(value.lower() == "true") elif name == "closest-tag": more_pieces["closest-tag"] = value if value == "None": more_pieces["closest-tag"] = None elif name == "branch": more_pieces["branch"] = value else: expected[name] = value if more_pieces and expected: pieces = base_pieces.copy() pieces.update(more_pieces) yield (pieces, expected) def test_render(self): for (pieces, expected) in self.parse_expected(): got = self.do_render(pieces) for key in expected: self.assertEqual(got[key], expected[key], (pieces, key, got[key], expected[key])) VERBOSE = False class Repo(common.Common, unittest.TestCase): # There are six tree states we're interested in: # S1: sitting on the initial commit, no tags # S2: dirty tree after the initial commit # S3: sitting on the 1.0 tag # S4: dirtying the tree after 1.0 # S5: making a new commit after 1.0, clean tree # S6: dirtying the tree after the post-1.0 commit # # Then we're interested in 6 kinds of trees: # TA: source tree (with .git) # TB: source tree without .git (should get 'unknown') # TC: source tree without .git unpacked into prefixdir # TD: git-archive tarball # TE: unpacked sdist tarball (python setup.py sdist) # TF: unpacked sdist tarball (python -m build -s) # # In three runtime situations: # RA1: setup.py --version # RA2: ...path/to/setup.py --version (from outside the source tree) # RB: setup.py build; rundemo --version # # We can only detect dirty files in real git trees, so we don't examine # S2/S4/S6 for TB/TC/TD/TE, or RB. # note that the repo being manipulated is always named "demoapp", # regardless of which source directory we copied it from (test/demoapp/ # or test/demoapp-script-only/) def test_full(self): self.run_test("test/demoapp", False, ".", False) def test_script_only(self): # This test looks at an application that consists entirely of a # script: no libraries (so its setup.py has packages=[]). This sort # of app cannot be run from source: you must 'setup.py build' to get # anything executable. So of the 3 runtime situations examined by # Repo.test_full above, we only care about RB. (RA1 is valid too, but # covered by Repo). self.run_test("test/demoapp-script-only", True, ".", False) def test_project_in_subdir(self): # This test sets of the git repository so that the python project -- # i.e. setup.py -- is not located in the root directory self.run_test("test/demoapp", False, "project", False) def test_no_tag_prefix(self): self.run_test("test/demoapp", False, ".", False, tag_prefix="") def test_pyproject(self): self.run_test("test/demoapp-pyproject", False, ".", True) def run_test(self, demoapp_dir, script_only, project_sub_dir, pep518, tag_prefix=None): # The test dir should live under /tmp/ or /var/ or somewhere that # isn't the child of the versioneer repo's .git directory, since that # will confuse the tests that check what happens when there is no # .git parent. So if you change this to use a fixed directory (say, # when debugging problems), use /tmp/_test rather than ./_test . self.testdir = tempfile.mkdtemp() if VERBOSE: print("testdir: %s" % (self.testdir,)) if os.path.exists(self.testdir): self.rmtree(self.testdir) # Our tests run from a git repo that lives here. All self.git() # operations run from this directory unless overridden. self.gitdir = os.path.join(self.testdir, "demoapp") # Inside that git repo, the project (with setup.py, setup.cfg, and # versioneer.py) lives inside this directory. All self.python() and # self.command() operations run from this directory unless # overridden. self.project_sub_dir = project_sub_dir self.projdir = os.path.join(self.testdir, self.gitdir, self.project_sub_dir) # Extra repository to try to mess with GIT_DIR and check resilience self.extra_git_dir = os.path.join(self.testdir, "extra_git") os.mkdir(self.testdir) os.mkdir(self.extra_git_dir) self.git("init", workdir=self.extra_git_dir) shutil.copytree(demoapp_dir, self.projdir) setup_cfg_fn = self.project_file("setup.cfg") if os.path.exists(setup_cfg_fn): with open(setup_cfg_fn, "r") as f: setup_cfg = f.read() setup_cfg = setup_cfg.replace("@VCS@", "git") tag_prefix_regex = "tag_prefix = (.*)" if tag_prefix is None: tag_prefix = re.search(tag_prefix_regex, setup_cfg).group(1) else: setup_cfg = re.sub(tag_prefix_regex, f"tag_prefix = {tag_prefix}", setup_cfg) with open(setup_cfg_fn, "w") as f: f.write(setup_cfg) if pep518: # Set test versioneer build-system.requires entry to @ file:/// # so that `python -m build` picks it up. pyproject_path = Path(self.project_file("pyproject.toml")) versioneer_source_root = Path(__file__).absolute().parent.parent.parent vsr = str(versioneer_source_root).replace("\\", "/") # For testing on Windows... pyproject_toml = pyproject_path.read_text() pyproject_toml = pyproject_toml.replace("@REPOROOT@", f"file://{vsr}") # Update versioneer config pyproject_toml = pyproject_toml.replace("@VCS@", "git") tag_prefix_regex = 'tag_prefix = "(.*)"' if tag_prefix is None: tag_prefix = re.search(tag_prefix_regex, pyproject_toml).group(1) else: pyproject_toml = re.sub(tag_prefix_regex, f'tag_prefix = "{tag_prefix}"', pyproject_toml) pyproject_path.write_text(pyproject_toml) else: shutil.copyfile("versioneer.py", self.project_file("versioneer.py")) self.git("init") self.git("add", "--all") self.git("commit", "-m", "comment") full = self.git("rev-parse", "HEAD") v = self.python("setup.py", "--version") self.assertEqual(v, "0+untagged.1.g%s" % full[:7]) v = self.python(self.project_file("setup.py"), "--version", workdir=self.testdir) self.assertEqual(v, "0+untagged.1.g%s" % full[:7]) if pep518: out = self.python("-m", "versioneer", "install", "--no-vendor").splitlines() else: out = self.python("versioneer.py", "setup").splitlines() self.assertEqual(out[0], "creating src/demo/_version.py") init = os.path.join("src/demo", "__init__.py") if script_only: self.assertEqual(out[1], f" {init} doesn't exist, ok") else: self.assertEqual(out[1], f" appending to {init}") # Many folks have a ~/.gitignore with ignores .pyc files, but if they # don't, it will show up in the status here. Ignore it. def remove_pyc(s): return [f for f in s if not (f.startswith("?? ") and (f.endswith(".pyc") or f.endswith("__pycache__/"))) ] out = set(remove_pyc(self.git("status", "--porcelain").splitlines())) def pf(fn): return posixpath.normpath(posixpath.join(self.project_sub_dir, fn)) expected = {"A %s" % pf(".gitattributes"), "A %s" % pf("src/demo/_version.py"), } if not script_only: expected.add("M %s" % pf("src/demo/__init__.py")) self.assertEqual(out, expected) if not script_only: with open(self.project_file("src/demo/__init__.py")) as fobj: i = fobj.read().splitlines() self.assertEqual(i[-2], "from . import _version") self.assertEqual(i[-1], "__version__ = _version.get_versions()['version']") self.git("commit", "-m", "add _version stuff") # "versioneer.py setup" should be idempotent if pep518: out = self.python("-m", "versioneer", "install", "--no-vendor").splitlines() else: out = self.python("versioneer.py", "setup").splitlines() self.assertEqual(out[0], "creating src/demo/_version.py") if script_only: self.assertEqual(out[1], f" {init} doesn't exist, ok") else: self.assertEqual(out[1], f" {init} unmodified") out = set(remove_pyc(self.git("status", "--porcelain").splitlines())) self.assertEqual(out, set()) UNABLE = "unable to compute version" NOTAG = "no suitable tags" # S1: the tree is sitting on a pre-tagged commit full = self.git("rev-parse", "HEAD") short = "0+untagged.2.g%s" % full[:7] self.do_checks("S1", {"TA": [short, full, False, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, False, None], "TD": ["0+unknown", full, False, NOTAG], "TE": [short, full, False, None], "TF": [short, full, False, None], }) # TD: expanded keywords only tell us about tags and full revisionids, # not how many patches we are beyond a tag. So any TD git-archive # tarball from a non-tagged version will give us an error. "dirty" is # False, since the tree from which the tarball was created is # necessarily clean. # S2: dirty the pre-tagged tree with open(self.project_file("setup.py"), "a") as fobj: fobj.write("# dirty\n") full = self.git("rev-parse", "HEAD") short = "0+untagged.2.g%s.dirty" % full[:7] self.do_checks("S2", {"TA": [short, full, True, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, True, None], "TD": ["0+unknown", full, False, NOTAG], "TE": [short, full, True, None], "TF": [short, full, True, None], }) # S3: we commit that change, then make the first tag (1.0) self.git("add", self.project_file("setup.py")) self.git("commit", "-m", "dirty") self.git("tag", f"{tag_prefix}1.0") # also add an unrelated tag, to test exclusion. git-describe appears # to return the highest lexicographically-sorted tag, so make sure # the unrelated one sorts earlier self.git("tag", "aaa-999") full = self.git("rev-parse", "HEAD") short = "1.0" if VERBOSE: print("FULL %s" % full) # the tree is now sitting on the 1.0 tag self.do_checks("S3", {"TA": [short, full, False, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, False, None], "TD": [short, full, False, None], "TE": [short, full, False, None], "TF": [short, full, False, None], }) # S4: now we dirty the tree with open(self.project_file("setup.py"), "a") as fobj: fobj.write("# dirty\n") full = self.git("rev-parse", "HEAD") short = "1.0+0.g%s.dirty" % full[:7] self.do_checks("S4", {"TA": [short, full, True, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, True, None], "TD": ["1.0", full, False, None], "TE": [short, full, True, None], "TF": [short, full, True, None], }) # S5: now we make one commit past the tag self.git("add", self.project_file("setup.py")) self.git("commit", "-m", "dirty") full = self.git("rev-parse", "HEAD") short = "1.0+1.g%s" % full[:7] self.do_checks("S5", {"TA": [short, full, False, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, False, None], "TD": ["0+unknown", full, False, NOTAG], "TE": [short, full, False, None], "TF": [short, full, False, None], }) # S6: dirty the post-tag tree with open(self.project_file("setup.py"), "a") as fobj: fobj.write("# more dirty\n") full = self.git("rev-parse", "HEAD") short = "1.0+1.g%s.dirty" % full[:7] self.do_checks("S6", {"TA": [short, full, True, None], "TB": ["0+unknown", None, None, UNABLE], "TC": [short, full, True, None], "TD": ["0+unknown", full, False, NOTAG], "TE": [short, full, True, None], "TF": [short, full, True, None], }) def do_checks(self, state, exps): if os.path.exists(self.subpath("out")): self.rmtree(self.subpath("out")) # TA: project tree self.check_version(self.projdir, state, "TA", exps["TA"]) # TA2: GIT_DIR has no effect when in git repository GIT_DIR = os.path.join(self.extra_git_dir, ".git") with mock.patch.dict(os.environ, {"GIT_DIR": GIT_DIR}): self.check_version(self.projdir, state, "TA", exps["TA"]) # TB: .git-less copy of project tree target = self.subpath("out/demoapp-TB") shutil.copytree(self.projdir, target) if os.path.exists(os.path.join(target, ".git")): self.rmtree(os.path.join(target, ".git")) self.check_version(target, state, "TB", exps["TB"]) # TC: project tree in versionprefix-named parentdir target = self.subpath("out/demo-1.1") shutil.copytree(self.projdir, target) if os.path.exists(os.path.join(target, ".git")): self.rmtree(os.path.join(target, ".git")) self.check_version(target, state, "TC", ["1.1", None, False, None]) # XXX # TD: project subdir of an unpacked git-archive tarball target = self.subpath("out/TD/demoapp-TD") self.git("archive", "--format=tar", "--prefix=demoapp-TD/", "--output=../demo.tar", "HEAD") os.mkdir(self.subpath("out/TD")) with tarfile.TarFile(self.subpath("demo.tar")) as t: t.extractall(path=self.subpath("out/TD")) self.check_version(os.path.join(target, self.project_sub_dir), state, "TD", exps["TD"]) # TE: unpacked setup.py sdist tarball dist_path = os.path.join(self.projdir, "dist") if os.path.exists(dist_path): self.rmtree(dist_path) self.python("setup.py", "sdist", "--formats=tar") files = os.listdir(dist_path) self.assertTrue(len(files)==1, files) distfile = files[0] self.assertEqual(distfile, "demo-%s.tar" % exps["TE"][0]) fn = os.path.join(dist_path, distfile) os.mkdir(self.subpath("out/TE")) with tarfile.TarFile(fn) as t: t.extractall(path=self.subpath("out/TE")) target = self.subpath("out/TE/demo-%s" % exps["TE"][0]) self.assertTrue(os.path.isdir(target)) self.check_version(target, state, "TE", exps["TE"]) # TF: unpacked python -m build --sdist tarball pyproject_path = Path(self.projdir) / "pyproject.toml" if not pyproject_path.exists(): return dist_path = Path(self.projdir) / "dist" if dist_path.exists(): self.rmtree(dist_path) # --no-isolation makes this less finicky on slow/unreliable network # connections at the cost of being potentially less "normal". # We'll rely on Tox and CI to keep this environment isolated and # fresh. self.python("-m", "build", "--sdist", "--no-isolation") files = os.listdir(dist_path) self.assertTrue(len(files)==1, files) distfile = files[0] self.assertEqual(distfile, "demo-%s.tar.gz" % exps["TF"][0]) fn = os.path.join(dist_path, distfile) os.mkdir(self.subpath("out/TF")) with tarfile.open(fn) as t: t.extractall(path=self.subpath("out/TF")) target = self.subpath("out/TF/demo-%s" % exps["TF"][0]) self.assertTrue(os.path.isdir(target)) self.check_version(target, state, "TF", exps["TF"]) def check_version(self, workdir, state, tree, exps): exp_version, exp_full, exp_dirty, exp_error = exps if VERBOSE: print("== starting %s %s" % (state, tree)) # RA: setup.py --version if VERBOSE: # setup.py version invokes cmd_version, which uses verbose=True # and has more boilerplate. print(self.python("setup.py", "version", workdir=workdir)) # setup.py --version gives us get_version() with verbose=False. v = self.python("setup.py", "--version", workdir=workdir) self.compare(v, exp_version, state, tree, "RA1") self.assertPEP440(v, state, tree, "RA1") # and test again from outside the tree v = self.python(os.path.join(workdir, "setup.py"), "--version", workdir=self.testdir) self.compare(v, exp_version, state, tree, "RA2") self.assertPEP440(v, state, tree, "RA2") # RB: setup.py build; rundemo --version if os.path.exists(os.path.join(workdir, "build")): self.rmtree(os.path.join(workdir, "build")) self.python("setup.py", "build", "--build-lib=build/lib", "--build-scripts=build/lib", workdir=workdir) build_lib = os.path.join(workdir, "build", "lib") out = self.python("rundemo", "--version", workdir=build_lib) data = dict(line.split(":",1) for line in out.splitlines()) self.compare(data["__version__"], exp_version, state, tree, "RB") self.assertPEP440(data["__version__"], state, tree, "RB") self.compare(data["version"], exp_version, state, tree, "RB") self.compare(data["dirty"], str(exp_dirty), state, tree, "RB") self.compare(data["full-revisionid"], str(exp_full), state, tree, "RB") self.compare(data["error"], str(exp_error), state, tree, "RB") def compare(self, got, expected, state, tree, runtime): where = "/".join([state, tree, runtime]) self.assertEqual(got, expected, "%s: got '%s' != expected '%s'" % (where, got, expected)) if VERBOSE: print(" good %s" % where) def assertPEP440(self, got, state, tree, runtime): where = "/".join([state, tree, runtime]) pv = parse_version(got) # rather than using an undocumented API, setuptools dev recommends this self.assertFalse("Legacy" in pv.__class__.__name__, "%s: '%s' was not pep440-compatible" % (where, got)) self.assertEqual(str(pv), got, "%s: '%s' pep440-normalized to '%s'" % (where, got, str(pv))) if __name__ == '__main__': ver, rc = run_command(common.GITS, ["--version"], ".", True) print("git --version: %s" % ver.strip()) unittest.main()