mirror of
https://github.com/clinton-hall/nzbToMedia.git
synced 2024-11-14 17:40:24 -08:00
f05b09f349
Updates rarfile to 3.1 Updates stevedore to 3.5.0 Updates appdirs to 1.4.4 Updates click to 8.1.3 Updates decorator to 5.1.1 Updates dogpile.cache to 1.1.8 Updates pbr to 5.11.0 Updates pysrt to 1.1.2 Updates pytz to 2022.6 Adds importlib-metadata version 3.1.1 Adds typing-extensions version 4.1.1 Adds zipp version 3.11.0
287 lines
11 KiB
Python
287 lines
11 KiB
Python
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
try:
|
|
import configparser
|
|
except ImportError:
|
|
import ConfigParser as configparser
|
|
import os.path
|
|
import pkg_resources
|
|
import shlex
|
|
import sys
|
|
|
|
import fixtures
|
|
import testtools
|
|
import textwrap
|
|
|
|
from pbr.tests import base
|
|
from pbr.tests import test_packaging
|
|
|
|
PIPFLAGS = shlex.split(os.environ.get('PIPFLAGS', ''))
|
|
PIPVERSION = os.environ.get('PIPVERSION', 'pip')
|
|
PBRVERSION = os.environ.get('PBRVERSION', 'pbr')
|
|
REPODIR = os.environ.get('REPODIR', '')
|
|
WHEELHOUSE = os.environ.get('WHEELHOUSE', '')
|
|
PIP_CMD = ['-m', 'pip'] + PIPFLAGS + ['install', '-f', WHEELHOUSE]
|
|
PROJECTS = shlex.split(os.environ.get('PROJECTS', ''))
|
|
PBR_ROOT = os.path.abspath(os.path.join(__file__, '..', '..', '..'))
|
|
|
|
|
|
def all_projects():
|
|
if not REPODIR:
|
|
return
|
|
# Future: make this path parameterisable.
|
|
excludes = set(['tempest', 'requirements'])
|
|
for name in PROJECTS:
|
|
name = name.strip()
|
|
short_name = name.split('/')[-1]
|
|
try:
|
|
with open(os.path.join(
|
|
REPODIR, short_name, 'setup.py'), 'rt') as f:
|
|
if 'pbr' not in f.read():
|
|
continue
|
|
except IOError:
|
|
continue
|
|
if short_name in excludes:
|
|
continue
|
|
yield (short_name, dict(name=name, short_name=short_name))
|
|
|
|
|
|
class TestIntegration(base.BaseTestCase):
|
|
|
|
scenarios = list(all_projects())
|
|
|
|
def setUp(self):
|
|
# Integration tests need a higher default - big repos can be slow to
|
|
# clone, particularly under guest load.
|
|
env = fixtures.EnvironmentVariable(
|
|
'OS_TEST_TIMEOUT', os.environ.get('OS_TEST_TIMEOUT', '600'))
|
|
with env:
|
|
super(TestIntegration, self).setUp()
|
|
base._config_git()
|
|
|
|
@testtools.skipUnless(
|
|
os.environ.get('PBR_INTEGRATION', None) == '1',
|
|
'integration tests not enabled')
|
|
def test_integration(self):
|
|
# Test that we can:
|
|
# - run sdist from the repo in a venv
|
|
# - install the resulting tarball in a new venv
|
|
# - pip install the repo
|
|
# - pip install -e the repo
|
|
# We don't break these into separate tests because we'd need separate
|
|
# source dirs to isolate from side effects of running pip, and the
|
|
# overheads of setup would start to beat the benefits of parallelism.
|
|
path = os.path.join(REPODIR, self.short_name)
|
|
setup_cfg = os.path.join(path, 'setup.cfg')
|
|
project_name = pkg_resources.safe_name(self.short_name).lower()
|
|
# These projects should all have setup.cfg files but we'll be careful
|
|
if os.path.exists(setup_cfg):
|
|
config = configparser.ConfigParser()
|
|
config.read(setup_cfg)
|
|
if config.has_section('metadata'):
|
|
raw_name = config.get('metadata', 'name',
|
|
fallback='notapackagename')
|
|
# Technically we should really only need to use the raw
|
|
# name because all our projects should be good and use
|
|
# normalized names but they don't...
|
|
project_name = pkg_resources.safe_name(raw_name).lower()
|
|
constraints = os.path.join(REPODIR, 'requirements',
|
|
'upper-constraints.txt')
|
|
tmp_constraints = os.path.join(
|
|
self.useFixture(fixtures.TempDir()).path,
|
|
'upper-constraints.txt')
|
|
# We need to filter out the package we are installing to avoid
|
|
# conflicts with the constraints.
|
|
with open(constraints, 'r') as src:
|
|
with open(tmp_constraints, 'w') as dest:
|
|
for line in src:
|
|
constraint = line.split('===')[0]
|
|
if project_name != constraint:
|
|
dest.write(line)
|
|
pip_cmd = PIP_CMD + ['-c', tmp_constraints]
|
|
|
|
venv = self.useFixture(
|
|
test_packaging.Venv('sdist',
|
|
modules=['pip', 'wheel', PBRVERSION],
|
|
pip_cmd=PIP_CMD))
|
|
python = venv.python
|
|
self.useFixture(base.CapturedSubprocess(
|
|
'sdist', [python, 'setup.py', 'sdist'], cwd=path))
|
|
venv = self.useFixture(
|
|
test_packaging.Venv('tarball',
|
|
modules=['pip', 'wheel', PBRVERSION],
|
|
pip_cmd=PIP_CMD))
|
|
python = venv.python
|
|
filename = os.path.join(
|
|
path, 'dist', os.listdir(os.path.join(path, 'dist'))[0])
|
|
self.useFixture(base.CapturedSubprocess(
|
|
'tarball', [python] + pip_cmd + [filename]))
|
|
venv = self.useFixture(
|
|
test_packaging.Venv('install-git',
|
|
modules=['pip', 'wheel', PBRVERSION],
|
|
pip_cmd=PIP_CMD))
|
|
root = venv.path
|
|
python = venv.python
|
|
self.useFixture(base.CapturedSubprocess(
|
|
'install-git', [python] + pip_cmd + ['git+file://' + path]))
|
|
if self.short_name == 'nova':
|
|
found = False
|
|
for _, _, filenames in os.walk(root):
|
|
if 'migrate.cfg' in filenames:
|
|
found = True
|
|
self.assertTrue(found)
|
|
venv = self.useFixture(
|
|
test_packaging.Venv('install-e',
|
|
modules=['pip', 'wheel', PBRVERSION],
|
|
pip_cmd=PIP_CMD))
|
|
root = venv.path
|
|
python = venv.python
|
|
self.useFixture(base.CapturedSubprocess(
|
|
'install-e', [python] + pip_cmd + ['-e', path]))
|
|
|
|
|
|
class TestInstallWithoutPbr(base.BaseTestCase):
|
|
|
|
@testtools.skipUnless(
|
|
os.environ.get('PBR_INTEGRATION', None) == '1',
|
|
'integration tests not enabled')
|
|
def test_install_without_pbr(self):
|
|
# Test easy-install of a thing that depends on a thing using pbr
|
|
tempdir = self.useFixture(fixtures.TempDir()).path
|
|
# A directory containing sdists of the things we're going to depend on
|
|
# in using-package.
|
|
dist_dir = os.path.join(tempdir, 'distdir')
|
|
os.mkdir(dist_dir)
|
|
self._run_cmd(sys.executable, ('setup.py', 'sdist', '-d', dist_dir),
|
|
allow_fail=False, cwd=PBR_ROOT)
|
|
# testpkg - this requires a pbr-using package
|
|
test_pkg_dir = os.path.join(tempdir, 'testpkg')
|
|
os.mkdir(test_pkg_dir)
|
|
pkgs = {
|
|
'pkgTest': {
|
|
'setup.py': textwrap.dedent("""\
|
|
#!/usr/bin/env python
|
|
import setuptools
|
|
setuptools.setup(
|
|
name = 'pkgTest',
|
|
tests_require = ['pkgReq'],
|
|
test_suite='pkgReq'
|
|
)
|
|
"""),
|
|
'setup.cfg': textwrap.dedent("""\
|
|
[easy_install]
|
|
find_links = %s
|
|
""" % dist_dir)},
|
|
'pkgReq': {
|
|
'requirements.txt': textwrap.dedent("""\
|
|
pbr
|
|
"""),
|
|
'pkgReq/__init__.py': textwrap.dedent("""\
|
|
print("FakeTest loaded and ran")
|
|
""")},
|
|
}
|
|
pkg_dirs = self.useFixture(
|
|
test_packaging.CreatePackages(pkgs)).package_dirs
|
|
test_pkg_dir = pkg_dirs['pkgTest']
|
|
req_pkg_dir = pkg_dirs['pkgReq']
|
|
|
|
self._run_cmd(sys.executable, ('setup.py', 'sdist', '-d', dist_dir),
|
|
allow_fail=False, cwd=req_pkg_dir)
|
|
# A venv to test within
|
|
venv = self.useFixture(test_packaging.Venv('nopbr', ['pip', 'wheel']))
|
|
python = venv.python
|
|
# Run the depending script
|
|
self.useFixture(base.CapturedSubprocess(
|
|
'nopbr', [python] + ['setup.py', 'test'], cwd=test_pkg_dir))
|
|
|
|
|
|
class TestMarkersPip(base.BaseTestCase):
|
|
|
|
scenarios = [
|
|
('pip-latest', {'modules': ['pip']}),
|
|
('setuptools-Bionic', {
|
|
'modules': ['pip==9.0.1', 'setuptools==39.0.1']}),
|
|
('setuptools-Stretch', {
|
|
'modules': ['pip==9.0.1', 'setuptools==33.1.1']}),
|
|
('setuptools-EL8', {'modules': ['pip==9.0.3', 'setuptools==39.2.0']}),
|
|
('setuptools-Buster', {
|
|
'modules': ['pip==18.1', 'setuptools==40.8.0']}),
|
|
('setuptools-Focal', {
|
|
'modules': ['pip==20.0.2', 'setuptools==45.2.0']}),
|
|
]
|
|
|
|
@testtools.skipUnless(
|
|
os.environ.get('PBR_INTEGRATION', None) == '1',
|
|
'integration tests not enabled')
|
|
def test_pip_versions(self):
|
|
pkgs = {
|
|
'test_markers':
|
|
{'requirements.txt': textwrap.dedent("""\
|
|
pkg_a; python_version=='1.2'
|
|
pkg_b; python_version!='1.2'
|
|
""")},
|
|
'pkg_a': {},
|
|
'pkg_b': {},
|
|
}
|
|
pkg_dirs = self.useFixture(
|
|
test_packaging.CreatePackages(pkgs)).package_dirs
|
|
temp_dir = self.useFixture(fixtures.TempDir()).path
|
|
repo_dir = os.path.join(temp_dir, 'repo')
|
|
venv = self.useFixture(test_packaging.Venv('markers'))
|
|
bin_python = venv.python
|
|
os.mkdir(repo_dir)
|
|
for module in self.modules:
|
|
self._run_cmd(
|
|
bin_python,
|
|
['-m', 'pip', 'install', '--upgrade', module],
|
|
cwd=venv.path, allow_fail=False)
|
|
for pkg in pkg_dirs:
|
|
self._run_cmd(
|
|
bin_python, ['setup.py', 'sdist', '-d', repo_dir],
|
|
cwd=pkg_dirs[pkg], allow_fail=False)
|
|
self._run_cmd(
|
|
bin_python,
|
|
['-m', 'pip', 'install', '--no-index', '-f', repo_dir,
|
|
'test_markers'],
|
|
cwd=venv.path, allow_fail=False)
|
|
self.assertIn('pkg-b', self._run_cmd(
|
|
bin_python, ['-m', 'pip', 'freeze'], cwd=venv.path,
|
|
allow_fail=False)[0])
|
|
|
|
|
|
class TestLTSSupport(base.BaseTestCase):
|
|
|
|
# These versions come from the versions installed from the 'virtualenv'
|
|
# command from the 'python-virtualenv' package.
|
|
scenarios = [
|
|
('Bionic', {'modules': ['pip==9.0.1', 'setuptools==39.0.1']}),
|
|
('Stretch', {'modules': ['pip==9.0.1', 'setuptools==33.1.1']}),
|
|
('EL8', {'modules': ['pip==9.0.3', 'setuptools==39.2.0']}),
|
|
('Buster', {'modules': ['pip==18.1', 'setuptools==40.8.0']}),
|
|
('Focal', {'modules': ['pip==20.0.2', 'setuptools==45.2.0']}),
|
|
]
|
|
|
|
@testtools.skipUnless(
|
|
os.environ.get('PBR_INTEGRATION', None) == '1',
|
|
'integration tests not enabled')
|
|
def test_lts_venv_default_versions(self):
|
|
venv = self.useFixture(
|
|
test_packaging.Venv('setuptools', modules=self.modules))
|
|
bin_python = venv.python
|
|
pbr = 'file://%s#egg=pbr' % PBR_ROOT
|
|
# Installing PBR is a reasonable indication that we are not broken on
|
|
# this particular combination of setuptools and pip.
|
|
self._run_cmd(bin_python, ['-m', 'pip', 'install', pbr],
|
|
cwd=venv.path, allow_fail=False)
|