def load_cache_to_apis(): """Reload cache in APIs.""" BaseHandler.updates_api = UpdatesAPI(BaseHandler.db_cache) BaseHandler.repo_api = RepoAPI(BaseHandler.db_cache) BaseHandler.cve_api = CveAPI(BaseHandler.db_cache) BaseHandler.errata_api = ErrataAPI(BaseHandler.db_cache) BaseHandler.packages_api = PackagesAPI(BaseHandler.db_cache) BaseHandler.pkglist_api = PkgListAPI(BaseHandler.db_cache) BaseHandler.pkgtree_api = PkgtreeAPI(BaseHandler.db_cache) BaseHandler.vulnerabilities_api = VulnerabilitiesAPI( BaseHandler.db_cache, BaseHandler.updates_api) BaseHandler.patches_api = PatchesAPI(BaseHandler.db_cache, BaseHandler.updates_api) BaseHandler.dbchange_api = DBChange(BaseHandler.db_cache) BaseHandler.srpm_pkg_names_api = SRPMPkgNamesAPI(BaseHandler.db_cache) BaseHandler.rpm_pkg_names_api = RPMPkgNamesAPI(BaseHandler.db_cache)
def setup_api(self, load_cache): """Setup UpdatesAPI object.""" self.updates_api = UpdatesAPI(self.cache)
class TestUpdatesAPI(TestBase): """Test updates api class.""" updates_api = None @pytest.fixture(autouse=True) def setup_api(self, load_cache): """Setup UpdatesAPI object.""" self.updates_api = UpdatesAPI(self.cache) def test_process_input_pkg(self): """Test filtering out unknown (or without updates) package names.""" pkgs, update_list = self.updates_api.process_input_packages(UPDATES_JSON) assert pkgs == {'my-pkg-1.1.0-1.el8.i686': {'parsed_nevra': ('my-pkg', '0', '1.1.0', '1.el8', 'i686')}} assert update_list == {'my-pkg-1.1.0-1.el8.i686': {}} def test_process_input_non_exist(self): """Test filtering out unknown non existing package.""" pkgs, update_list = self.updates_api.process_input_packages(UPDATES_JSON_NON_EXIST) assert pkgs == {} assert update_list == {'non-exist': {}} def test_schema_v1(self): """Test schema of updates api v1.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(1, UPDATES_JSON_3_OPT.copy()) assert schemas.updates_top_all_schema.validate(updates) assert schemas.updates_package_schema.validate(updates["update_list"][PKG]) def test_schema_v2(self): """Test schema of updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_3_OPT.copy()) assert schemas.updates_top_all_schema.validate(updates) assert schemas.updates_package_schema_v2.validate(updates["update_list"][PKG]) def test_schema_repolist(self): """Test repolist schema of updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_REPO.copy()) assert schemas.updates_top_repolist_schema.validate(updates) def test_schema_releasever(self): """Test releasever schema of updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_RELEASE.copy()) assert schemas.updates_top_releasever_schema.validate(updates) def test_schema_basearch(self): """Test basearch schema of updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_ARCH.copy()) assert schemas.updates_top_basearch_schema.validate(updates) def test_process_list_v1(self): """Test looking for package updates api v1.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(1, UPDATES_JSON_3_OPT.copy()) assert updates == UPDATES_RESPONSE_1 def test_process_list_v2(self): """Test looking for package updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_3_OPT.copy()) assert updates == UPDATES_RESPONSE_2 def test_process_list_v3(self): """Test looking for package updates api v3.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(3, UPDATES_JSON_3_OPT.copy()) assert updates == UPDATES_RESPONSE_2 def test_process_list_prefix_v3(self): """Test looking for package updates api v3 with prefixed repo names.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(3, UPDATES_JSON_PREFIX.copy()) assert updates == UPDATES_RESPONSE_2 def test_process_none_arch(self): """Test pkg with arch (none).""" # NOTE: use copy of dict with json input, because process_list changes this dict updates_json_none = UPDATES_JSON_3_OPT.copy() updates_json_none['package_list'] = [PKG, PKG_NONE_ARCH] updates = self.updates_api.process_list(3, updates_json_none) assert len(updates['update_list']) == 2 assert len(updates['update_list'][PKG]['available_updates']) == 1 assert len(updates['update_list'][PKG_NONE_ARCH]['available_updates']) == 0 def test_process_list_v2_unknown(self): """Test looking for unknown EVRA updates, disabled optimistic_updates.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_UNKNOWN.copy()) assert updates == UPDATES_RESPONSE_2_UNKNOWN_NONE def test_optimistic_updates_1(self): """Test looking for unknown EVRA updates (module_stream: 1).""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_UNKNOWN_OPT_UPD.copy()) assert updates == UPDATES_RESPONSE_2_UNKNOWN def test_optimistic_updates_2(self): """Test looking for unknown EVRA updates (module_stream: 2).""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_UNKNOWN_OPT_UPD_2.copy()) assert updates == UPDATES_RESPONSE_2_UNKNOWN_2 def test_process_empty_pkg_list_v1(self): """Test empty package_list updates api v1.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(1, UPDATES_JSON_EMPTY_LIST.copy()) assert updates == EMPTY_RESPONSE def test_process_empty_pkg_list_v2(self): """Test empty package_list updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_EMPTY_LIST.copy()) assert updates == EMPTY_RESPONSE def test_process_non_exist_v1(self): """Test non-existing package updates api v1.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(1, UPDATES_JSON_NON_EXIST.copy()) assert updates == NON_EXIST_RESPONSE def test_process_non_exist_v2(self): """Test non-existing package updates api v2.""" # NOTE: use copy of dict with json input, because process_list changes this dict updates = self.updates_api.process_list(2, UPDATES_JSON_NON_EXIST.copy()) assert updates == NON_EXIST_RESPONSE
class TestInternalUpdatesAPI(TestBase): """Test internal methods of updates api class.""" updates_api = None @pytest.fixture(autouse=True) def setup_api(self, load_cache): """Setup UpdatesAPI object.""" self.updates_api = UpdatesAPI(self.cache) def test_get_repository_list_1(self): """Test with complete request.""" repositories_list, repo_ids = self.updates_api._get_repository_list(UPDATES_JSON) assert repositories_list == ['rhel-7-server-rpms'] assert repo_ids == [1] def test_get_repository_list_3(self): """Test with 'repository_list' only request.""" repositories_list, repo_ids = self.updates_api._get_repository_list(UPDATES_JSON_REPO) assert repositories_list == ['rhel-6-server-rpms'] assert repo_ids == [] def test_get_repository_list_4(self): """Test with 'releasever' only request.""" repositories_list, repo_ids = self.updates_api._get_repository_list(UPDATES_JSON_RELEASE) assert repositories_list is None assert list(repo_ids) == [1, 2, 3, 4, 5, 6] def test_get_repository_list_5(self): """Test with 'basearch' only request.""" repositories_list, repo_ids = self.updates_api._get_repository_list(UPDATES_JSON_ARCH) assert repositories_list is None assert list(repo_ids) == [1, 2, 3, 4, 5, 6] def test_get_releasever_1(self): """Test with complete request""" repo_ids_in = [1] releasever, repo_ids = self.updates_api._get_releasever(UPDATES_JSON, repo_ids_in) assert releasever == '7Server' assert repo_ids == [1] def test_get_releasever_2(self): """Test with 'releasever' only request.""" repo_ids_in = [1, 2, 3, 4, 5] releasever, repo_ids = self.updates_api._get_releasever(UPDATES_JSON_RELEASE, repo_ids_in) assert releasever == '6Server' assert repo_ids == [] def test_get_releasever_3(self): """Test with 'basearch' only request.""" repo_ids_in = [1, 2, 3, 4, 5] releasever, repo_ids = self.updates_api._get_releasever(UPDATES_JSON_ARCH, repo_ids_in) assert releasever is None assert repo_ids == repo_ids_in def test_get_basearch_1(self): """Test with complete request.""" repo_ids_in = [1] basearch, repo_ids = self.updates_api._get_basearch(UPDATES_JSON, repo_ids_in) assert basearch == 'x86_64' assert repo_ids == {1} def test_get_basearch_2(self): """Test with 'repository_list' only request.""" repo_ids_in = [] basearch, repo_ids = self.updates_api._get_basearch(UPDATES_JSON_REPO, repo_ids_in) assert basearch is None assert repo_ids == set() def test_get_basearch_3(self): """Test with 'releasever' only request.""" repo_ids_in = [] basearch, repo_ids = self.updates_api._get_basearch(UPDATES_JSON_RELEASE, repo_ids_in) assert basearch is None assert repo_ids == set() def test_get_basearch_4(self): """Test with 'basearch' only request.""" repo_ids_in = [1, 2, 3, 4, 5] basearch, repo_ids = self.updates_api._get_basearch(UPDATES_JSON_ARCH, repo_ids_in) assert basearch == 'i386' assert repo_ids == set()
class TestModularity(TestBase): """Test /updates modularity""" updates_api = None @staticmethod def gen_pkg_json(nevra, modules=None): """Prepares a request to VMaaS""" retval = {'package_list': [nevra]} if modules is not None: retval['modules_list'] = modules return retval @pytest.fixture(autouse=True) def setup_api(self, load_cache): """Setup UpdatesAPI object.""" self.updates_api = UpdatesAPI(self.cache) @pytest.mark.parametrize('test_data', OLD_OLD, ids=[x[0] for x in OLD_OLD]) def test_old_pkg_old_module(self, test_data): """ Test with my-pkg-1.1.0-1.el8.i686 Test without modularity info provided, should find 3 updates: my-pkg-1.2.0-1.el8.i686 my-pkg-2.0.0-1.el8.i686 my-pkg-2.1.0-1.el8.i686 Test with modularity info provided, should find one update: my-pkg-1.2.0-1.el8.i686 """ pkg = PKG_NEVRAS[0] mode, modules, expected_update_pkgs = test_data # pylint:disable=unused-variable updates = self.updates_api.process_list( 2, self.gen_pkg_json(pkg, modules)) assert updates available_updates = updates['update_list'][pkg]['available_updates'] assert len(available_updates) == len(expected_update_pkgs) assert expected_update_pkgs == { rec['package'] for rec in available_updates } @pytest.mark.parametrize('test_data', NEW_OLD, ids=[x[0] for x in NEW_OLD]) def test_new_pkg_old_module(self, test_data): """Test with my-pkg-1.2.0-1.el8.i686 Test without modularity info enabled, should find two updates my-pkg-2.0.0-1.el8.i686 my-pkg-2.1.0-1.el8.i686 With correct modularity stream enabled there should be no upates Test with incorrect modularity information, should find two (incorrect) update: my-pkg-2.0.0-1.el8.i686 my-pkg-2.1.0-1.el8.i686 DNF on the client should never let this happen """ pkg = PKG_NEVRAS[1] mode, modules, expected_update_pkgs = test_data # pylint:disable=unused-variable updates = self.updates_api.process_list( 2, self.gen_pkg_json(pkg, modules)) assert updates available_updates = updates['update_list'][pkg]['available_updates'] if mode == 'correct_stream_enabled': # with correct stream enabled there should be no updates assert not available_updates return assert len(available_updates) == len(expected_update_pkgs) assert expected_update_pkgs == { rec['package'] for rec in available_updates } @pytest.mark.parametrize('test_data', NEW_MODULE, ids=[x[0] for x in NEW_MODULE]) def test_old_pkg_new_module(self, test_data): """ Test with my-pkg-2.0.0-1.el8.i686 Both tests with, or without modularity should find one update my-pkg-2.1.0-1.el8.i686 """ pkg = PKG_NEVRAS[2] mode, modules, expected_update_pkgs = test_data # pylint:disable=unused-variable updates = self.updates_api.process_list( 2, self.gen_pkg_json(pkg, modules)) assert updates available_updates = updates['update_list'][pkg]['available_updates'] assert len(available_updates) == len(expected_update_pkgs) assert expected_update_pkgs == { rec['package'] for rec in available_updates } @pytest.mark.parametrize('test_data', NEW_MODULE, ids=[x[0] for x in NEW_MODULE]) def test_new_pkg_new_module(self, test_data): """ Test with my-pkg-2.1.0-1.el8.i686 which is the latest package and has no updates There should be zero updates with or without modularity """ pkg = PKG_NEVRAS[3] mode, modules, expected_update_pkgs = test_data # pylint:disable=unused-variable updates = self.updates_api.process_list( 2, self.gen_pkg_json(pkg, modules)) assert updates assert not updates['update_list'][pkg]['available_updates'] @pytest.mark.parametrize('test_data', NO_MODULES, ids=[x[0] for x in NO_MODULES]) def test_no_enabled_modules(self, test_data): """ Tests with modularity functionaility enabled witout needed module (my-pkg 1) enabled Scenarios: no modules enabled at all, only rhn-tools module enabled, module not present in the database enabled All of these should result in no updates found """ pkg = PKG_NEVRAS[0] mode, modules = test_data # pylint:disable=unused-variable updates = self.updates_api.process_list( 2, self.gen_pkg_json(pkg, modules)) assert updates assert not updates['update_list'][pkg]['available_updates']
def setup_api(self, load_cache): """Setup UpdatesAPI object.""" self.vulnerabilities_api = VulnerabilitiesAPI(self.cache, UpdatesAPI(self.cache))