def 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='Date')
version_first = models.ProjectVersion(
project_id=project.id,
version='1.0',
)
version_second = models.ProjectVersion(
project_id=project.id,
version='0.8',
)
self.session.add(project)
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 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",
)
version_first = models.ProjectVersion(project_id=project.id,
version="1.0")
version_second = models.ProjectVersion(project_id=project.id,
version="0.8")
self.session.add(project)
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_check_project_release_old_version(self, mock_method):
"""
Test the check_project_release function for Project.
This test will test if the fedora message is sent even if
the version is not the newest.
"""
with fml_testing.mock_sends(anitya_schema.ProjectCreated):
project = utilities.create_project(
self.session,
name="pypi_and_npm",
homepage="https://example.com/not-a-real-npmjs-project",
backend="npmjs",
user_id="*****@*****.**",
version_scheme="RPM",
)
# Create version
version = models.ProjectVersion(project_id=project.id, version="1.0.0")
self.session.add(version)
self.session.commit()
with fml_testing.mock_sends(anitya_schema.ProjectVersionUpdated,
anitya_schema.ProjectVersionUpdatedV2):
utilities.check_project_release(project, self.session)
versions = project.get_sorted_version_objects()
self.assertEqual(len(versions), 2)
self.assertEqual(versions[0].version, "1.0.0")
self.assertEqual(versions[1].version, "0.9.9")
def setUp(self):
super(DeleteProjectVersionTests, self).setUp()
session = Session()
# Add a project with a version to delete.
self.project = models.Project(
name='test_project',
homepage='https://example.com/test_project',
backend='PyPI',
)
self.project_version = models.ProjectVersion(project=self.project, version='1.0.0')
# Add a regular user and an admin user
self.user = models.User(email='*****@*****.**', username='******')
self.admin = models.User(email='*****@*****.**', username='******')
session.add_all([self.user, self.admin, self.project, self.project_version])
session.commit()
mock_config = mock.patch.dict(
models.anitya_config, {'ANITYA_WEB_ADMINS': [six.text_type(self.admin.id)]})
mock_config.start()
self.addCleanup(mock_config.stop)
self.client = self.flask_app.test_client()
def test_is_delete_candidate_mapping_version_exists(self):
"""
Assert that project is not marked as delete candidate,
if it has mapping added and at least one 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()
version = models.ProjectVersion(version="1.0.0", project_id=project.id)
self.session.add(version)
self.session.commit()
result = self.checker.is_delete_candidate(project)
self.assertFalse(result)
def test_latest_version_object_with_versions(self):
"""Test the latest_version_object property with versions."""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
ecosystem_name="pypi",
version_scheme="RPM",
)
self.session.add(project)
self.session.flush()
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.flush()
self.assertEqual(project.latest_version_object.version, version_second.version)
def test_get_last_created_version(self):
"""
Assert that last retrieved version is returned.
"""
project = models.Project(
name="test", homepage="https://example.com", ecosystem_name="pypi"
)
self.session.add(project)
self.session.commit()
version_first = models.ProjectVersion(project_id=project.id, version="1.0")
version_second = models.ProjectVersion(project_id=project.id, version="0.8")
self.session.add(version_first)
self.session.add(version_second)
self.session.commit()
version = project.get_last_created_version()
self.assertEqual(version, version_second)
def test_get_last_created_version_no_date_all_versions(self):
"""
Assert that None is returned,
when every version doesn't have date filled.
"""
project = models.Project(
name="test", homepage="https://example.com", ecosystem_name="pypi"
)
self.session.add(project)
self.session.commit()
version_first = models.ProjectVersion(project_id=project.id, version="1.0")
version_second = models.ProjectVersion(project_id=project.id, version="0.8")
self.session.add(version_first)
self.session.add(version_second)
self.session.commit()
version_first.created_on = None
version_second.created_on = None
version = project.get_last_created_version()
self.assertEqual(version, None)
def test_stable_versions(self):
"""
Assert that only stable versions are retrieved.
"""
project = models.Project(
name="test",
homepage="https://example.com",
ecosystem_name="pypi",
version_scheme="Semantic",
)
self.session.add(project)
self.session.commit()
version_stable = models.ProjectVersion(project_id=project.id,
version="1.0.0")
version_pre_release = models.ProjectVersion(project_id=project.id,
version="1.0.0-alpha")
self.session.add(version_stable)
self.session.add(version_pre_release)
self.session.commit()
versions = project.stable_versions
self.assertEqual([str(version) for version in versions], ["1.0.0"])
def test_api_projects_versions(self):
"""
Assert that the correct version prefix is removed.
Test for https://github.com/fedora-infra/anitya/issues/1026
"""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
version_scheme="RPM",
version_prefix="test-",
latest_version="0.1.0",
)
self.session.add(project)
self.session.commit()
version = models.ProjectVersion(
project_id=project.id, version="test-0.1.0", project=project
)
self.session.add(version)
self.session.commit()
output = self.app.get("/api/projects/?homepage=https://example.com")
self.assertEqual(output.status_code, 200)
data = _read_json(output)
for key in range(len(data["projects"])):
del data["projects"][key]["created_on"]
del data["projects"][key]["updated_on"]
exp = {
"projects": [
{
"id": 1,
"backend": "custom",
"homepage": "https://example.com",
"ecosystem": "https://example.com",
"name": "test",
"regex": None,
"version": "0.1.0",
"version_url": None,
"versions": ["0.1.0"],
"stable_versions": ["0.1.0"],
}
],
"total": 1,
}
self.assertEqual(data, exp)
def test_check_project_release_no_new_version(self, mock_method):
""" Test the check_project_release function for Project. """
project = utilities.create_project(
self.session,
name="pypi_and_npm",
homepage="https://example.com/not-a-real-npmjs-project",
backend="npmjs",
user_id="*****@*****.**",
)
project.latest_version = "1.0.0"
version = models.ProjectVersion(version="1.0.0", project_id=project.id)
self.session.add(version)
self.session.commit()
utilities.check_project_release(project, self.session)
self.assertEqual(project.latest_version, "1.0.0")
self.assertEqual(project.logs, "No new version found")
def test_check_project_release_no_new_version(self, mock_method):
""" Test the check_project_release function for Project. """
project = utilities.create_project(
self.session,
name='pypi_and_npm',
homepage='https://example.com/not-a-real-npmjs-project',
backend='npmjs',
user_id='*****@*****.**',
)
project.latest_version = '1.0.0'
version = models.ProjectVersion(version='1.0.0', project_id=project.id)
self.session.add(version)
self.session.commit()
utilities.check_project_release(project, self.session)
self.assertEqual(project.latest_version, '1.0.0')
self.assertEqual(project.logs, 'No new version found')
def test_get_time_last_created_version(self):
"""
Assert that time of last retrieved version is returned.
"""
project = models.Project(name="test",
homepage="https://example.com",
ecosystem_name="pypi")
self.session.add(project)
self.session.commit()
time_now = arrow.utcnow()
version = models.ProjectVersion(project_id=project.id,
created_on=time_now.datetime,
version="1.0")
self.session.add(version)
self.session.commit()
last_version_time = project.get_time_last_created_version()
self.assertEqual(last_version_time, time_now)
def test_pre_release(self):
"""Test the pre_release property on version."""
project = models.Project(
name="test",
homepage="https://example.com",
backend="custom",
ecosystem_name="pypi",
version_scheme="Semantic",
)
self.session.add(project)
self.session.flush()
version = models.ProjectVersion(
project_id=project.id,
version="v0.8.0-alpha",
project=project,
)
self.session.add(version)
self.session.flush()
self.assertTrue(version.pre_release)
def check_project_release(project, session, test=False):
''' Check if the provided project has a new release available or not.
:arg package: a Package object has defined in anitya.db.modelss.Project
'''
backend = plugins.get_plugin(project.backend)
if not backend:
raise exceptions.AnityaException('No backend was found for "%s"' %
project.backend)
publish = False
versions_prefix = []
max_version = ''
# don't change actual data during test run
if not test:
project.last_check = arrow.utcnow().datetime
project.next_check = project.last_check + backend.check_interval
try:
versions_prefix = backend.get_versions(project)
except exceptions.RateLimitException as err:
_log.exception("AnityaError catched:")
if not test:
project.logs = str(err)
project.next_check = err.reset_time.to('utc').datetime
session.add(project)
session.commit()
raise
except exceptions.AnityaPluginException as err:
_log.exception("AnityaError catched:")
if not test:
project.logs = str(err)
session.add(project)
session.commit()
raise
# Remove prefix
versions = project.create_version_objects(versions_prefix)
if test:
return [str(v) for v in versions]
# There is always at least one version retrieved,
# otherwise this backend raises exception
project.logs = 'Version retrieved correctly'
p_versions = project.get_sorted_version_objects()
old_version = project.latest_version or ''
version_column_len = models.ProjectVersion.version.property.columns[
0].type.length
for version in versions:
if version not in p_versions:
if len(version.version) < version_column_len:
project.versions_obj.append(
models.ProjectVersion(project_id=project.id,
version=version.version))
else:
_log.info("Version '{}' was skipped. Reason: too long.".format(
version.version))
sorted_versions = project.get_sorted_version_objects()
if sorted_versions:
max_version = sorted_versions[0].parse()
if project.latest_version != max_version:
project.latest_version = max_version
publish = True
else:
project.logs = 'No new version found'
if publish:
log(
session,
project=project,
topic="project.version.update",
message=dict(project=project.__json__(),
upstream_version=max_version,
old_version=old_version,
packages=[pkg.__json__() for pkg in project.packages],
versions=project.versions,
ecosystem=project.ecosystem_name,
agent='anitya',
odd_change=False),
)
session.add(project)
session.commit()
def check_project_release(project, session, test=False):
''' Check if the provided project has a new release available or not.
:arg package: a Package object has defined in anitya.db.modelss.Project
'''
backend = plugins.get_plugin(project.backend)
if not backend:
raise exceptions.AnityaException('No backend was found for "%s"' %
project.backend)
publish = False
up_version = None
max_version = None
try:
up_version = backend.get_version(project)
except exceptions.AnityaPluginException as err:
_log.exception("AnityaError catched:")
project.logs = str(err)
session.add(project)
session.commit()
raise
if test:
return up_version
p_version = project.latest_version or ''
if up_version:
project.logs = 'Version retrieved correctly'
if up_version and up_version not in project.versions:
publish = True
project.versions_obj.append(
models.ProjectVersion(project_id=project.id, version=up_version))
odd_change = False
if up_version and up_version != p_version:
version_class = project.get_version_class()
max_version = max(up_version, p_version, key=version_class)
if project.latest_version and max_version != up_version:
odd_change = True
project.logs = 'Something strange occured, we found that this '\
'project has released a version "%s" while we had the latest '\
'version at "%s"' % (up_version, project.latest_version)
else:
project.latest_version = up_version
if publish:
log(
session,
project=project,
topic="project.version.update",
message=dict(
project=project.__json__(),
upstream_version=up_version,
old_version=p_version,
packages=[pkg.__json__() for pkg in project.packages],
versions=project.versions,
agent='anitya',
odd_change=odd_change,
),
)
session.add(project)
session.commit()
def check_project_release(project, session, test=False):
''' Check if the provided project has a new release available or not.
:arg package: a Package object has defined in anitya.db.modelss.Project
'''
backend = plugins.get_plugin(project.backend)
if not backend:
raise exceptions.AnityaException('No backend was found for "%s"' %
project.backend)
publish = False
versions = []
max_version = None
old_version = None
try:
versions = backend.get_versions(project)
except exceptions.AnityaPluginException as err:
_log.exception("AnityaError catched:")
project.logs = str(err)
session.add(project)
session.commit()
raise
if test:
return versions
# There is always at least one version retrieved,
# otherwise this backend raises exception
project.logs = 'Version retrieved correctly'
p_versions = project.get_sorted_version_objects()
if p_versions:
old_version = p_versions[0].version
for version in versions:
if version not in project.versions:
project.versions_obj.append(
models.ProjectVersion(project_id=project.id, version=version))
sorted_versions = project.get_sorted_version_objects()
max_version = sorted_versions[0].version
if project.latest_version != max_version:
project.latest_version = max_version
publish = True
else:
project.logs = 'No new version found'
if publish:
log(
session,
project=project,
topic="project.version.update",
message=dict(
project=project.__json__(),
upstream_version=max_version,
old_version=old_version,
packages=[pkg.__json__() for pkg in project.packages],
versions=project.versions,
agent='anitya',
),
)
session.add(project)
session.commit()
def check_project_release(project, session, test=False):
""" Check if the provided project has a new release available or not.
:arg package: a Package object has defined in anitya.db.modelss.Project
"""
backend = plugins.get_plugin(project.backend)
if not backend:
raise exceptions.AnityaException(
'No backend was found for "%s"' % project.backend
)
publish = False
versions_prefix = []
max_version = ""
# don't change actual data during test run
if not test:
project.last_check = arrow.utcnow().datetime
project.next_check = project.last_check + backend.check_interval
try:
versions_prefix = backend.get_versions(project)
except exceptions.RateLimitException as err:
_log.error(f"{project.name} ({project.backend}): {str(err)}")
if not test:
project.logs = str(err)
project.next_check = err.reset_time.to("utc").datetime
project.check_successful = False
session.add(project)
session.commit()
raise
except exceptions.AnityaPluginException as err:
_log.error(f"{project.name} ({project.backend}): {str(err)}")
if not test:
project.logs = str(err)
project.check_successful = False
project.error_counter += 1
session.add(project)
session.commit()
raise
# Remove prefix
versions = project.create_version_objects(versions_prefix)
if test:
return [str(v) for v in versions]
# There is always at least one version retrieved,
# otherwise this backend raises exception
project.logs = "Version retrieved correctly"
project.check_successful = True
project.error_counter = 0
p_versions = project.get_sorted_version_objects()
old_version = project.latest_version or ""
version_column_len = models.ProjectVersion.version.property.columns[0].type.length
for version in versions:
if version not in p_versions:
if len(version.version) < version_column_len:
project.versions_obj.append(
models.ProjectVersion(
project_id=project.id,
version=version.version,
commit_url=version.commit_url,
)
)
else:
_log.info(
"Version '{}' was skipped. Reason: too long.".format(
version.version
)
)
sorted_versions = project.get_sorted_version_objects()
if sorted_versions:
max_version_obj = sorted_versions[0]
max_version = max_version_obj.parse()
if project.latest_version != max_version:
project.latest_version = max_version
if versions: # pragma: no branch
# project.create_version_objects() returns sorted versions, i.e.
# version[-1] will be the latest one
project.latest_version_cursor = versions[-1].cursor
publish = True
else:
project.logs = "No new version found"
if publish:
log(
session,
project=project.__json__(),
topic="project.version.update",
message=dict(
project=project.__json__(),
upstream_version=max_version,
old_version=old_version,
packages=[pkg.__json__() for pkg in project.packages],
versions=project.versions,
ecosystem=project.ecosystem_name,
agent="anitya",
odd_change=False,
),
)
session.add(project)
session.commit()
