def test_sanity(self):
"""Check contrived version runs"""
package = 'A'
version = '1.0.0'
DepTools.check_if_ancestors_still_satisfied(package, version,
self.ancestors,
self.package_requirements)
def test_contrived_obvious_example_2(self):
"""
Add D, remove B
A 2.0.0
Req:
D == 1.0.0
C >= 0.0.5
"""
req_ex1 = {
'project_name': 'A',
'version': '2.0.0',
'requires': {
'b': {
'key': 'd',
'project_name': 'D',
'specs': [['==', '1.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
}
},
}
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(res['removed_deps'], ['B'])
self.assertEqual(res['new_deps'], ['D'])
def test_contrived_obvious_example_1(self):
"""
No new or removed dependencies for current package.
"""
req_ex1 = {
'project_name': 'A',
'version': '1.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
}
},
}
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(res['removed_deps'], [])
self.assertEqual(res['new_deps'], [])
def test_returns_dict(self):
"""
method should return dictionary.
"""
res = DepTools.check_changes_in_requirements_vs_env(
self.fab_reqs, self.descendants)
self.assertEqual(type(res), dict)
def test_multiple_requirements1(self):
"""Multiple requirements should be evaluated when present.
All reqs should be satisfied.
"""
req = {
'project_name': 'A',
'version': '1.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0'], ['!=', '1.1.1']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
},
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
missing = [] # no missing
conflicts = {} # no conflicts
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_multiple_requirements2_conflicts(self):
"""Multiple requirements should be evaluated when present.
Should fail with conflicting reqs.
"""
req = {
'project_name': 'A',
'version': '1.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0'], ['!=', '1.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
},
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.assertTrue('B' in res['conflicts'])
specs = req['requires']['b']['specs']
details = [(req['version'], specs[1][0], specs[1][1], False)]
self.assertEqual(res['conflicts']['B'], details)
def test_contrived_obvious_eg2_missing_req(self):
"""
'D' should be in missing
"""
req = {
'project_name': 'A',
'version': '2.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
},
'd': {
'key': 'd',
'project_name': 'D',
'specs': [['>=', '40.5.0']],
},
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
missing = ['D']
conflicts = {}
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_contrived_obvious_eg3_b_conflicts(self):
"""
'B' should be in conflicts
"""
req = {
'project_name': 'A',
'version': '1.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '2.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
},
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
self.assertTrue('B' in res['conflicts'])
specs = req['requires']['b']['specs']
details = [(req['version'], specs[0][0], specs[0][1], False)]
self.assertEqual(res['conflicts']['B'], details)
def test_returns_dict(self):
"""
method should return dictionary.
"""
res = DepTools.check_changes_in_requirements_vs_env(
self.fab_reqs, self.descendants)
self.assertEqual(type(res), dict)
def test_contrived_obvious_example_1(self):
"""
All reqs should be satisfied.
"""
req_ex1 = {
'project_name': 'A',
'version': '1.0.0',
'requires': {
'b': {
'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']],
},
'c': {
'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']],
},
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(
req_ex1, self.nodes)
self.sanity_checks(res)
missing = [] # no missing
conflicts = {} # no conflicts
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_details_returned(self):
"""
Return tuple should be:
(cur_ver, requirement_sym, requirement_ver, requirement_met)
"""
req = ("==", "1.0.1")
res, details = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertEqual(details, (self.cur_ver, req[0], req[1], res))
def test_details_returned(self):
"""
Return tuple should be:
(cur_ver, requirement_sym, requirement_ver, requirement_met)
"""
req = ("==", "1.0.1")
res, details = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertEqual(details, (self.cur_ver, req[0], req[1], res))
def test_check_no_conflicts(self):
"""
No conflicts if package is same as environment
"""
res = DepTools.check_if_ancestors_still_satisfied(
self.package, self.version, self.ancestors,
self.package_requirements)
self.assertEqual(res['conflicts'], {})
def test_y_fails(self):
"""
Y should fail with A>21
"""
package = 'A'
version = '3.0.0'
res = DepTools.check_if_ancestors_still_satisfied(
package, version, self.ancestors, self.package_requirements)
self.assertIn('y', res['conflicts'])
def test_y_fails(self):
"""
Y should fail with A>21
"""
package = 'A'
version = '3.0.0'
res = DepTools.check_if_ancestors_still_satisfied(
package, version, self.ancestors, self.package_requirements)
self.assertIn('y', res['conflicts'])
def test_check_no_conflicts(self):
"""
No conflicts if package is same as environment
"""
res = DepTools.check_if_ancestors_still_satisfied(
self.package, self.version, self.ancestors,
self.package_requirements)
self.assertEqual(res['conflicts'], {})
def test_contrived_obvious_example_0(self):
"""
Should run with no requirements.
"""
req_ex1 = {'project_name': 'A',
'version': '1.0.0',
'requires': {}, }
res = DepTools.check_req_deps_satisfied_by_current_env(
req_ex1, self.nodes)
self.sanity_checks(res)
def test_empty_lists_in_removed_and_new_for_fabtools(self):
"""
There should be no differences as we are comparing a package and
version that is already in the environment.
"""
res = DepTools.check_changes_in_requirements_vs_env(
self.fab_reqs, self.descendants)
self.assertEqual(res['removed_deps'], [])
self.assertEqual(res['new_deps'], [])
def test_empty_lists_in_removed_and_new_for_fabtools(self):
"""
There should be no differences as we are comparing a package and
version that is already in the environment.
"""
res = DepTools.check_changes_in_requirements_vs_env(
self.fab_reqs, self.descendants)
self.assertEqual(res['removed_deps'], [])
self.assertEqual(res['new_deps'], [])
def test_sanity(self):
"""
Should run without crashing.
"""
res = DepTools.check_if_ancestors_still_satisfied(
self.package, '1.0.0', self.ancestors, self.package_requirements)
self.assertEqual(type(res), dict)
self.assertIn('checks', res)
self.assertEqual(type(res['checks']), dict)
self.assertIn('conflicts', res)
self.assertEqual(type(res['conflicts']), dict)
def test_contrived_obvious_example_0(self):
"""
Should run with no requirements.
"""
req_ex1 = {
'project_name': 'A',
'version': '1.0.0',
'requires': {},
}
res = DepTools.check_req_deps_satisfied_by_current_env(
req_ex1, self.nodes)
self.sanity_checks(res)
def test_sanity(self):
"""
Should run without crashing.
"""
res = DepTools.check_if_ancestors_still_satisfied(
self.package, '1.0.0', self.ancestors, self.package_requirements)
self.assertEqual(type(res), dict)
self.assertIn('checks', res)
self.assertEqual(type(res['checks']), dict)
self.assertIn('conflicts', res)
self.assertEqual(type(res['conflicts']), dict)
def test_returns_false(self):
"""Should return False.
all reqs should fail.
"""
# self.cur_ver = '1.0.0'
req = ("==", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = (">=", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("!=", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("<=", "0.0.9")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("<", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = (">", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
def test_returns_false(self):
"""Should return False.
all reqs should fail.
"""
# self.cur_ver = '1.0.0'
req = ("==", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = (">=", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("!=", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("<=", "0.0.9")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = ("<", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
req = (">", "1.0.0")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertFalse(res)
def test_z_fails(self):
"""
Z should fail with B<1
"""
package = 'B'
version = '0.0.1'
ancestors, _ = Package.get_direct_links_to_any_package('B', self.edges)
res = DepTools.check_if_ancestors_still_satisfied(
package, version, ancestors, self.package_requirements)
self.assertIn('z', res['conflicts'])
def test_z_fails(self):
"""
Z should fail with B<1
"""
package = 'B'
version = '0.0.1'
ancestors, _ = Package.get_direct_links_to_any_package('B', self.edges)
res = DepTools.check_if_ancestors_still_satisfied(
package, version, ancestors, self.package_requirements)
self.assertIn('z', res['conflicts'])
def test_contrived_obvious_example_empty_reqs(self):
"""
remove B and C
A 3.0.0
Req: Nothing
"""
req_ex1 = {'project_name': 'A',
'version': '3.0.0',
'requires': {}, }
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(sorted(res['removed_deps']),
sorted(['B', 'C']))
self.assertEqual(res['new_deps'], [])
def test_contrived_obvious_example_empty_reqs(self):
"""
remove B and C
A 3.0.0
Req: Nothing
"""
req_ex1 = {
'project_name': 'A',
'version': '3.0.0',
'requires': {},
}
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(sorted(res['removed_deps']), sorted(['B', 'C']))
self.assertEqual(res['new_deps'], [])
def test_contrived_obvious_example_1(self):
"""
No new or removed dependencies for current package.
"""
req_ex1 = {'project_name': 'A',
'version': '1.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], }
},
}
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(res['removed_deps'], [])
self.assertEqual(res['new_deps'], [])
def test_contrived_obvious_example_1(self):
"""
All reqs should be satisfied.
"""
req_ex1 = {'project_name': 'A',
'version': '1.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], }, }, }
res = DepTools.check_req_deps_satisfied_by_current_env(
req_ex1, self.nodes)
self.sanity_checks(res)
missing = [] # no missing
conflicts = {} # no conflicts
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_multiple_requirements1(self):
"""Multiple requirements should be evaluated when present.
All reqs should be satisfied.
"""
req = {'project_name': 'A',
'version': '1.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0'],
['!=', '1.1.1']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], }, }, }
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
missing = [] # no missing
conflicts = {} # no conflicts
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_multiple_requirements2_conflicts(self):
"""Multiple requirements should be evaluated when present.
Should fail with conflicting reqs.
"""
req = {'project_name': 'A',
'version': '1.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0'],
['!=', '1.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], }, }, }
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.assertTrue('B' in res['conflicts'])
specs = req['requires']['b']['specs']
details = [(req['version'], specs[1][0], specs[1][1], False)]
self.assertEqual(res['conflicts']['B'], details)
def test_contrived_obvious_eg3_b_conflicts(self):
"""
'B' should be in conflicts
"""
req = {'project_name': 'A',
'version': '1.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '2.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], },
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
self.assertTrue('B' in res['conflicts'])
specs = req['requires']['b']['specs']
details = [(req['version'], specs[0][0], specs[0][1], False)]
self.assertEqual(res['conflicts']['B'], details)
def test_contrived_obvious_example_2(self):
"""
Add D, remove B
A 2.0.0
Req:
D == 1.0.0
C >= 0.0.5
"""
req_ex1 = {'project_name': 'A',
'version': '2.0.0',
'requires': {'b': {'key': 'd',
'project_name': 'D',
'specs': [['==', '1.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], }
},
}
res = DepTools.check_changes_in_requirements_vs_env(
req_ex1, self.descendants)
self.assertEqual(res['removed_deps'], ['B'])
self.assertEqual(res['new_deps'], ['D'])
def test_contrived_obvious_eg2_missing_req(self):
"""
'D' should be in missing
"""
req = {'project_name': 'A',
'version': '2.0.0',
'requires': {'b': {'key': 'b',
'project_name': 'B',
'specs': [['==', '1.0.0']], },
'c': {'key': 'c',
'project_name': 'C',
'specs': [['>=', '0.5.0']], },
'd': {'key': 'd',
'project_name': 'D',
'specs': [['>=', '40.5.0']], },
},
}
res = DepTools.check_req_deps_satisfied_by_current_env(req, self.nodes)
self.sanity_checks(res)
missing = ['D']
conflicts = {}
self.assertEqual(res['missing'], missing)
self.assertEqual(res['conflicts'], conflicts)
def test_returns_bool(self):
"""Should return boolean."""
req = ("==", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertEqual(type(res), bool)
def test_sanity(self):
"""
Check it runs without crashing.
"""
DepTools.check_changes_in_requirements_vs_env(
self.fab_reqs, self.descendants)
def test_sanity(self):
"""
Check it runs without crashing.
"""
DepTools.check_changes_in_requirements_vs_env(self.fab_reqs,
self.descendants)
def test_sanity_run(self):
"""Check runs without crashing"""
res = DepTools.check_req_deps_satisfied_by_current_env(
self.fab_reqs, self.nodes)
self.sanity_checks(res)
def test_sanity(self):
"""Check contrived version runs"""
package = 'A'
version = '1.0.0'
DepTools.check_if_ancestors_still_satisfied(
package, version, self.ancestors, self.package_requirements)
def test_sanity_run(self):
""" Check runs. """
req = ("==", "1.0.1")
DepTools.check_requirement_satisfied(self.cur_ver, req)
def test_sanity_run(self):
""" Check runs. """
req = ("==", "1.0.1")
DepTools.check_requirement_satisfied(self.cur_ver, req)
def test_sanity_run(self):
"""Check runs without crashing"""
res = DepTools.check_req_deps_satisfied_by_current_env(
self.fab_reqs, self.nodes)
self.sanity_checks(res)
def test_returns_bool(self):
"""Should return boolean."""
req = ("==", "1.0.1")
res, _ = DepTools.check_requirement_satisfied(self.cur_ver, req)
self.assertEqual(type(res), bool)
def _go(venv_name, **kwargs):
"""Main script of magellan program.
If an environment is passed in but doesn't exist, then exit.
If no environment is passed in, do analysis on current env.
If packages are specified then do package specific analysis.
Otherwise perform general analysis on environment.
"""
print_col = kwargs.get('colour') # print in colour
# Environment Setup
if not os.path.exists(MagellanConfig.cache_dir) and MagellanConfig.caching:
MagellanConfig.setup_cache()
if kwargs['list_all_versions']:
for p in kwargs['list_all_versions']:
print(p[0])
all_package_versions = PyPIHelper.all_package_versions_on_pypi(
p[0])
pprint(natsorted(all_package_versions))
sys.exit()
venv = Environment(venv_name)
venv.magellan_setup_go_env(kwargs)
requirements_file = kwargs.get('requirements_file')
package_list = Package.resolve_package_list(venv, kwargs)
packages = {p.lower(): venv.all_packages[p.lower()] for p in package_list}
if kwargs['outdated']:
if package_list:
Package.check_outdated_packages(packages, print_col)
elif requirements_file:
print("Analysing requirements file for outdated packages.")
Requirements.check_outdated_requirements_file(requirements_file,
pretty=print_col)
else: # if nothing passed in then check local env.
Package.check_outdated_packages(venv.all_packages, print_col)
sys.exit()
if kwargs['get_dependencies']: # -D
DepTools.acquire_and_display_dependencies(kwargs['get_dependencies'],
print_col)
if kwargs['get_ancestors']: # -A
ancestor_dictionary = \
DepTools.get_ancestors_of_packages(
kwargs['get_ancestors'], venv, print_col)
if kwargs['get_descendants']: # -Z
descendants_dictionary = \
DepTools.get_descendants_of_packages(
kwargs['get_descendants'], venv, print_col)
if kwargs['package_conflicts']: # -P
addition_conflicts, upgrade_conflicts = \
DepTools.process_package_conflicts(
kwargs['package_conflicts'], venv, print_col)
if kwargs['detect_env_conflicts']: # -C
cur_env_conflicts = DepTools.highlight_conflicts_in_current_env(
venv.nodes, venv.package_requirements, print_col)
if kwargs['compare_env_to_req_file']: # -R
if not requirements_file:
print("Please specify a requirements file with -r <file>")
else:
same, verdiff, req_only, env_only = \
Requirements.compare_req_file_to_env(requirements_file, venv)
Requirements.print_req_env_comp_lists(same, verdiff, req_only,
env_only, print_col)
def _go(venv_name, **kwargs):
"""Main script of magellan program.
If an environment is passed in but doesn't exist, then exit.
If no environment is passed in, do analysis on current env.
If packages are specified then do package specific analysis.
Otherwise perform general analysis on environment.
"""
print_col = kwargs.get('colour') # print in colour
# Environment Setup
if not os.path.exists(MagellanConfig.cache_dir) and MagellanConfig.caching:
MagellanConfig.setup_cache()
if kwargs['list_all_versions']:
for p in kwargs['list_all_versions']:
print(p[0])
all_package_versions = PyPIHelper.all_package_versions_on_pypi(
p[0])
pprint(natsorted(all_package_versions))
sys.exit()
venv = Environment(venv_name)
venv.magellan_setup_go_env(kwargs)
requirements_file = kwargs.get('requirements_file')
package_list = Package.resolve_package_list(venv, kwargs)
packages = {p.lower(): venv.all_packages[p.lower()] for p in package_list}
if kwargs['outdated']:
if package_list:
Package.check_outdated_packages(packages, print_col)
elif requirements_file:
print("Analysing requirements file for outdated packages.")
Requirements.check_outdated_requirements_file(
requirements_file, pretty=print_col)
else: # if nothing passed in then check local env.
Package.check_outdated_packages(venv.all_packages, print_col)
sys.exit()
if kwargs['get_dependencies']: # -D
DepTools.acquire_and_display_dependencies(
kwargs['get_dependencies'], print_col)
if kwargs['get_ancestors']: # -A
ancestor_dictionary = \
DepTools.get_ancestors_of_packages(
kwargs['get_ancestors'], venv, print_col)
if kwargs['get_descendants']: # -Z
descendants_dictionary = \
DepTools.get_descendants_of_packages(
kwargs['get_descendants'], venv, print_col)
if kwargs['package_conflicts']: # -P
addition_conflicts, upgrade_conflicts = \
DepTools.process_package_conflicts(
kwargs['package_conflicts'], venv, print_col)
if kwargs['detect_env_conflicts']: # -C
cur_env_conflicts = DepTools.highlight_conflicts_in_current_env(
venv.nodes, venv.package_requirements, print_col)
if kwargs['compare_env_to_req_file']: # -R
if not requirements_file:
print("Please specify a requirements file with -r <file>")
else:
same, verdiff, req_only, env_only = \
Requirements.compare_req_file_to_env(requirements_file, venv)
Requirements.print_req_env_comp_lists(
same, verdiff, req_only, env_only, print_col)