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()