def __init__(self, sca_subscription): # The sca_subscription is a PistonResponseObject, whereas any child # objects are normal Python dicts. self.sca_subscription = sca_subscription self.MAPPING.update(self.SUBSCRIPTION_MAPPING) super(SCAPurchasedApplicationParser, self).__init__( PistonResponseObject.from_dict(sca_subscription.application))
def test_desktop_categories_no_department(self): piston_app = PistonResponseObject.from_dict( json.loads(AVAILABLE_APPS_JSON)[0]) del (piston_app.department) parser = self._make_application_parser(piston_app) self.assertEqual(["AudioVideo"], parser.get_desktop_categories())
def test_desktop_categories_no_department(self): piston_app = PistonResponseObject.from_dict( json.loads(AVAILABLE_APPS_JSON)[0]) del(piston_app.department) parser = self._make_application_parser(piston_app) self.assertEqual(["AudioVideo"], parser.get_desktop_categories())
def test_region_blacklist_blacklists(self, get_region_cached_mock): """Test that the region blacklist adds non-blacklisted locations""" get_region_cached_mock.return_value = {"countrycode": "de"} app_dict = make_software_center_agent_app_dict({"debtags": ["%s%s" % (REGION_BLACKLIST_TAG, "ES")]}) item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertNotEqual(doc, None)
def test_no_region_tags_passes(self, get_region_cached_mock): """Do not skip apps with no white or blacklist tags.""" get_region_cached_mock.return_value = {"countrycode": "es"} app_dict = make_software_center_agent_app_dict({"debtags": []}) item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertNotEqual(doc, None)
def test_license_key_present(self): piston_subscription = PistonResponseObject.from_dict( json.loads(SUBSCRIPTIONS_FOR_ME_JSON)[0]) piston_subscription.license_key = 'abcd' piston_subscription.license_key_path = '/foo' parser = self._make_application_parser(piston_subscription) self.assertEqual('abcd', parser.get_value(AppInfoFields.LICENSE_KEY)) self.assertEqual( '/foo', parser.get_value(AppInfoFields.LICENSE_KEY_PATH))
def test_no_region_tags_passes(self, get_region_cached_mock): """Do not skip apps with no white or blacklist tags.""" get_region_cached_mock.return_value = { "countrycode": "es", } app_dict = make_software_center_agent_app_dict({"debtags": []}) item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertNotEqual(doc, None)
def test_license_key_present(self): piston_subscription = PistonResponseObject.from_dict( json.loads(SUBSCRIPTIONS_FOR_ME_JSON)[0]) piston_subscription.license_key = 'abcd' piston_subscription.license_key_path = '/foo' parser = self._make_application_parser(piston_subscription) self.assertTrue(parser.has_option_desktop('License-Key')) self.assertTrue(parser.has_option_desktop('License-Key-Path')) self.assertEqual('abcd', parser.get_desktop('License-Key')) self.assertEqual('/foo', parser.get_desktop('License-Key-Path'))
def test_region_blacklist(self, get_region_cached_mock): from softwarecenter.region import REGION_BLACKLIST_TAG get_region_cached_mock.return_value = {"countrycode": "es"} app_dict = make_software_center_agent_app_dict() app_dict["debtags"] = ["%s%s" % (REGION_BLACKLIST_TAG, "es")] # see _get_app_details_from_app_dict item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = make_doc_from_parser(parser, self.db._aptcache) self.assertEqual(doc, None)
def test_region_blacklist_blacklists(self, get_region_cached_mock): """Test that the region blacklist adds non-blacklisted locations""" get_region_cached_mock.return_value = { "countrycode": "de", } app_dict = make_software_center_agent_app_dict( {"debtags": ["%s%s" % (REGION_BLACKLIST_TAG, "ES")]}) item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertNotEqual(doc, None)
def test_region_blacklist(self, get_region_cached_mock): from softwarecenter.region import REGION_BLACKLIST_TAG get_region_cached_mock.return_value = { "countrycode": "es", } app_dict = make_software_center_agent_app_dict() app_dict["debtags"] = [ "%s%s" % (REGION_BLACKLIST_TAG, "es"), ] # see _get_app_details_from_app_dict item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = make_doc_from_parser(parser, self.db._aptcache) self.assertEqual(doc, None)
def test_region_whitelist_blacklists(self, get_region_cached_mock): """Test that the whitelist ignores non-whitelist locations""" from softwarecenter.region import REGION_WHITELIST_TAG get_region_cached_mock.return_value = { "countrycode": "de", } app_dict = make_software_center_agent_app_dict() app_dict["debtags"] = [ "%s%s" % (REGION_WHITELIST_TAG, "ES"), ] # see _get_app_details_from_app_dict item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = make_doc_from_parser(parser, self.db._aptcache) self.assertEqual(doc, None)
def test_region_whitelist_blacklists(self, get_region_cached_mock): """Test that the whitelist ignores non-whitelist locations""" get_region_cached_mock.return_value = {"countrycode": "de"} app_dict = make_software_center_agent_app_dict( { "debtags": [ "%s%s" % (REGION_WHITELIST_TAG, "ES"), "%s%s" % (REGION_BLACKLIST_TAG, "CA"), "%s%s" % (REGION_WHITELIST_TAG, "US"), ] } ) # see _get_app_details_from_app_dict item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertEqual(doc, None)
def test_region_whiteandblack_blacklists(self, get_region_cached_mock): """Ignore regions that are in both black and whitelists.""" get_region_cached_mock.return_value = { "countrycode": "de", } app_dict = make_software_center_agent_app_dict({ "debtags": [ "%s%s" % (REGION_WHITELIST_TAG, "DE"), "%s%s" % (REGION_BLACKLIST_TAG, "DE"), "%s%s" % (REGION_BLACKLIST_TAG, "US"), "%s%s" % (REGION_WHITELIST_TAG, "ES") ] }) # see _get_app_details_from_app_dict item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) self.assertEqual(doc, None)
def make_purchased_app_details(db=None, supported_series=None): """Return an AppDetail instance with the required attributes.""" app = make_software_center_agent_app_dict() subscription = make_software_center_agent_subscription_dict(app) if supported_series != None: subscription["application"]["series"] = supported_series else: # If no supportod_series kwarg was provided, we ensure the # current series/arch is supported. distro = get_distro() subscription["application"]["series"] = {distro.get_codename(): [distro.get_architecture()]} item = PistonResponseObject.from_dict(subscription) parser = SCAPurchasedApplicationParser(item) if db is None: db = get_test_db() doc = make_doc_from_parser(parser, db._aptcache) app_details = AppDetails(db, doc) return app_details
def make_purchased_app_details(db=None, supported_series=None): """Return an AppDetail instance with the required attributes.""" app = make_software_center_agent_app_dict() subscription = make_software_center_agent_subscription_dict(app) if supported_series != None: subscription['application']['series'] = supported_series else: # If no supportod_series kwarg was provided, we ensure the # current series/arch is supported. distro = softwarecenter.distro.get_distro() subscription['application']['series'] = { distro.get_codename(): [distro.get_architecture()] } item = PistonResponseObject.from_dict(subscription) parser = SCAPurchasedApplicationParser(item) if db is None: db = get_test_db() doc = parser.make_doc(db._aptcache) app_details = AppDetails(db, doc) return app_details
def _make_available_for_me_list(self): my_subscriptions = json.loads(SUBSCRIPTIONS_FOR_ME_JSON) return list( PistonResponseObject.from_dict(subs) for subs in my_subscriptions)
def _make_application_parser(self, piston_subscription=None): if piston_subscription is None: piston_subscription = PistonResponseObject.from_dict( json.loads(SUBSCRIPTIONS_FOR_ME_JSON)[0]) return SCAPurchasedApplicationParser(piston_subscription)
def _make_application_parser(self, piston_application=None): if piston_application is None: piston_application = PistonResponseObject.from_dict( json.loads(AVAILABLE_APPS_JSON)[0]) return SCAApplicationParser(piston_application)
def _make_available_list(self): available_apps = json.loads(AVAILABLE_APPS_JSON) return list( PistonResponseObject.from_dict(subs) for subs in available_apps)
def _get_app_details_from_app_dict(self, app_dict): item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = parser.make_doc(self.db._aptcache) app_details = AppDetails(self.db, doc) return app_details
def _get_app_details_from_app_dict(self, app_dict): item = PistonResponseObject.from_dict(app_dict) parser = SCAApplicationParser(item) doc = make_doc_from_parser(parser, self.db._aptcache) app_details = AppDetails(self.db, doc) return app_details