def main():
deps = testdata.DEPS_MODERATE
versions_by_package = depdata.generate_dict_versions_by_package(deps)
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = depdata.elaborate_dependencies(
deps, versions_by_package
)
assert depdata.are_deps_valid(testdata.DEPS_MODERATE) and depdata.are_deps_valid(
testdata.DEPS_SIMPLE
), "The test dependencies are coming up as invalid for some reason...."
# Clear any pre-existing test database.
sqli.initialize(db_fname="data/test_dependencies.db")
sqli.delete_all_tables()
sqli.populate_sql_with_full_dependency_info(
edeps,
versions_by_package,
packs_wout_avail_version_info,
dists_w_missing_dependencies,
db_fname="data/test_dependencies.db",
)
print("All tests in main() OK.")
def test_depdata():
"""
"""
assert 41 == len(testdata.DEPS_MODERATE), \
"Set changed: should be len 41 but is len " + \
str(len(testdata.DEPS_MODERATE)) + " - reconfigure tests"
json.dump(testdata.DEPS_MODERATE, open('data/test_deps_set.json', 'w'))
deps = depdata.load_json_db('data/test_deps_set.json')
assert testdata.DEPS_MODERATE == deps, \
"JSON write and load via load_json_db is breaking!"
versions_by_package = depdata.generate_dict_versions_by_package(deps)
assert 10 == len(versions_by_package) # different package names
total_package_versions = \
sum([len(versions_by_package[p]) for p in versions_by_package])
assert 41 == total_package_versions, \
"Wrong number of versions: " + str(total_package_versions) + "instead" \
+ "of 41."
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = \
depdata.elaborate_dependencies(deps, versions_by_package)
# 1 entry in the edeps dict
assert 41 == len(edeps), \
"Wrong number of dists in elaborate_dependencies output. " + \
str(len(edeps)) + "instead of 41."
# 1 version listed for every possible satisfying dependency
n_dependencies_elaborated = 0
for distkey in edeps:
for satisfying_package_entry in edeps[distkey]:
list_of_satisfying_versions = satisfying_package_entry[1]
n_dependencies_elaborated += len(list_of_satisfying_versions)
#print(distkey + " -> " + str(list_of_satisfying_versions))
assert 34 == n_dependencies_elaborated, \
"Expecting 34 satisfying versions (1 for every [depending dist]" + \
",[satisfying_version] pair. Instead, got " + \
str(n_dependencies_elaborated)
assert depdata.are_deps_valid(testdata.DEPS_MODERATE) and \
depdata.are_deps_valid(testdata.DEPS_SIMPLE), \
'The test dependencies are coming up as invalid for some reason....'
print("test_depdata(): All tests OK.")
def test_depdata():
"""
"""
assert 41 == len(testdata.DEPS_MODERATE), (
"Set changed: should be len 41 but is len " + str(len(testdata.DEPS_MODERATE)) + " - reconfigure tests"
)
json.dump(testdata.DEPS_MODERATE, open("data/test_deps_set.json", "w"))
deps = depdata.load_json_db("data/test_deps_set.json")
assert testdata.DEPS_MODERATE == deps, "JSON write and load via load_json_db is breaking!"
versions_by_package = depdata.generate_dict_versions_by_package(deps)
assert 10 == len(versions_by_package) # different package names
total_package_versions = sum([len(versions_by_package[p]) for p in versions_by_package])
assert 41 == total_package_versions, (
"Wrong number of versions: " + str(total_package_versions) + "instead" + "of 41."
)
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = depdata.elaborate_dependencies(
deps, versions_by_package
)
# 1 entry in the edeps dict
assert 41 == len(edeps), (
"Wrong number of dists in elaborate_dependencies output. " + str(len(edeps)) + "instead of 41."
)
# 1 version listed for every possible satisfying dependency
n_dependencies_elaborated = 0
for distkey in edeps:
for satisfying_package_entry in edeps[distkey]:
list_of_satisfying_versions = satisfying_package_entry[1]
n_dependencies_elaborated += len(list_of_satisfying_versions)
# print(distkey + " -> " + str(list_of_satisfying_versions))
assert 34 == n_dependencies_elaborated, (
"Expecting 34 satisfying versions (1 for every [depending dist]"
+ ",[satisfying_version] pair. Instead, got "
+ str(n_dependencies_elaborated)
)
assert depdata.are_deps_valid(testdata.DEPS_MODERATE) and depdata.are_deps_valid(
testdata.DEPS_SIMPLE
), "The test dependencies are coming up as invalid for some reason...."
print("test_depdata(): All tests OK.")
def test_detect_model_2_conflicts():
"""TEST 3: Detection of model 2 conflicts."""
deps = testdata.DEPS_MODEL2
versions_by_package = depdata.generate_dict_versions_by_package(deps)
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = \
depdata.elaborate_dependencies(deps, versions_by_package)
success = ry.detect_model_2_conflict_from_distkey('motorengine(0.7.4)',
edeps,
versions_by_package)
if not success:
logger.error(
'Did not detect model 2 conflict for motorengine(0.7.4). ):')
else:
logger.info("test_resolver(): Test 3 OK.")
return success
def main():
deps = testdata.DEPS_MODERATE
versions_by_package = depdata.generate_dict_versions_by_package(deps)
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = \
depdata.elaborate_dependencies(deps, versions_by_package)
assert depdata.are_deps_valid(testdata.DEPS_MODERATE) and \
depdata.are_deps_valid(testdata.DEPS_SIMPLE), \
'The test dependencies are coming up as invalid for some reason....'
# Clear any pre-existing test database.
sqli.initialize(db_fname='data/test_dependencies.db')
sqli.delete_all_tables()
sqli.populate_sql_with_full_dependency_info(
edeps,
versions_by_package,
packs_wout_avail_version_info,
dists_w_missing_dependencies,
db_fname='data/test_dependencies.db')
print('All tests in main() OK.')
def test_resolver(resolver_func,
expected_result,
distkey,
deps,
versions_by_package=None,
edeps=None,
expected_exception=None,
use_raw_deps=False):
"""
Returns True if the given resolver function returns the expected result on
the given data, else False. More modes described in args notes below.
Solutions are compared with intelligent version parsing outsourced partly to
pip's pip._vendor.packaging.version classes. For example, 2.0 and 2 and 2.0.0
are all treated as equivalent.
Arguments:
resolver_func
Argument resolver_func should be a function that accepts 3 arguments and
returns a solution list:
- Arg 1: distkey to generate an install set for, whose installation
results in a fully satisfied set of dependencies
- Arg 2: dependency data (either deps or edeps, per depdata.py)
- Arg 3: versions_by_package, a dict mapping package names to all
versions of that package available
- Return: a list containing the distkeys for dists to install
expected_result
This should be a list of distkeys. If the list given matches the solution
generated by calling resolver_func with the appropriate arguments, we
return True.
If this is None, then we don't care what solution is returned by the call
to resolver_func, only that no unexpected exceptions were raised and
any expected exception was raised.
distkey
The distkey of the distribution to solve for (find install set that
fully satisfies).
deps
Dependency data to be used in resolution.
Optional Arguments:
versions_by_package
As described elsewhere, the dictionary mapping package names to available
versions of those packages. If not provided, this is generated from deps.
use_raw_deps
If True, we do not try to elaborate dependencies (or use provided
elaborated dependencies), instead passing the deps provided on in our
call to resolver_func. Some resolvers do not use elaborated dependencies.
edeps
If provided, we don't elaborate the deps argument, but instead use these.
expected_exception
The type() of an exception that we expect to receive. If provided, we
disregard expected_result and instead expect to catch an exception of the
indicated type, returning True if we catch one and False otherwise.
Raises:
- UnresolvableConflictError (reraise) if unable to resolve and we were not
told to expect UnresolvableConflictError. (Same goes for any other
exceptions generated by call to resolver_func.)
Side Effects:
(NO:
Used to also write dependency graph to resolver/output/test_resolver_* in
graphviz .dot format, but have turned this off for now.)
"""
if versions_by_package is None:
versions_by_package = depdata.generate_dict_versions_by_package(deps)
if use_raw_deps:
edeps = deps
elif edeps is None:
(edeps, packs_wout_avail_version_info, dists_w_missing_dependencies) = \
depdata.elaborate_dependencies(deps, versions_by_package)
solution = None
try:
#(solution, _junk_, dotstrings) = \
solution = \
resolver_func(distkey, edeps, versions_by_package)
except Exception as e:
if expected_exception is None or type(e) is not expected_exception:
logger.exception('Test Failure: Unexpectedly unable to resolve ' +
distkey)
# Compromise traceback style so as not to give up python2 compatibility.
six.reraise(
UnexpectedException,
UnexpectedException('Unexpectedly '
'unable to resolve ' + distkey),
sys.exc_info()[2])
# Python 3 style (by far the nicest):
#raise UnexpectedException('Unexpectedly unable to resolve ' + distkey) \
# from e
# Original (2 or 3 compatible but not great on either, especially not 2)
#raise
#return False
else:
# We expected this error.
logger.info('As expected, unable to resolve ' + distkey +
' due to ' + str(type(e)) + '.')
logger.info(' Exception caught: ' + e.args[0])
return True
else:
logger.info('Resolved ' + distkey + '. Solution: ' + str(solution))
#if dotstrings is not None: # If the func provides dotstrings
# fobj = open('data/resolver/test_resolver_' + resolver_func.__name__ +
# '_' + distkey + '.dot', 'w')
# fobj.write('digraph G {\n' + dotstrings + '}\n')
# fobj.close()
# Were we expecting an exception? (We didn't get one if we're here.)
if expected_exception is not None:
logger.info('Expecting exception (' + str(expected_exception) +
') but '
'none were raised. Was solving for ' + distkey +
' using ' + resolver_func.__name__)
return False
# If expected_result is None, then we didn't care what the result was as
# long as there was no unexpected exception / as long as whatever exception
# is expected was raised.
elif expected_result is None:
logger.info(
'No particular solution expected and resolver call did not '
'raise an exception, therefore result is acceptable. Was solving '
'for ' + distkey + ' using ' + resolver_func.__name__)
return True
# Is the solution set as expected?
elif ry.dist_lists_are_equal(solution, expected_result):
logger.info('Solution is as expected.')
return True
else:
logger.info('Solution does not match while solving for ' +
distkey + ' using ' + resolver_func.__name__ + ':')
logger.info(' Expected: ' + str(sorted(expected_result)))
logger.info(' Produced: ' + str(sorted(solution)))
return False
