def test_check_unnecessary_requirements(capsys, test_data):
# preconditions
package_list, requirements_list, locked_list = test_data
packages = PackageCollection([
Package(key=key, name=key, obj=None, version=None)
for key in package_list
])
requirements = RequirementCollection([
Requirement.from_requirement_string(key) for key in requirements_list
])
locked = RequirementCollection(
[Requirement.from_requirement_string(key) for key in locked_list])
# action
success = validate.check_unnecessary_packages(
packages=packages,
requirements=requirements,
locked=locked,
)
# verification
captured = capsys.readouterr()
required = set(requirements_list + locked_list)
assert success is False if len(package_list) > len(required) else success
if success:
assert messages.PACKAGE_NOT_REQUIRED_OK in captured.out
else:
assert messages.PACKAGE_NOT_REQUIRED_FOUND in captured.out
for package in package_list:
if package not in required:
assert package in captured.out
def parse_requirements_file(filepath):
"""Parse requirements file and return a collection of requirements
:param filepath: Filepath of requirements file
:return: Collection of requirements
"""
with open(str(filepath), 'r') as requirements_file:
data = [
# Remove whitespaces and newlines
row.replace(' ', '').strip()
# In every row
for row in requirements_file.readlines()
# Ignore comments and empty lines
if not row.startswith('#') and
not row.startswith('-r ') and
not row.startswith('-c ') and
row != '\n'
]
requirements = RequirementCollection([
Requirement.from_requirement_string(row)
for row in data
])
return requirements
def test_check_version_mismatch(capsys, test_data):
# preconditions
package_list, locked_list = test_data
packages = PackageCollection([
Package(key=key, name=key, obj=None, version=InstalledVersion(version))
for key, version in package_list
])
locked = RequirementCollection([
Requirement(key=key,
name=key,
obj=None,
version=RequiredVersion(version))
for key, version in locked_list
])
# action
success = validate.check_package_version_mismatch(packages=packages,
locked=locked)
# verification
captured = capsys.readouterr()
assert success is False if package_list != locked_list else success
if success:
assert messages.PACKAGE_VERSION_MISMATCH_OK in captured.out
else:
assert messages.PACKAGE_VERSION_MISMATCH_FOUND in captured.out
for package in package_list:
for lock in locked_list:
if package[0] == lock[0] and package[1] != lock[1]:
assert package[0] in captured.out
def locked_requirements(packages=None, requirements=None, ignore_list=None):
"""Returns all requirements locked to the required versions
:param packages: Collection of packages
:param requirements: Collection of requirements
:param ignore_list: List of package keys to ignore
:return: All requirements locked to their installed versions
"""
packages = packages or PackageCollection()
requirements = requirements or RequirementCollection()
ignore_list = ignore_list or []
if not requirements:
return RequirementCollection(
sorted([
Requirement.from_package(package=package)
for package in packages
]))
locked = []
for package in packages:
specified_in_requirements = package.key in requirements.keys()
required_by_requirements = required_by(requirement=package,
packages=requirements.flatten())
if specified_in_requirements or required_by_requirements:
locked.append(package)
return RequirementCollection(
sorted([requirement for requirement in locked]))
def test_locked_requirements(virtualenv, mocker):
# preconditions
locked_package1_path = PACKAGES_DIR / 'locked' / 'locked-package1'
locked_package2_path = PACKAGES_DIR / 'locked' / 'locked-package2'
locked_package3_path = PACKAGES_DIR / 'locked' / 'locked-package3'
expected_result = ['locked-package1', 'locked-package2', 'locked-package3']
packages = prepare_packages(venv=virtualenv,
mocker=mocker,
packages=[
locked_package1_path,
locked_package2_path,
locked_package3_path,
])
requirements_empty = RequirementCollection()
requirements = RequirementCollection()
package_1 = packages.get(key='locked-package1')
requirement_1 = Requirement.from_package(package_1)
requirements.append(requirement_1)
# action
locked_no_requirements = operations.locked_requirements(
packages=packages, requirements=requirements_empty)
locked = operations.locked_requirements(packages=packages,
requirements=requirements)
# verification
assert expected_result == locked_no_requirements.keys()
assert expected_result == locked.keys()
for lock in locked_no_requirements:
assert lock.version.specifier == '==1.0.0'
for lock in locked:
assert lock.version.specifier == '==1.0.0'
def test_check_unset_locks(capsys, test_data):
# preconditions
requirements_list, locked_list = test_data
requirements = RequirementCollection([
Requirement.from_requirement_string(key) for key in requirements_list
])
locked = RequirementCollection(
[Requirement.from_requirement_string(key) for key in locked_list])
# action
success = validate.check_unset_locks(requirements=requirements,
locked=locked)
# verification
captured = capsys.readouterr()
assert success is False if requirements_list != locked_list else success
if success:
assert messages.UNSET_LOCKS_OK in captured.out
else:
assert messages.UNSET_LOCKS_FOUND in captured.out
for requirement in requirements_list:
if requirement not in locked_list:
assert requirement in captured.out
def test_check_unlocked_requirements(capsys, unlocked):
# preconditions
requirements = RequirementCollection(
Requirement.from_requirement_string(key) for key in unlocked)
# action
success = validate.check_unlocked_requirements(requirements=requirements)
# verification
captured = capsys.readouterr()
assert success is False if unlocked else success
if success:
assert messages.UNLOCKED_REQUIREMENTS_OK in captured.out
else:
assert messages.UNLOCKED_REQUIREMENTS_FOUND in captured.out
for requirement in unlocked:
assert requirement in captured.out
def test_parse_requirements_file():
# preconditions
num_packages = 3
filepath = FILE_DIR / 'requirements.txt'
version = RequiredVersion('1.0.0')
expected_requirements = RequirementCollection([
Requirement(key='package{}'.format(i),
name='p{}'.format(i),
obj=None,
version=version) for i in range(1, num_packages + 1)
])
# action
requirements = PipParser.parse_requirements_file(filepath=filepath)
# verification
assert expected_requirements == requirements
def test_dependency_list(virtualenv, mocker):
# preconditions
package1_path = PACKAGES_DIR / 'dependencies' / 'dependency-package1'
package2_path = PACKAGES_DIR / 'dependencies' / 'dependency-package2'
working_set = prepare_working_set(venv=virtualenv,
packages=[package1_path, package2_path])
requirements = RequirementCollection(
[Requirement.from_requirement_string('dependency-package1')])
mocker.patch('dante.vendor.pkg_resources.working_set', working_set)
# action
installed_dependencies = operations.dependency_list()
installed_dependencies_with_requirements = operations.dependency_list(
requirements=requirements)
# verification
assert (['dependency-package1',
'dependency-package2'] == installed_dependencies.keys())
assert (['dependency-package1'
] == installed_dependencies_with_requirements.keys())
def test_save_lock_file(mocker, tmp_path):
# preconditions
num_packages = 6
version = '1.0.0'
filepath = tmp_path / 'requirements.lock'
expected_filepath = FILE_DIR / 'requirements.lock'
expected_data = expected_filepath.read_text()
requirements = RequirementCollection([
Requirement.from_requirement_string(
requirement_string='package{}=={}'.format(i, version), )
for i in range(1, num_packages + 1)
])
# action
mocker.patch('dante.core.models.Requirement.version_id', version)
PipParser.save_lock_file(requirements=requirements, filepath=filepath)
# verification
data = filepath.read_text()
assert expected_data == data