def test_distro_delete_cascade(self):
"""Assert deletion of mapped packages when project is deleted"""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
ecosystem_name="pypi",
version_scheme="Invalid",
)
self.session.add(project)
distro = models.Distro(name="Fedora")
self.session.add(distro)
package = models.Packages(project_id=1,
distro_name="Fedora",
package_name="test")
self.session.add(package)
self.session.commit()
distros = self.session.query(models.Distro).all()
self.assertEqual(len(distros), 1)
self.assertEqual(len(distros[0].package), 1)
self.session.delete(distros[0])
self.session.commit()
distros = self.session.query(models.Distro).all()
packages = self.session.query(models.Packages).all()
self.assertEqual(len(distros), 0)
self.assertEqual(len(packages), 0)
def test_parse_json_tag_missing(self):
"""Test parsing a JSON skips releases where tag is missing."""
project = models.Project(
name="foobar",
homepage="https://foobar.com",
version_url="foo/bar",
backend=BACKEND,
releases_only=True,
)
json = {
"data": {
"repository": {
"releases": {
"totalCount": 1,
"edges": [
{
"node": {"name": "This is a release", "tag": None},
},
],
},
},
"rateLimit": {"limit": 5000, "remaining": 5000, "resetAt": "dummy"},
}
}
obs = backend.parse_json(json, project)
self.assertEqual([], obs)
def test_get_sorted_version_objects(self):
"""Assert that sorted versions are included in the list returned from
:data:`Project.get_sorted_version_objects`.
"""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
ecosystem_name="pypi",
version_scheme="RPM",
)
self.session.add(project)
self.session.commit()
version_first = models.ProjectVersion(project_id=project.id,
version="0.8")
version_second = models.ProjectVersion(project_id=project.id,
version="1.0")
self.session.add(version_first)
self.session.add(version_second)
self.session.commit()
versions = project.get_sorted_version_objects()
self.assertEqual(len(versions), 2)
self.assertEqual(versions[0].version, version_second.version)
self.assertEqual(versions[1].version, version_first.version)
def test_parse_json_threshold_reach(self):
"""
Assert that exception is thrown when
rate limit threshold is reached.
"""
project = models.Project(
name="foobar",
homepage="https://foobar.com",
version_url="foo/bar",
backend=BACKEND,
)
json = {
"data": {
"repository": {
"refs": {
"totalCount": 0
}
},
"rateLimit": {
"limit": 5000,
"remaining": 500,
"resetAt": "2008-09-03T20:56:35.450686",
},
}
}
self.assertRaises(RateLimitException, backend.parse_json, json,
project)
def test_get_versions_filter(self):
"""Test the get_versions functions with releases only."""
project = models.Project(
name="the-new-hotness",
homepage="https://github.com/fedora-infra/the-new-hotness",
version_url="fedora-infra/the-new-hotness",
backend=BACKEND,
releases_only=True,
version_filter=".9",
)
exp = [
"0.10.0",
"0.10.1",
"0.11.0",
"0.11.1",
"0.11.2",
"0.11.3",
"0.11.4",
"0.11.5",
"0.11.6",
"0.11.7",
"0.11.8",
"0.12.0",
"0.13.0",
"0.13.1",
"0.13.2",
"0.13.3",
"0.13.4",
]
obs = backend.GithubBackend.get_ordered_versions(project)
self.assertEqual(obs, exp)
def test_get_versions_gnash(self):
"""
Assert that versions of the gnash project is received correctly.
"""
project = models.Project(
name="gnash",
homepage="https://www.gnu.org/software/gnash/",
version_url="https://ftp.gnu.org/pub/gnu/gnash/",
backend=BACKEND,
)
exp = [
"0.7.1",
"0.7.2",
"0.8.0",
"0.8.1",
"0.8.10",
"0.8.2",
"0.8.3",
"0.8.4",
"0.8.5",
"0.8.6",
"0.8.7",
"0.8.8",
"0.8.9",
]
obs = backend.FolderBackend.get_versions(project)
self.assertEqual(sorted(obs), exp)
def test_get_versions(self):
""" Test the get_versions function of the gitlab backend. """
pid = 1
project = models.Project.get(self.session, pid)
exp = [
u'0.6.1', u'0.6.1.1', u'0.6.2', u'0.6.3', u'0.6.4', u'0.6.5',
u'0.6.6', u'0.6.7', u'0.6.8', u'0.7.0', u'0.7.1', u'0.8.0',
u'0.8.1', u'0.8.2', u'0.8.3', u'0.8.4', u'0.8.5', u'0.8.6',
u'0.8.7', u'0.8.8'
]
obs = backend.GitlabBackend.get_ordered_versions(project)
self.assertEqual(obs, exp)
pid = 2
project = models.Project.get(self.session, pid)
self.assertRaises(AnityaPluginException,
backend.GitlabBackend.get_versions, project)
pid = 3
project = models.Project.get(self.session, pid)
exp = [
u'xonotic-v0.1.0preview', u'xonotic-v0.5.0', u'xonotic-v0.6.0',
u'xonotic-v0.7.0', u'xonotic-v0.8.0', u'xonotic-v0.8.1',
u'xonotic-v0.8.2'
]
obs = backend.GitlabBackend.get_ordered_versions(project)
self.assertEqual(obs, exp)
project = models.Project(
name='foobar',
homepage='',
backend=BACKEND,
)
self.assertRaises(AnityaPluginException,
backend.GitlabBackend.get_versions, project)
def test_update_project_backend_blacklist(self,
mock_check_project_release):
"""
Assert that project next_check is set to correct_time when backend
is blacklisted.
"""
project = models.Project(
name="Foobar",
backend="GitHub",
homepage="www.fakeproject.com",
next_check=arrow.utcnow().datetime,
)
self.session.add(project)
self.session.commit()
reset_time = project.next_check + timedelta(hours=1)
with mock.patch.dict(self.checker.blacklist_dict,
{"GitHub": reset_time}):
self.checker.update_project(project.id)
self.assertEqual(project.next_check, reset_time)
self.assertEqual(self.checker.ratelimit_counter, 1)
self.assertEqual(self.checker.success_counter, 0)
self.assertEqual(self.checker.error_counter, 0)
self.assertEqual(self.checker.ratelimit_queue["GitHub"][0], project.id)
def test_run(self):
"""
Assert that `db.Run` is created at the end of run with success.
"""
project = models.Project(
name="Foobar",
backend="GitHub",
homepage="www.fakeproject.com",
next_check=arrow.utcnow().datetime,
)
self.session.add(project)
self.session.commit()
def increment(project_id):
self.checker.success_counter = self.checker.success_counter + 1
self.checker.update_project = increment
self.checker.run()
run_objects = models.Run.query.all()
self.assertEqual(len(run_objects), 1)
self.assertEqual(run_objects[0].total_count, 1)
self.assertEqual(run_objects[0].error_count, 0)
self.assertEqual(run_objects[0].ratelimit_count, 0)
self.assertEqual(run_objects[0].success_count, 1)
def test_is_delete_candidate_mapping_no_version(self):
"""
Assert that project is marked as delete candidate,
if it has mapping added and no version.
"""
project = models.Project(
name="Foobar",
backend="GitHub",
homepage="www.fakeproject.com",
next_check=arrow.utcnow().datetime,
error_counter=100,
)
self.session.add(project)
self.session.commit()
distro = models.Distro(name="Fedora")
self.session.add(distro)
self.session.commit()
mapping = models.Packages(distro_name="Fedora", project_id=project.id)
self.session.add(mapping)
self.session.commit()
result = self.checker.is_delete_candidate(project)
self.assertTrue(result)
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='pagure',
homepage='https://pagure.io/pagure',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='fake',
homepage='https://pagure.io/fake',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def test_validate_backend(self):
project = models.Project(
name="test", homepage="https://example.com", backend="custom"
)
self.session.add(project)
self.session.commit()
self.assertEqual(1, self.session.query(models.Project).count())
self.assertEqual("custom", self.session.query(models.Project).one().backend)
def test_plexus_utils(self):
""" Regression test for issue #286 """
project = models.Project(
version_url='codehaus-plexus/plexus-archiver',
version_prefix='plexus-archiver-',
)
version = backend.GithubBackend().get_version(project)
self.assertEqual(u'3.6.0', version)
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='Biobase',
homepage='https://hackage.haskell.org/package/Biobase',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='non-existent-package-that-does-not-exist',
homepage='https://hackage.haskell.org/package/non-existent-package-that-does-not-exist',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='Biobase',
homepage='http://hackage.haskell.org/package/Biobase',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='foobar',
homepage='http://hackage.haskell.org/package/foobar',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='exaile',
homepage='https://launchpad.net/exaile',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='foo',
homepage='https://launchpad.net/foo',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='PHP-UML',
homepage='https://pear.php.net/package/PHP_UML',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='foo',
homepage='https://pear.php.net/package/foo',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='arduino',
homepage='https://code.google.com/p/arduino/',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='foo',
homepage='https://code.google.com/p/foo',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name="cpphs",
homepage="https://www.stackage.org/package/cpphs",
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name="foobar",
homepage="https://www.stackage.org/package/foobar",
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def test_get_version_url(self):
""" Assert that correct url is returned. """
project = models.Project(name='test',
homepage='https://example.com',
backend='custom',
version_url='https://example.com/releases',
ecosystem_name='pypi')
self.assertEqual(project.version_url, project.get_version_url())
def test_get_version_url_no_backend(self):
""" Assert that empty string is returned when backend is not specified. """
project = models.Project(
name='test',
homepage='https://example.com',
ecosystem_name='pypi',
)
self.assertEqual('', project.get_version_url())
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='SOAP',
homepage='http://search.cpan.org/dist/SOAP/',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='foo',
homepage='http://search.cpan.org/dist/foo/',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def create_project(self):
""" Create some basic projects to work with. """
project = models.Project(
name='bio',
homepage='https://rubygems.org/gems/bio',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
project = models.Project(
name='biofoobar',
homepage='https://rubygems.org/gems/biofoobar',
backend=BACKEND,
)
self.session.add(project)
self.session.commit()
def __init__(self, *args, **kwargs):
super(JsonTests, self).__init__(*args, **kwargs)
self.maxDiff = None
self.project = models.Project(
name="foobar",
homepage="https://foobar.com",
version_url="foo/bar",
backend=BACKEND,
)
def test_plexus_utils(self):
""" Regression test for issue #286 """
project = models.Project(
version_url="codehaus-plexus/plexus-archiver",
version_prefix="plexus-archiver-",
backend=BACKEND,
)
version = backend.GithubBackend().get_version(project)
self.assertEqual("plexus-archiver-3.6.0", version)
def test_filter_distribution(self):
"""Assert retrieving other pages works."""
project = models.Project(
name='requests',
homepage='https://pypi.io/project/requests',
backend='PyPI',
)
fedora_package = models.Packages(distro_name='Fedora',
project=project,
package_name='python-requests')
debian_package = models.Packages(distro_name='Debian',
project=project,
package_name='python-requests')
Session.add_all([project, fedora_package, debian_package])
Session.commit()
fedora = self.app.get('/api/v2/packages/?distribution=Fedora')
debian = self.app.get('/api/v2/packages/?distribution=Debian')
self.assertEqual(fedora.status_code, 200)
self.assertEqual(debian.status_code, 200)
fedora_data = _read_json(fedora)
debian_data = _read_json(debian)
fedora_exp = {
'page':
1,
'items_per_page':
25,
'total_items':
1,
'items': [
{
"distribution": "Fedora",
"name": "python-requests",
"project": "requests",
"ecosystem": "pypi"
},
]
}
debian_exp = {
'page':
1,
'items_per_page':
25,
'total_items':
1,
'items': [
{
"distribution": "Debian",
"name": "python-requests",
"project": "requests",
"ecosystem": "pypi"
},
]
}
self.assertEqual(fedora_data, fedora_exp)
self.assertEqual(debian_data, debian_exp)
def test_ecosystem_in_json(self):
"""Assert the ecosystem is included in the dict returned from ``__json__``"""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
ecosystem_name="pypi",
)
self.assertEqual("pypi", project.__json__()["ecosystem"])
def test_ecosystem_in_json(self):
"""Assert the ecosystem is included in the dict returned from ``__json__``"""
project = models.Project(
name='test',
homepage='https://example.com',
backend='custom',
ecosystem_name='pypi',
)
self.assertEqual('pypi', project.__json__()['ecosystem'])
def test_gargoyle(self):
""" Regression test for issue #642 """
project = models.Project(
version_url='garglk/garglk',
version_scheme='Date',
backend=BACKEND,
)
version = backend.GithubBackend().get_version(project)
self.assertEqual(u'stable-2011.1', version)
def test_get_version_url(self):
"""Assert that correct url is returned."""
project = models.Project(name="test",
homepage="http://example.org",
backend=BACKEND)
exp = "http://freshmeat.net/projects/test"
obs = backend.FreshmeatBackend.get_version_url(project)
self.assertEqual(obs, exp)
