def test_freeze_git_clone(script, tmpdir):
"""
Test freezing a Git clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
'git', 'clone', pkg_version, 'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python', 'setup.py', 'develop',
cwd=repo_dir,
expect_stderr=True,
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+...#egg=version_pkg
...
"""
).strip()
_check_output(result.stdout, expected)
result = script.pip(
'freeze', '-f', '%s#egg=pip_test_package' % repo_dir,
expect_stderr=True,
)
expected = textwrap.dedent(
"""
-f %(repo)s#egg=pip_test_package...
-e git+...#egg=version_pkg
...
""" % {'repo': repo_dir},
).strip()
_check_output(result.stdout, expected)
# Check that slashes in branch or tag names are translated.
# See also issue #1083: https://github.com/pypa/pip/issues/1083
script.run(
'git', 'checkout', '-b', 'branch/name/with/slash',
cwd=repo_dir,
expect_stderr=True,
)
# Create a new commit to ensure that the commit has only one branch
# or tag name associated to it (to avoid the non-determinism reported
# in issue #1867).
script.run('touch', 'newfile', cwd=repo_dir)
script.run('git', 'add', 'newfile', cwd=repo_dir)
script.run('git', 'commit', '-m', '...', cwd=repo_dir)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e ...@...#egg=version_pkg
...
"""
).strip()
_check_output(result.stdout, expected)
def test_reinstalling_works_with_editible_non_master_branch(script):
"""
Reinstalling an editable installation should not assume that the "master"
branch exists. See https://github.com/pypa/pip/issues/4448.
"""
version_pkg_path = _create_test_package(script)
# Switch the default branch to something other than 'master'
script.run('git', 'branch', '-m', 'foobar', cwd=version_pkg_path)
script.pip(
'install', '-e',
'%s#egg=version_pkg' %
('git+file://' + version_pkg_path.abspath.replace('\\', '/')),
)
version = script.run('version_pkg')
assert '0.1' in version.stdout
_change_test_package_version(script, version_pkg_path)
script.pip(
'install', '-e',
'%s#egg=version_pkg' %
('git+file://' + version_pkg_path.abspath.replace('\\', '/')),
)
version = script.run('version_pkg')
assert 'some different version' in version.stdout
def test_freeze_exclude_editable(script, tmpdir):
"""
Test excluding editable from freezing list.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
'git', 'clone', pkg_version, 'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python', 'setup.py', 'develop',
cwd=repo_dir,
expect_stderr=True,
)
result = script.pip('freeze', '--exclude-editable', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+...#egg=version_pkg
...
"""
).strip()
_check_output(result.stdout, expected)
def test_freeze_bazaar_clone(script, tmpdir):
"""
Test freezing a Bazaar clone.
"""
try:
checkout_path = _create_test_package(script, vcs='bazaar')
except OSError as e:
pytest.fail('Invoking `bzr` failed: %s' % e)
result = script.run(
'bzr', 'checkout', checkout_path, 'bzr-package'
)
result = script.run(
'python', 'setup.py', 'develop',
cwd=script.scratch_path / 'bzr-package',
expect_stderr=True,
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""\
...-e bzr+file://...@1#egg=version_pkg
...""")
_check_output(result.stdout, expected)
result = script.pip(
'freeze', '-f',
'%s/#egg=django-wikiapp' % checkout_path,
expect_stderr=True,
)
expected = textwrap.dedent("""\
-f %(repo)s/#egg=django-wikiapp
...-e bzr+file://...@...#egg=version_pkg
...""" % {'repo': checkout_path})
_check_output(result.stdout, expected)
def _test_install_editable_from_git(script, tmpdir, wheel):
"""Test cloning from Git."""
if wheel:
script.pip('install', 'wheel')
pkg_path = _create_test_package(script, name='testpackage', vcs='git')
args = ['install', '-e', 'git+%s#egg=testpackage' % path_to_url(pkg_path)]
result = script.pip(*args, **{"expect_error": True})
result.assert_installed('testpackage', with_files=['.git'])
def test_vcs_url_final_slash_normalization(script, tmpdir):
"""
Test that presence or absence of final slash in VCS URL is normalized.
"""
pkg_path = _create_test_package(script, name='testpackage', vcs='hg')
args = ['install', '-e', 'hg+%s/#egg=testpackage' % path_to_url(pkg_path)]
result = script.pip(*args, **{"expect_error": True})
result.assert_installed('testpackage', with_files=['.hg'])
def test_get_refs_should_return_branch_name_and_commit_pair(script):
version_pkg_path = _create_test_package(script)
script.run('git', 'branch', 'branch0.1', cwd=version_pkg_path)
commit = script.run('git', 'rev-parse', 'HEAD',
cwd=version_pkg_path).stdout.strip()
git = Git()
result = git.get_refs(version_pkg_path)
assert result['master'] == commit, result
assert result['branch0.1'] == commit, result
def test_git_with_sha1_revisions(script):
"""
Git backend should be able to install from SHA1 revisions
"""
version_pkg_path = _create_test_package(script)
_change_test_package_version(script, version_pkg_path)
sha1 = script.run('git', 'rev-parse', 'HEAD~1', cwd=version_pkg_path).stdout.strip()
script.pip('install', '-e', '%s@%s#egg=version_pkg' % ('git+file://' + version_pkg_path.abspath.replace('\\', '/'), sha1))
version = script.run('version_pkg')
assert '0.1' in version.stdout, version.stdout
def test_git_with_branch_name_as_revision(script):
"""
Git backend should be able to install from branch names
"""
version_pkg_path = _create_test_package(script)
script.run('git', 'checkout', '-b', 'test_branch', expect_stderr=True, cwd=version_pkg_path)
_change_test_package_version(script, version_pkg_path)
script.pip('install', '-e', '%s@test_branch#egg=version_pkg' % ('git+file://' + version_pkg_path.abspath.replace('\\', '/')))
version = script.run('version_pkg')
assert 'some different version' in version.stdout
def test_git_with_tag_name_as_revision(script):
"""
Git backend should be able to install from tag names
"""
version_pkg_path = _create_test_package(script)
script.run('git', 'tag', 'test_tag', expect_stderr=True, cwd=version_pkg_path)
_change_test_package_version(script, version_pkg_path)
script.pip('install', '-e', '%s@test_tag#egg=version_pkg' % ('git+file://' + version_pkg_path.abspath.replace('\\', '/')))
version = script.run('version_pkg')
assert '0.1' in version.stdout
def test_git_works_with_editable_non_origin_repo(script):
# set up, create a git repo and install it as editable from a local directory path
version_pkg_path = _create_test_package(script)
script.pip('install', '-e', version_pkg_path.abspath)
# 'freeze'ing this should not fall over, but should result in stderr output warning
result = script.pip('freeze', expect_stderr=True)
assert "Error when trying to get requirement" in result.stderr
assert "Could not determine repository location" in result.stdout
assert "version-pkg==0.1" in result.stdout
def test_install_editable_from_svn(script):
"""
Test checking out from svn.
"""
checkout_path = _create_test_package(script)
repo_url = _create_svn_repo(script, checkout_path)
result = script.pip(
'install',
'-e', 'svn+' + repo_url + '#egg=version-pkg'
)
result.assert_installed('version-pkg', with_files=['.svn'])
def test_get_refs_should_return_tag_name_and_commit_pair():
env = reset_env()
version_pkg_path = _create_test_package(env)
env.run('git', 'tag', '0.1', cwd=version_pkg_path)
env.run('git', 'tag', '0.2', cwd=version_pkg_path)
commit = env.run('git', 'rev-parse', 'HEAD',
cwd=version_pkg_path).stdout.strip()
git = Git()
result = git.get_refs(version_pkg_path)
assert result['0.1'] == commit, result
assert result['0.2'] == commit, result
def test_git_install_ref(script):
"""
The Git backend should be able to install a ref with the first install.
"""
version_pkg_path = _create_test_package(script)
_add_ref(script, version_pkg_path, 'refs/foo/bar')
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(
script, version_pkg_path, rev='refs/foo/bar', expect_stderr=True,
)
assert '0.1' == version
def test_get_refs_should_ignore_no_branch(script):
version_pkg_path = _create_test_package(script)
script.run('git', 'branch', 'branch0.1', cwd=version_pkg_path)
commit = script.run('git', 'rev-parse', 'HEAD',
cwd=version_pkg_path).stdout.strip()
# current branch here is "* (nobranch)"
script.run('git', 'checkout', commit,
cwd=version_pkg_path, expect_stderr=True)
git = Git()
result = git.get_refs(version_pkg_path)
assert result['master'] == commit, result
assert result['branch0.1'] == commit, result
def test_git_with_ambiguous_revs(script):
"""
Test git with two "names" (tag/branch) pointing to the same commit
"""
version_pkg_path = _create_test_package(script)
version_pkg_url = _make_version_pkg_url(version_pkg_path, rev='0.1')
script.run('git', 'tag', '0.1', cwd=version_pkg_path)
result = script.pip('install', '-e', version_pkg_url)
assert 'Could not find a tag or branch' not in result.stdout
# it is 'version-pkg' instead of 'version_pkg' because
# egg-link name is version-pkg.egg-link because it is a single .py module
result.assert_installed('version-pkg', with_files=['.git'])
def test_check_version(script):
version_pkg_path = _create_test_package(script)
script.run('git', 'branch', 'branch0.1', cwd=version_pkg_path)
commit = script.run(
'git', 'rev-parse', 'HEAD',
cwd=version_pkg_path
).stdout.strip()
git = Git()
assert git.check_version(version_pkg_path, [commit])
assert git.check_version(version_pkg_path, [commit[:7]])
assert not git.check_version(version_pkg_path, ['branch0.1'])
assert not git.check_version(version_pkg_path, ['abc123'])
def test_editable__no_revision(script):
"""
Test a basic install in editable mode specifying no revision.
"""
version_pkg_path = _create_test_package(script)
_install_version_pkg_only(script, version_pkg_path)
branch = _get_editable_branch(script, 'version-pkg')
assert branch == 'master'
remote = _get_branch_remote(script, 'version-pkg', 'master')
assert remote == 'origin'
def test_git_install_branch_again_after_branch_changes(script):
"""
Test installing a branch again after the branch is updated in the remote
repository.
"""
version_pkg_path = _create_test_package(script)
version = _install_version_pkg(script, version_pkg_path, rev='master')
assert version == '0.1'
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev='master')
assert version == 'some different version'
def test_install_git_branch_not_cached(script: PipTestEnvironment) -> None:
"""
Installing git urls with a branch revision does not cause wheel caching.
"""
PKG = "gitbranchnotcached"
repo_dir = _create_test_package(script.scratch_path, name=PKG)
url = _make_version_pkg_url(repo_dir, rev="master", name=PKG)
result = script.pip("install", url, "--only-binary=:all:")
assert f"Successfully built {PKG}" in result.stdout, result.stdout
script.pip("uninstall", "-y", PKG)
# build occurs on the second install too because it is not cached
result = script.pip("install", url)
assert f"Successfully built {PKG}" in result.stdout, result.stdout
def test_git_install_branch_again_after_branch_changes(
script: PipTestEnvironment, ) -> None:
"""
Test installing a branch again after the branch is updated in the remote
repository.
"""
version_pkg_path = _create_test_package(script.scratch_path)
version = _install_version_pkg(script, version_pkg_path, rev="master")
assert version == "0.1"
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev="master")
assert version == "some different version"
def test_editable_git_upgrade(script):
"""
Test installing an editable git package from a repository, upgrading the repository,
installing again, and check it gets the newer version
"""
version_pkg_path = _create_test_package(script)
script.pip('install', '-e', '%s#egg=version_pkg' % ('git+file://' + version_pkg_path))
version = script.run('version_pkg')
assert '0.1' in version.stdout
_change_test_package_version(script, version_pkg_path)
script.pip('install', '-e', '%s#egg=version_pkg' % ('git+file://' + version_pkg_path))
version2 = script.run('version_pkg')
assert 'some different version' in version2.stdout, "Output: %s" % (version2.stdout)
def test_git_with_ambiguous_revs(script):
"""
Test git with two "names" (tag/branch) pointing to the same commit
"""
version_pkg_path = _create_test_package(script)
package_url = ('git+file://%[email protected]#egg=version_pkg' %
(version_pkg_path.abspath.replace('\\', '/')))
script.run('git', 'tag', '0.1', cwd=version_pkg_path)
result = script.pip('install', '-e', package_url)
assert 'Could not find a tag or branch' not in result.stdout
# it is 'version-pkg' instead of 'version_pkg' because
# egg-link name is version-pkg.egg-link because it is a single .py module
result.assert_installed('version-pkg', with_files=['.git'])
def test_git_with_ambiguous_revs():
"""
Test git with two "names" (tag/branch) pointing to the same commit
"""
env = reset_env()
version_pkg_path = _create_test_package(env)
package_url = "git+file://%[email protected]#egg=version_pkg" % (version_pkg_path.abspath.replace("\\", "/"))
env.run("git", "tag", "0.1", cwd=version_pkg_path)
result = run_pip("install", "-e", package_url)
assert "Could not find a tag or branch" not in result.stdout
# it is 'version-pkg' instead of 'version_pkg' because
# egg-link name is version-pkg.egg-link because it is a single .py module
result.assert_installed("version-pkg", with_files=[".git"])
def test_git_with_sha1_revisions():
"""
Git backend should be able to install from SHA1 revisions
"""
env = reset_env()
version_pkg_path = _create_test_package(env)
_change_test_package_version(env, version_pkg_path)
sha1 = env.run("git", "rev-parse", "HEAD~1", cwd=version_pkg_path).stdout.strip()
run_pip(
"install", "-e", "%s@%s#egg=version_pkg" % ("git+file://" + version_pkg_path.abspath.replace("\\", "/"), sha1)
)
version = env.run("version_pkg")
assert "0.1" in version.stdout, version.stdout
def test_git_with_tag_name_as_revision(script):
"""
Git backend should be able to install from tag names
"""
version_pkg_path = _create_test_package(script)
script.run(
'git', 'tag', 'test_tag',
expect_stderr=True,
cwd=version_pkg_path,
)
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev='test_tag')
assert '0.1' == version
def test_git_with_tag_name_as_revision():
"""
Git backend should be able to install from tag names
"""
env = reset_env()
version_pkg_path = _create_test_package(env)
env.run("git", "tag", "test_tag", expect_stderr=True, cwd=version_pkg_path)
_change_test_package_version(env, version_pkg_path)
run_pip(
"install", "-e", "%s@test_tag#egg=version_pkg" % ("git+file://" + version_pkg_path.abspath.replace("\\", "/"))
)
version = env.run("version_pkg")
assert "0.1" in version.stdout
def test_freeze_git_clone(script, tmpdir):
"""
Test freezing a Git clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
'git',
'clone',
pkg_version,
'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python',
'setup.py',
'develop',
cwd=repo_dir,
expect_stderr=True,
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""
...-e git+...#egg=version_pkg
...
""").strip()
_check_output(result.stdout, expected)
# Check that slashes in branch or tag names are translated.
# See also issue #1083: https://github.com/pypa/pip/issues/1083
script.run(
'git',
'checkout',
'-b',
'branch/name/with/slash',
cwd=repo_dir,
expect_stderr=True,
)
# Create a new commit to ensure that the commit has only one branch
# or tag name associated to it (to avoid the non-determinism reported
# in issue #1867).
(repo_dir / 'newfile').touch()
script.run('git', 'add', 'newfile', cwd=repo_dir)
_git_commit(script, repo_dir, message='...')
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""
...-e ...@...#egg=version_pkg
...
""").strip()
_check_output(result.stdout, expected)
def test_freeze_git_clone(script: PipTestEnvironment) -> None:
"""
Test freezing a Git clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
"git",
"clone",
pkg_version,
"pip-test-package",
expect_stderr=True,
)
repo_dir = script.scratch_path / "pip-test-package"
result = script.run(
"python",
"setup.py",
"develop",
cwd=repo_dir,
expect_stderr=True,
)
result = script.pip("freeze", expect_stderr=True)
expected = textwrap.dedent("""
...-e git+...#egg=version_pkg
...
""").strip()
_check_output(result.stdout, expected)
# Check that slashes in branch or tag names are translated.
# See also issue #1083: https://github.com/pypa/pip/issues/1083
script.run(
"git",
"checkout",
"-b",
"branch/name/with/slash",
cwd=repo_dir,
expect_stderr=True,
)
# Create a new commit to ensure that the commit has only one branch
# or tag name associated to it (to avoid the non-determinism reported
# in issue #1867).
(repo_dir / "newfile").touch()
script.run("git", "add", "newfile", cwd=repo_dir)
_git_commit(script, repo_dir, message="...")
result = script.pip("freeze", expect_stderr=True)
expected = textwrap.dedent("""
...-e ...@...#egg=version_pkg
...
""").strip()
_check_output(result.stdout, expected)
def test_git_with_short_sha1_revisions(script):
"""
Git backend should be able to install from SHA1 revisions
"""
version_pkg_path = _create_test_package(script)
_change_test_package_version(script, version_pkg_path)
sha1 = script.run(
'git',
'rev-parse',
'HEAD~1',
cwd=version_pkg_path,
).stdout.strip()[:7]
version = _install_version_pkg(script, version_pkg_path, rev=sha1)
assert '0.1' == version
def test_git_with_branch_name_as_revision(script):
"""
Git backend should be able to install from branch names
"""
version_pkg_path = _create_test_package(script)
branch = 'test_branch'
script.run(
'git', 'checkout', '-b', branch,
expect_stderr=True,
cwd=version_pkg_path,
)
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev=branch)
assert 'some different version' == version
def test_git_with_branch_name_as_revision(script):
"""
Git backend should be able to install from branch names
"""
version_pkg_path = _create_test_package(script)
branch = 'test_branch'
script.run(
'git', 'checkout', '-b', branch,
expect_stderr=True,
cwd=version_pkg_path,
)
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev=branch)
assert 'some different version' == version
def test_git_with_short_sha1_revisions(script):
"""
Git backend should be able to install from SHA1 revisions
"""
version_pkg_path = _create_test_package(script)
_change_test_package_version(script, version_pkg_path)
sha1 = script.run(
'git', 'rev-parse', 'HEAD~1',
cwd=version_pkg_path,
).stdout.strip()[:7]
version = _install_version_pkg(
script, version_pkg_path, rev=sha1, expect_stderr=True,
)
assert '0.1' == version
def test_editable_git_upgrade():
"""
Test installing an editable git package from a repository, upgrading the repository,
installing again, and check it gets the newer version
"""
env = reset_env()
version_pkg_path = _create_test_package(env)
run_pip("install", "-e", "%s#egg=version_pkg" % ("git+file://" + version_pkg_path))
version = env.run("version_pkg")
assert "0.1" in version.stdout
_change_test_package_version(env, version_pkg_path)
run_pip("install", "-e", "%s#egg=version_pkg" % ("git+file://" + version_pkg_path))
version2 = env.run("version_pkg")
assert "some different version" in version2.stdout, "Output: %s" % (version2.stdout)
def test_should_cache_git_sha(script, tmpdir):
repo_path = _create_test_package(script, name="mypkg")
commit = script.run("git", "rev-parse", "HEAD",
cwd=repo_path).stdout.strip()
# a link referencing a sha should be cached
url = "git+https://g.c/o/r@" + commit + "#egg=mypkg"
req = ReqMock(link=Link(url), source_dir=repo_path)
assert wheel_builder._should_cache(req)
# a link not referencing a sha should not be cached
url = "git+https://g.c/o/r@master#egg=mypkg"
req = ReqMock(link=Link(url), source_dir=repo_path)
assert not wheel_builder._should_cache(req)
def test_git_with_short_sha1_revisions(script):
"""
Git backend should be able to install from SHA1 revisions
"""
version_pkg_path = _create_test_package(script)
_change_test_package_version(script, version_pkg_path)
sha1 = script.run(
'git', 'rev-parse', 'HEAD~1',
cwd=version_pkg_path,
).stdout.strip()[:7]
version_pkg_url = _make_version_pkg_url(version_pkg_path, rev=sha1)
script.pip('install', '-e', version_pkg_url, expect_stderr=True)
version = script.run('version_pkg')
assert '0.1' in version.stdout, version.stdout
def test_install_git_branch_not_cached(script, with_wheel):
"""
Installing git urls with a branch revision does not cause wheel caching.
"""
PKG = "gitbranchnotcached"
repo_dir = _create_test_package(script, name=PKG)
url = _make_version_pkg_url(repo_dir, rev="master", name=PKG)
result = script.pip("install", url, "--only-binary=:all:")
assert "Successfully built {}".format(PKG) in result.stdout, result.stdout
script.pip("uninstall", "-y", PKG)
# build occurs on the second install too because it is not cached
result = script.pip("install", url)
assert ("Successfully built {}".format(PKG)
in result.stdout), result.stdout
def test_git_install_ref(script):
"""
The Git backend should be able to install a ref with the first install.
"""
version_pkg_path = _create_test_package(script)
_add_ref(script, version_pkg_path, 'refs/foo/bar')
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(
script,
version_pkg_path,
rev='refs/foo/bar',
)
assert '0.1' == version
def test_freeze_git_remote(script, tmpdir):
"""
Test freezing a Git clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
'git', 'clone', pkg_version, 'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python', 'setup.py', 'develop',
cwd=repo_dir,
expect_stderr=True,
)
origin_remote = pkg_version
other_remote = pkg_version + '-other'
# check frozen remote after clone
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=origin_remote).strip()
_check_output(result.stdout, expected)
# check frozen remote when there is no remote named origin
script.run('git', 'remote', 'remove', 'origin', cwd=repo_dir)
script.run('git', 'remote', 'add', 'other', other_remote, cwd=repo_dir)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=other_remote).strip()
_check_output(result.stdout, expected)
# when there are more than one origin, priority is given to the
# remote named origin
script.run('git', 'remote', 'add', 'origin', origin_remote, cwd=repo_dir)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=origin_remote).strip()
_check_output(result.stdout, expected)
def test_freeze_git_remote(script, tmpdir):
"""
Test freezing a Git clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script)
result = script.run(
'git', 'clone', pkg_version, 'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python', 'setup.py', 'develop',
cwd=repo_dir,
expect_stderr=True,
)
origin_remote = pkg_version
other_remote = pkg_version + '-other'
# check frozen remote after clone
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=origin_remote).strip()
_check_output(result.stdout, expected)
# check frozen remote when there is no remote named origin
script.run('git', 'remote', 'remove', 'origin', cwd=repo_dir)
script.run('git', 'remote', 'add', 'other', other_remote, cwd=repo_dir)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=other_remote).strip()
_check_output(result.stdout, expected)
# when there are more than one origin, priority is given to the
# remote named origin
script.run('git', 'remote', 'add', 'origin', origin_remote, cwd=repo_dir)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent(
"""
...-e git+{remote}@...#egg=version_pkg
...
"""
).format(remote=origin_remote).strip()
_check_output(result.stdout, expected)
def test_install_git_sha_cached(script: PipTestEnvironment) -> None:
"""
Installing git urls with a sha revision does cause wheel caching.
"""
PKG = "gitshacached"
repo_dir = _create_test_package(script, name=PKG)
commit = script.run("git", "rev-parse", "HEAD", cwd=repo_dir).stdout.strip()
url = _make_version_pkg_url(repo_dir, rev=commit, name=PKG)
result = script.pip("install", url)
assert f"Successfully built {PKG}" in result.stdout, result.stdout
script.pip("uninstall", "-y", PKG)
# build does not occur on the second install because it is cached
result = script.pip("install", url)
assert f"Successfully built {PKG}" not in result.stdout, result.stdout
def test_git_install_ref(script: PipTestEnvironment) -> None:
"""
The Git backend should be able to install a ref with the first install.
"""
version_pkg_path = _create_test_package(script)
_add_ref(script, version_pkg_path, "refs/foo/bar")
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(
script,
version_pkg_path,
rev="refs/foo/bar",
)
assert "0.1" == version
def test_git_with_short_sha1_revisions(script: PipTestEnvironment) -> None:
"""
Git backend should be able to install from SHA1 revisions
"""
version_pkg_path = _create_test_package(script)
_change_test_package_version(script, version_pkg_path)
sha1 = script.run(
"git",
"rev-parse",
"HEAD~1",
cwd=version_pkg_path,
).stdout.strip()[:7]
version = _install_version_pkg(script, version_pkg_path, rev=sha1)
assert "0.1" == version
def test_is_commit_id_equal(script: PipTestEnvironment) -> None:
"""
Test Git.is_commit_id_equal().
"""
version_pkg_path = _create_test_package(script)
script.run("git", "branch", "branch0.1", cwd=version_pkg_path)
commit = script.run("git", "rev-parse", "HEAD", cwd=version_pkg_path).stdout.strip()
assert Git.is_commit_id_equal(version_pkg_path, commit)
assert not Git.is_commit_id_equal(version_pkg_path, commit[:7])
assert not Git.is_commit_id_equal(version_pkg_path, "branch0.1")
assert not Git.is_commit_id_equal(version_pkg_path, "abc123")
# Also check passing a None value.
assert not Git.is_commit_id_equal(version_pkg_path, None)
def test_editable__non_master_default_branch(
script: PipTestEnvironment) -> None:
"""
Test the branch you get after an editable install from a remote repo
with a non-master default branch.
"""
version_pkg_path = _create_test_package(script.scratch_path)
# Change the default branch of the remote repo to a name that is
# alphabetically after "master".
script.run("git", "checkout", "-b", "release", cwd=version_pkg_path)
_install_version_pkg_only(script, version_pkg_path)
branch = _get_editable_branch(script, "version-pkg")
assert branch == "release"
def test_freeze_mercurial_clone(script, tmpdir):
"""
Test freezing a Mercurial clone.
"""
# Returns path to a generated package called "version_pkg"
pkg_version = _create_test_package(script, vcs='hg')
result = script.run(
'hg',
'clone',
pkg_version,
'pip-test-package',
expect_stderr=True,
)
repo_dir = script.scratch_path / 'pip-test-package'
result = script.run(
'python',
'setup.py',
'develop',
cwd=repo_dir,
expect_stderr=True,
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""
Script result: ...pip freeze
-- stdout: --------------------
...-e hg+...#egg=version_pkg-dev
...
""").strip()
_check_output(result, expected)
result = script.pip(
'freeze',
'-f',
'%s#egg=pip_test_package' % repo_dir,
expect_stderr=True,
)
expected = textwrap.dedent(
"""
Script result: pip freeze -f %(repo)s#egg=pip_test_package
-- stdout: --------------------
-f %(repo)s#egg=pip_test_package...
...-e hg+...#egg=version_pkg-dev
...
""" % {
'repo': repo_dir
}, ).strip()
_check_output(result, expected)
def test_editable__branch_with_sha_same_as_default(script: PipTestEnvironment) -> None:
"""
Test installing in editable mode a branch whose sha matches the sha
of the default branch, but is different from the default branch.
"""
version_pkg_path = _create_test_package(script)
# Create a second branch with the same SHA.
script.run("git", "branch", "develop", cwd=version_pkg_path)
_install_version_pkg_only(script, version_pkg_path, rev="develop")
branch = _get_editable_branch(script, "version-pkg")
assert branch == "develop"
remote = _get_branch_remote(script, "version-pkg", "develop")
assert remote == "origin"
def test_is_commit_id_equal(script):
"""
Test Git.is_commit_id_equal().
"""
version_pkg_path = _create_test_package(script)
script.run('git', 'branch', 'branch0.1', cwd=version_pkg_path)
commit = script.run('git', 'rev-parse', 'HEAD',
cwd=version_pkg_path).stdout.strip()
assert Git.is_commit_id_equal(version_pkg_path, commit)
assert not Git.is_commit_id_equal(version_pkg_path, commit[:7])
assert not Git.is_commit_id_equal(version_pkg_path, 'branch0.1')
assert not Git.is_commit_id_equal(version_pkg_path, 'abc123')
# Also check passing a None value.
assert not Git.is_commit_id_equal(version_pkg_path, None)
def test_is_immutable_rev_checkout(script):
version_pkg_path = _create_test_package(script)
commit = script.run(
'git', 'rev-parse', 'HEAD',
cwd=version_pkg_path
).stdout.strip()
assert Git().is_immutable_rev_checkout(
"git+https://g.c/o/r@" + commit, version_pkg_path
)
assert not Git().is_immutable_rev_checkout(
"git+https://g.c/o/r", version_pkg_path
)
assert not Git().is_immutable_rev_checkout(
"git+https://g.c/o/r@master", version_pkg_path
)
def test_git_with_branch_name_as_revision():
"""
Git backend should be able to install from branch names
"""
env = reset_env()
version_pkg_path = _create_test_package(env)
env.run("git", "checkout", "-b", "test_branch", expect_stderr=True, cwd=version_pkg_path)
_change_test_package_version(env, version_pkg_path)
run_pip(
"install",
"-e",
"%s@test_branch#egg=version_pkg" % ("git+file://" + version_pkg_path.abspath.replace("\\", "/")),
)
version = env.run("version_pkg")
assert "some different version" in version.stdout
def test_editable_non_master_default_branch(script):
"""
Test the branch you get after an editable install from a remote repo
with a non-master default branch.
"""
version_pkg_path = _create_test_package(script)
# Change the default branch of the remote repo to a name that is
# alphabetically after "master".
script.run(
'git', 'checkout', '-b', 'release', expect_stderr=True,
cwd=version_pkg_path,
)
_install_version_pkg_only(script, version_pkg_path)
branch = _get_editable_branch(script, 'version-pkg')
assert 'release' == branch
def test_git_with_tag_name_as_revision(script):
"""
Git backend should be able to install from tag names
"""
version_pkg_path = _create_test_package(script)
script.run(
'git',
'tag',
'test_tag',
expect_stderr=True,
cwd=version_pkg_path,
)
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path, rev='test_tag')
assert '0.1' == version
def test_freeze_svn(script, tmpdir):
"""Test freezing a svn checkout"""
checkout_path = _create_test_package(script, vcs='svn')
# Install with develop
script.run(
'python', 'setup.py', 'develop',
cwd=checkout_path, expect_stderr=True
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""\
...-e svn+...#egg=version_pkg
...""")
_check_output(result.stdout, expected)
def test_git_with_tag_name_as_revision(script):
"""
Git backend should be able to install from tag names
"""
version_pkg_path = _create_test_package(script)
script.run(
'git', 'tag', 'test_tag',
expect_stderr=True,
cwd=version_pkg_path,
)
_change_test_package_version(script, version_pkg_path)
version_pkg_url = _make_version_pkg_url(version_pkg_path, rev='test_tag')
script.pip('install', '-e', version_pkg_url)
version = script.run('version_pkg')
assert '0.1' in version.stdout
def test_editable__branch_with_sha_same_as_default(script):
"""
Test installing in editable mode a branch whose sha matches the sha
of the default branch, but is different from the default branch.
"""
version_pkg_path = _create_test_package(script)
# Create a second branch with the same SHA.
script.run('git', 'branch', 'develop', cwd=version_pkg_path)
_install_version_pkg_only(script, version_pkg_path, rev='develop')
branch = _get_editable_branch(script, 'version-pkg')
assert branch == 'develop'
remote = _get_branch_remote(script, 'version-pkg', 'develop')
assert remote == 'origin'
def test_freeze_svn(script, tmpdir):
"""Test freezing a svn checkout"""
checkout_path = _create_test_package(script, vcs='svn')
# Install with develop
script.run(
'python', 'setup.py', 'develop',
cwd=checkout_path, expect_stderr=True
)
result = script.pip('freeze', expect_stderr=True)
expected = textwrap.dedent("""\
...-e svn+...#egg=version_pkg
...""")
_check_output(result.stdout, expected)
def test_freeze_svn(script: PipTestEnvironment) -> None:
"""Test freezing a svn checkout"""
checkout_path = _create_test_package(script, vcs="svn")
# Install with develop
script.run("python",
"setup.py",
"develop",
cwd=checkout_path,
expect_stderr=True)
result = script.pip("freeze", expect_stderr=True)
expected = textwrap.dedent("""\
...-e svn+...#egg=version_pkg
...""")
_check_output(result.stdout, expected)
def test_editable_git_upgrade(script):
"""
Test installing an editable git package from a repository, upgrading the repository,
installing again, and check it gets the newer version
"""
version_pkg_path = _create_test_package(script)
script.pip('install', '-e',
'%s#egg=version_pkg' % ('git+file://' + version_pkg_path))
version = script.run('version_pkg')
assert '0.1' in version.stdout
_change_test_package_version(script, version_pkg_path)
script.pip('install', '-e',
'%s#egg=version_pkg' % ('git+file://' + version_pkg_path))
version2 = script.run('version_pkg')
assert 'some different version' in version2.stdout, "Output: %s" % (
version2.stdout)
def test_reinstalling_works_with_editable_non_master_branch(script):
"""
Reinstalling an editable installation should not assume that the "master"
branch exists. See https://github.com/pypa/pip/issues/4448.
"""
version_pkg_path = _create_test_package(script)
# Switch the default branch to something other than 'master'
script.run('git', 'branch', '-m', 'foobar', cwd=version_pkg_path)
version = _install_version_pkg(script, version_pkg_path)
assert '0.1' == version
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path)
assert 'some different version' == version
def test_git_install_again_after_changes(script):
"""
Test installing a repository a second time without specifying a revision,
and after updates to the remote repository.
This test also checks that no warning message like the following gets
logged on the update: "Did not find branch or tag ..., assuming ref or
revision."
"""
version_pkg_path = _create_test_package(script)
version = _install_version_pkg(script, version_pkg_path)
assert version == '0.1'
_change_test_package_version(script, version_pkg_path)
version = _install_version_pkg(script, version_pkg_path)
assert version == 'some different version'
