def test_install_units(self):
     repo_id = "test_repo_id"
     errata_obj = self.get_test_errata_object()
     errata_unit = Unit(TYPE_ID_ERRATA, {"id":errata_obj["id"]}, errata_obj, None)
     existing_units = [errata_unit]
     test_repo = profiler_mocks.get_repo(repo_id)
     conduit = profiler_mocks.get_profiler_conduit(existing_units=existing_units,
                                                   repo_bindings=[test_repo])
     example_errata = {"unit_key":errata_unit.unit_key, "type_id":TYPE_ID_ERRATA}
     prof = YumProfiler()
     translated_units  = prof.install_units(self.test_consumer, [example_errata], None, None,
                                            conduit)
     # check repo_id passed to the conduit get_units()
     self.assertEqual(conduit.get_units.call_args[0][0].id, repo_id)
     # check unit association criteria passed to the conduit get_units()
     self.assertEqual(conduit.get_units.call_args[0][1].type_ids, [TYPE_ID_ERRATA])
     self.assertEqual(conduit.get_units.call_args[0][1].unit_filters, errata_unit.unit_key)
     # validate translated units
     self.assertEqual(len(translated_units), 2)
     expected = []
     for r in prof._get_rpms_from_errata(errata_unit):
         expected_name = "%s-%s:%s-%s.%s" % (r["name"], r["epoch"], r["version"], r["release"],
                                             r["arch"])
         expected.append(expected_name)
     for u in translated_units:
         rpm_name = u["unit_key"]["name"]
         self.assertTrue(rpm_name in expected)

    def test_update_profile_presorted_profile(self):
        """
        Test the update_profile() method with a presorted profile. It should not alter it at all.
        """
        profile = [
            {'name': 'Package A', 'epoch': 0, 'version': '1.0.1', 'release': '2.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
            {'name': 'Package A', 'epoch': 0, 'version': '1.1.0', 'release': '1.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
            {'name': 'Package B', 'epoch': 0, 'version': '2.3.9', 'release': '1.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
            {'name': 'Package B', 'epoch': 1, 'version': '1.2.1', 'release': '8.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
            {'name': 'Package C', 'epoch': 0, 'version': '1.0.0', 'release': '1.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
            {'name': 'Package C', 'epoch': 0, 'version': '1.0.0', 'release': '2.el6',
             'arch': 'x86_64', 'vendor': 'Red Hat, Inc.'},
        ]
        profiler = YumProfiler()

        # The update_profile() method doesn't use any of the args except for profile and
        # content_type, so we'll just pass in strings for the others
        new_profile = profiler.update_profile('consumer', TYPE_ID_RPM, deepcopy(profile), 'config')

        self.assertEqual(new_profile, profile)

    def test_install_units_with_rpms(self):
        """
        Make sure install_units() can handle being given RPMs.
        """
        rpms = [{"name": "rpm_1", "type_id": TYPE_ID_RPM}, {"name": "rpm_2", "type_id": TYPE_ID_RPM}]
        profiler = YumProfiler()

        translated_units = profiler.install_units("consumer", deepcopy(rpms), None, None, "conduit")

        # The RPMs should be unaltered
        self.assertEqual(translated_units, rpms)

    def test_unit_applicable_false(self):
        rpm_unit_key = self.create_profile_entry("bla-bla", 0, "0.1", "2", "x86_64", "Test Vendor")
        rpm_unit = Unit(TYPE_ID_RPM, rpm_unit_key, {}, None)
        test_repo = profiler_mocks.get_repo("test_repo_id")
        conduit = profiler_mocks.get_profiler_conduit(repo_units=[rpm_unit], repo_bindings=[test_repo])

        prof = YumProfiler()
        unit_profile = self.test_consumer.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})

    def test_rpm_applicable_to_consumer(self):
        rpm = {}
        prof = YumProfiler()
        applicable = prof._is_rpm_applicable(rpm, {})
        self.assertEqual(applicable, False)

        # Test with newer RPM
        # The consumer has already been configured with a profile containing 'emoticons'
        rpm = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor")
        applicable = prof._is_rpm_applicable(rpm, self.test_consumer_lookup)
        self.assertTrue(applicable)

    def test_update_profile_with_errata(self):
        """
        Test the update_profile() method with a presorted profile. It should not alter it at all.
        """
        profile = ["one_errata", "two_errata", "three_errata", "four_errata"]
        profiler = YumProfiler()

        # The update_profile() method doesn't use any of the args except for profile and
        # content_type, so we'll just pass in strings for the others
        # This test just asserts that the profile is returned unaltered
        new_profile = profiler.update_profile("consumer", TYPE_ID_ERRATA, deepcopy(profile), "config")

        self.assertEqual(new_profile, profile)

    def test_unit_applicable_true(self):
        rpm_unit_key = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor")
        rpm_unit = Unit(TYPE_ID_RPM, rpm_unit_key, {}, None)
        # Let's give it an id, so we can assert for it later
        rpm_unit.id = "a_test_id"
        test_repo = profiler_mocks.get_repo("test_repo_id")
        conduit = profiler_mocks.get_profiler_conduit(repo_units=[rpm_unit], repo_bindings=[test_repo])

        prof = YumProfiler()
        unit_profile = self.test_consumer.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_RPM: [rpm_unit.id], TYPE_ID_ERRATA: []})

    def test_install_units_with_rpms(self):
        """
        Make sure install_units() can handle being given RPMs.
        """
        rpms = [{'name': 'rpm_1', 'type_id': TYPE_ID_RPM},
                {'name': 'rpm_2', 'type_id': TYPE_ID_RPM}]
        profiler = YumProfiler()

        translated_units = profiler.install_units('consumer', deepcopy(rpms), None, None,
                                                  'conduit')

        # The RPMs should be unaltered
        self.assertEqual(translated_units, rpms)

    def test_unit_applicable_updated_rpm_already_installed(self):
        # Errata refers to RPMs already installed, i.e. the consumer has these exact NEVRA already
        errata_obj = self.get_test_errata_object()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        test_repo = profiler_mocks.get_repo("test_repo_id")

        prof = YumProfiler()
        errata_rpms = prof._get_rpms_from_errata(errata_unit)
        conduit = profiler_mocks.get_profiler_conduit(repo_units=[errata_unit],
                                                      repo_bindings=[test_repo],
                                                      errata_rpms=errata_rpms)
        unit_profile = self.test_consumer_been_updated.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})

    def test_unit_applicable_false(self):
        # Errata refers to RPMs which are NOT part of our test consumer's profile
        errata_obj = self.get_test_errata_object_unrelated()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        test_repo = profiler_mocks.get_repo("test_repo_id")

        prof = YumProfiler()
        errata_rpms = prof._get_rpms_from_errata(errata_unit)
        conduit = profiler_mocks.get_profiler_conduit(repo_units=[errata_unit],
                                                      repo_bindings=[test_repo],
                                                      errata_rpms=errata_rpms)
        unit_profile = self.test_consumer.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_ERRATA: [], TYPE_ID_RPM: []})

 def test_rpm_applicable_with_profile_containing_duplicate_packages(self):
     """
     If a consumer profile contains multiple rpms with same name and arch (eg. in case of
     kernel rpms), make sure that the applicability calculations take into consideration
     the newest rpm installed.
     """
     consumer_profile = self.get_test_profile_with_duplicate_packages()
     test_consumer_lookup = YumProfiler._form_lookup_table(consumer_profile[TYPE_ID_RPM])
     rpm = self.create_profile_entry("patb", 0, "0.0.2", "1", "x86_64", "Test Vendor")
     yum_profiler = YumProfiler()
     applicable = yum_profiler._is_rpm_applicable(rpm, test_consumer_lookup)
     self.assertFalse(applicable)
     newer_rpm = self.create_profile_entry("patb", 0, "0.0.3", "1", "x86_64", "Test Vendor")
     applicable = yum_profiler._is_rpm_applicable(newer_rpm, test_consumer_lookup)
     self.assertTrue(applicable)

    def test_unit_applicable_same_name_diff_arch(self):
        # Errata refers to RPMs that are x86_64, the test consumer is i386
        # the rpms installed share the same name as the errata, but the client arch is different
        # so this errata is marked as unapplicable
        errata_obj = self.get_test_errata_object()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        test_repo = profiler_mocks.get_repo("test_repo_id")

        prof = YumProfiler()
        errata_rpms = prof._get_rpms_from_errata(errata_unit)
        conduit = profiler_mocks.get_profiler_conduit(repo_units=[errata_unit],
                                                      repo_bindings=[test_repo],
                                                      errata_rpms=errata_rpms)
        unit_profile = self.test_consumer_i386.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_RPM: [], TYPE_ID_ERRATA: []})

    def test_install_units(self):
        """
        Verify that all available packages in the erratum are installed

        In this test, there are two packages in the erratum, and both are
        available to the consumer. Thus, both should be installed.
        """
        repo_id = "test_repo_id"
        errata_obj = self.get_test_errata_object()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        existing_units = [errata_unit]
        test_repo = profiler_mocks.get_repo(repo_id)

        # create two RPM units that match what is in the erratum
        rpm_units = []
        rpm_unit_key_1 = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64",
                                                   "Test Vendor")
        rpm_units.append(Unit(TYPE_ID_RPM, rpm_unit_key_1, {}, None))

        rpm_unit_key_2 = self.create_profile_entry("patb", 0, "0.1", "2", "x86_64", "Test Vendor")
        rpm_units.append(Unit(TYPE_ID_RPM, rpm_unit_key_2, {}, None))

        existing_units += rpm_units

        conduit = profiler_mocks.get_profiler_conduit(existing_units=existing_units,
                                                      repo_bindings=[test_repo],
                                                      repo_units=rpm_units)

        example_errata = {"unit_key": errata_unit.unit_key, "type_id": TYPE_ID_ERRATA}
        prof = YumProfiler()
        translated_units = prof.install_units(self.test_consumer, [example_errata], None, None,
                                              conduit)
        # check repo_id passed to the conduit get_units()
        self.assertEqual(conduit.get_units.call_args[0][0].id, repo_id)
        # check unit association criteria passed to the conduit get_units()
        self.assertEqual(conduit.get_units.call_args_list[0][0][1].type_ids, [TYPE_ID_ERRATA])
        self.assertEqual(conduit.get_units.call_args_list[0][0][1].unit_filters,
                         errata_unit.unit_key)
        # validate translated units
        self.assertEqual(len(translated_units), 2)
        expected = prof._get_rpms_from_errata(errata_unit)
        for u in translated_units:
            rpm_unit_key = u["unit_key"]
            self.assertTrue(rpm_unit_key in expected)

 def test_form_lookup_table(self):
     """
     Test that form_lookup_table creates a table with the latest rpm in the profile as a value
     corresponding to the rpm name and arch.
     """
     test_profile = self.get_test_profile_with_duplicate_packages()
     consumer_lookup = YumProfiler._form_lookup_table(test_profile[TYPE_ID_RPM])
     self.assertEqual(len(consumer_lookup), 2)
     self.assertEqual(consumer_lookup['patb x86_64'],
                      self.create_profile_entry("patb", 0, "0.0.2", "1", "x86_64", "Test Vendor"))

    def test_create_nevra(self):
        rpm = {'name': "foo",
               'epoch': 0,
               'version': '1',
               'release': '5',
               'arch': '8088',
               'extra_field': 'extra'}

        result = YumProfiler._create_nevra(rpm)
        self.assertEquals(result, {'name': 'foo', 'epoch': '0', 'version': '1',
                                   'release': '5', 'arch': '8088'})

 def test_get_rpms_from_errata(self):
     errata_obj = self.get_test_errata_object()
     errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
     prof = YumProfiler()
     rpms = prof._get_rpms_from_errata(errata_unit)
     # Expected data:
     # [{'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'emoticons',
     # 'sum': ('md5', '366bb5e73a5905eacb82c96e0578f92b'),
     #   'filename': 'emoticons-0.1-2.x86_64.rpm', 'epoch': '0',
     #   'version': '0.1', 'release': '2', 'arch': 'x86_64'},
     # {'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'patb',
     #   'sum': ('md5', 'f3c197a29d9b66c5b65c5d62b25db5b4'),
     #   'filename': 'patb-0.1-2.x86_64.rpm', 'epoch': '0'
     #   'version': '0.1', 'release': '2', 'arch': 'x86_64'}]
     self.assertEqual(len(rpms), 2)
     self.assertTrue(rpms[0]["name"] in ['emoticons', 'patb'])
     self.assertTrue(rpms[1]["name"] in ['emoticons', 'patb'])
     for r in rpms:
         for key in ["name", "filename", "epoch", "version", "release"]:
             self.assertTrue(key in r)
             self.assertTrue(r[key])

    def test_rpms_applicable_to_consumer(self):
        errata_rpms = []
        prof = YumProfiler()
        applicable_rpms, old_rpms = prof._rpms_applicable_to_consumer(Consumer("test", {}), errata_rpms)
        self.assertEqual(applicable_rpms, [])
        self.assertEqual(old_rpms, {})

        # Get rpm dictionaries embedded in an errata
        errata_obj = self.get_test_errata_object()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        errata_rpms = prof._get_rpms_from_errata(errata_unit)
        # Test with 2 newer RPMs in the test errata
        # The consumer has already been configured with a profile containing 'emoticons' and
        # 'patb' rpms
        applicable_rpms, old_rpms = prof._rpms_applicable_to_consumer(self.test_consumer, errata_rpms)
        self.assertTrue(applicable_rpms)
        self.assertTrue(old_rpms)
        self.assertEqual(len(applicable_rpms), 2)
        self.assertTrue("emoticons x86_64" in old_rpms)
        self.assertEqual("emoticons", old_rpms["emoticons x86_64"]["installed"]["name"])
        self.assertEqual("0.1", old_rpms["emoticons x86_64"]["installed"]["version"])

 def test_metadata(self):
     """
     Test the metadata() method.
     """
     data = YumProfiler.metadata()
     self.assertTrue("id" in data)
     self.assertEquals(data['id'], YumProfiler.TYPE_ID)
     self.assertTrue("display_name" in data)
     # Make sure the advertised types are RPM and Errata
     self.assertTrue('types' in data)
     self.assertEqual(len(data['types']), 2)
     self.assertTrue(TYPE_ID_RPM in data["types"])
     self.assertTrue(TYPE_ID_ERRATA in data["types"])

    def test_unit_applicable(self):
        # Errata refers to RPMs which ARE part of our test consumer's profile,
        # AND in the repo.
        errata_obj = self.get_test_errata_object()
        errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
        errata_unit.id = "an_errata"

        rpm_unit_key = self.create_profile_entry("emoticons", 0, "0.1", "2", "x86_64", "Test Vendor")
        rpm_unit = Unit(TYPE_ID_RPM, rpm_unit_key, {}, None)
        # Let's give it an id, so we can assert for it later
        rpm_unit.id = "a_test_id"

        test_repo = profiler_mocks.get_repo("test_repo_id")

        prof = YumProfiler()
        errata_rpms = prof._get_rpms_from_errata(errata_unit)
        conduit = profiler_mocks.get_profiler_conduit(
            repo_units=[errata_unit, rpm_unit], repo_bindings=[test_repo], errata_rpms=errata_rpms
        )
        unit_profile = self.test_consumer.profiles[TYPE_ID_RPM]
        bound_repo_id = "test_repo_id"
        report_list = prof.calculate_applicable_units(unit_profile, bound_repo_id, None, conduit)
        self.assertEqual(report_list, {TYPE_ID_RPM: ["a_test_id"], TYPE_ID_ERRATA: ["an_errata"]})

 def test_get_rpms_from_errata_no_epoch(self):
     """
     Test that we default to '0' for the epoch if one doesn't exist.
     """
     errata_obj = self.get_test_errata_object(eid='RHEA-2010:8888')
     errata_unit = Unit(TYPE_ID_ERRATA, {"id": errata_obj["id"]}, errata_obj, None)
     prof = YumProfiler()
     rpms = prof._get_rpms_from_errata(errata_unit)
     # Expected data:
     # [{'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'emoticons',
     #   'sum': ('md5', '366bb5e73a5905eacb82c96e0578f92b'),
     #   'filename': 'emoticons-0.1-2.x86_64.rpm', 'epoch': '0',
     #   'version': '0.1', 'release': '2', 'arch': 'x86_64'},
     # {'src': 'xen-3.0.3-80.el5_3.3.src.rpm', 'name': 'patb',
     #   'sum': ('md5', 'f3c197a29d9b66c5b65c5d62b25db5b4'),
     #   'filename': 'patb-0.1-2.x86_64.rpm', 'epoch': '0',
     #   'version': '0.1', 'release': '2', 'arch': 'x86_64'}]
     self.assertEqual(len(rpms), 2)
     self.assertTrue(rpms[0]["name"] in ['emoticons', 'patb'])
     self.assertTrue(rpms[1]["name"] in ['emoticons', 'patb'])
     for r in rpms:
         self.assertTrue('epoch' in r)
         self.assertTrue(r['epoch'] == '0')