class TestRuleKey(_TestBase):
names = _direct_names
ignore_missing = [
i.name for i in rules.values()
if normalize(i.name) in [normalize(i) for i in bad_metadata]
]
@foreach(names)
def test_package(self, name):
assert normalize(name) == name
self._test_names([name], ignore_not_found=name in self.ignore_missing)
def _collate_preload():
packages = []
for rule in rules.values():
if rule.preload:
packages += [i for i in rule.preload if normalize(i) not in rules]
return sorted(set(packages))
def test_package(self, name):
expected = self.expected[name]
url = self._get_scm(name)
self.assertIsNotNone(url)
self.assertInsensitiveEqual(url, expected)
normalised_name = normalize(name)
fetch_list = _fetch_mapping[normalised_name]
self.assertFalse(fetch_list)
self._check_result(name, url)
if PY2:
return
if isinstance(expected, str):
self.assertLess(
_compute_similarity(name, expected),
0.05,
"{} - {} should be moved to name mismatches".format(name, expected),
)
else:
for i in expected:
self.assertLess(
_compute_similarity(name, i),
0.05,
"{} - {} should be moved to name mismatches".format(name, expected),
)
def test_package(self, name):
expected = self.expected[name]
try:
url = self._get_scm(name)
except unittest.SkipTest:
raise
except Exception:
if name in self.expected_failures:
return
raise
if name in self.expected_failures:
return
self.assertIsNotNone(url)
self.assertInsensitiveEqual(url, expected)
if isinstance(expected, str):
self.assertIn("/", expected, "{} should be {}".format(expected, url))
normalised_name = normalize(name)
fetch_list = _fetch_mapping[normalised_name]
self.assertFalse(fetch_list)
if normalised_name in missing_repos:
pass
elif url.startswith("https://github.com/"):
slug = url[len("https://github.com/") :]
rv = self._check_github_repo(slug)
self.assertTrue(rv)
try:
rv = self._check_github_setuppy(slug, normalised_name)
except GitHubAPIMessage as e:
raise unittest.SkipTest(str(e))
if rv is False:
return
self.assertTrue(rv)
else:
r = web_session.get(url)
r.raise_for_status()
if PY2:
return
if isinstance(expected, str):
self.assertGreater(_compute_similarity(name, expected), 0.05)
else:
highest = 0
for i in expected:
val = _compute_similarity(name, i)
highest = max(highest, val)
self.assertGreater(highest, 0.05)
def test_package(self, name):
expected = self.expected[name]
url = self._test_package(name)
if name in self.expected_failures:
return
self.assertIsNotNone(url)
self.assertInsensitiveEqual(url, expected)
if isinstance(expected, str):
self.assertIn("/", expected, "{} should be {}".format(expected, url))
normalised_name = normalize(name)
fetch_list = _fetch_mapping[normalised_name]
self.assertTrue(fetch_list)
if normalised_name in missing_repos:
pass
elif url.startswith("https://github.com/"):
slug = url[len("https://github.com/") :]
rv = self._check_github_repo(slug)
self.assertTrue(rv)
try:
rv = self._check_github_setuppy(slug, normalised_name)
except GitHubAPIMessage as e:
raise unittest.SkipTest(str(e))
if rv is False:
return
self.assertTrue(rv)
elif url == "https://wiki.mozilla.org/Auto-tools/Projects/Mozbase":
# Fetching is a bit slow, and failures for moz* are very repetitive
pass
else:
r = web_session.get(url)
r.raise_for_status()
if PY2:
return
if isinstance(expected, str):
self.assertGreater(_compute_similarity(name, expected), 0.05)
else:
highest = 0
for i in expected:
val = _compute_similarity(name, i)
highest = max(highest, val)
self.assertGreater(highest, 0.05)
def _check_github_setuppy(self, slug, rule):
if not isinstance(rule, Rule):
normalised_name = rule
rule = rules.get(normalised_name)
if not rule:
rule = DefaultRule(normalised_name)
for setuppy_rule in setuppy_mismatches:
setuppy_rule = normalize(setuppy_rule.strip("$"))
if rule.key.startswith(setuppy_rule):
return False
matches = [rule.key]
if normalised_name in setuppy_mismatches_xstatic:
matches = ["xstatic-pkg", normalised_name[8:]]
filenames = None
try:
filenames = [rule.repo_filename]
except AttributeError:
pass
try:
rv = get_repo_setuppy(slug, matches, filenames)
except GitHubAPIMessage as e:
raise unittest.SkipTest(str(e))
except HTTPError as e:
if "403" in str(e):
raise unittest.SkipTest(str(e))
raise
if rv is not None:
match_results = [match in normalize(rv) for match in matches]
assert all(match_results), "{}: {} not in:\n{}".format(
rule.key, matches, rv)
return rv
def test_package(self, name):
expected = self.expected[name]
url = self._get_scm(name)
self.assertIsNotNone(url)
self.assertInsensitiveEqual(url, expected)
normalised_name = normalize(name)
fetch_list = _fetch_mapping[normalised_name]
self.assertTrue(fetch_list)
if normalised_name in missing_repos:
pass
elif url.startswith("https://github.com/"):
slug = url[len("https://github.com/") :]
rv = self._check_github_repo(slug)
self.assertTrue(rv)
try:
rv = self._check_github_setuppy(slug, normalised_name)
except GitHubAPIMessage as e:
raise unittest.SkipTest(str(e))
if rv is False:
return
self.assertTrue(rv)
else:
r = web_session.get(url)
r.raise_for_status()
if PY2:
return
if isinstance(expected, str):
self.assertLess(
_compute_similarity(name, expected),
0.05,
"{} - {} should be moved to name mismatches".format(name, expected),
)
else:
for i in expected:
self.assertLess(
_compute_similarity(name, i),
0.05,
"{} - {} should be moved to name mismatches".format(name, expected),
)
def _check_result(self, name, url):
normalised_name = normalize(name)
r = None
if normalised_name in missing_repos:
pass
elif url.startswith("https://github.com/"):
slug = url[len("https://github.com/") :]
rv = self._check_github_repo(slug)
self.assertTrue(rv)
try:
rv = self._check_github_setuppy(slug, normalised_name)
except GitHubAPIMessage as e:
raise unittest.SkipTest(str(e))
if rv is False:
return
self.assertTrue(rv)
else:
r = web_session.get(url, allow_redirects=False)
if r is not None:
r.raise_for_status()
self.assertEqual(r.url, url)
location = r.headers.get("location")
if location:
self.assertIn(r.status_code, [301, 302])
location = location.replace(
"code.google.com/archive/p/", "code.google.com/p/"
)
self.assertIn(location, [url, url + "/"])
else:
self.assertEqual(r.status_code, 200)
def test_package(self, name):
assert normalize(name) == name
self._test_names([name])
def test_package(self, name):
assert normalize(name) == name
self._test_names([name], ignore_not_found=name in self.ignore_missing)
def normalise_list(in_list):
return [normalize(name) for name in in_list]
def _test_names(self, names, ignore_not_found=False, ignore_setuppy=False):
assert len(names) == 1
expected_failures = [normalize(i) for i in self.expected_failures]
name = names[0]
normalised_name = normalize(name)
try:
url = self._get_scm(name)
except unittest.SkipTest:
raise
except InvalidPackage:
if (normalised_name in expected_failures or self._ignore_invalid
or ignore_not_found):
return
raise
except IncompletePackageMetadata:
if PY2:
return
if (normalised_name in expected_failures or self._ignore_invalid
or self._allow_missing or ignore_not_found):
return
raise
except Exception:
if PY2 or normalised_name in expected_failures:
return
raise
if not url:
if (normalised_name in expected_failures or self._allow_missing
or ignore_not_found):
return
assert False, name
if normalised_name in missing_repos or normalised_name in expected_failures:
return
if name in wrong_result:
return
distance = _compute_similarity(name, url)
if distance < 0.1:
pass
else:
normalised_name = normalize(name)
mismatch_urls = [
value for key, value in mismatch.items()
if normalize(key) == normalised_name
]
if url.lower() in [
"https://github.com/azure/azure-sdk-for-python",
"https://github.com/azure/azure-cli",
]:
return
elif mismatch_urls:
if (url not in multipackage_repos
and url.lower() not in multipackage_repos):
assert len(mismatch_urls) == 1, "{} matched {}".format(
name, mismatch_urls)
expected_url = mismatch_urls[0]
self.assertInsensitiveEqual(url, expected_url)
else:
if True:
for rule in setuppy_mismatches:
if rule.endswith("-") and normalised_name.startswith(
rule):
break
else:
raise Exception(
'"{}": "{}" should be in mismatches'.format(
name, url))
if url.startswith("https://github.com/"):
slug = url[len("https://github.com/"):]
try:
rv = self._check_github_repo(slug)
except unittest.SkipTest:
raise
except Exception:
rv = None
if not rv:
if PY2 or name in self.expected_failures:
return
elif name in wrong_result:
return
elif ignore_setuppy:
return
assert False, slug
self._check_github_setuppy(slug, normalised_name)
else:
r = web_session.get(url, timeout=get_timeout(url))
r.raise_for_status()
