def test_ent_cert_no_product(self): self.ent_dir = StubCertificateDirectory([ StubEntitlementCertificate(None, provided_products=[], quantity=2) ]) stub_facts = StubFacts(fact_dict={"cpu.cpu_socket(s)": 42}) self.sorter = CertSorter(self.prod_dir, self.ent_dir, stub_facts.get_facts()) self.assertEqual(0, len(self.sorter.partially_valid_products))
def test_sorter_adds_multiple_entitlements_to_group_when_same_stacking_id( self): expected_stacking_id = 5 ent1_prod = StubProduct("Product 1") ent1 = StubEntitlementCertificate(ent1_prod, stacking_id=expected_stacking_id) ent2_prod = StubProduct("Product 2") ent2 = StubEntitlementCertificate(ent2_prod, stacking_id=expected_stacking_id) entitlements = [ent1, ent2] sorter = EntitlementCertStackingGroupSorter(entitlements) self.assertEquals(1, len(sorter.groups)) self.assertEquals("Product 1", sorter.groups[0].name) self.assertEquals(2, len(sorter.groups[0].entitlements)) self.assertEquals(ent1, sorter.groups[0].entitlements[0]) self.assertEquals(ent2, sorter.groups[0].entitlements[1])
def test_sorter_adds_multiple_groups_for_non_stacking_entitlements(self): ent1_prod = StubProduct("Product 1") ent1 = StubEntitlementCertificate(ent1_prod, stacking_id=None) ent2_prod = StubProduct("Product 2") ent2 = StubEntitlementCertificate(ent2_prod, stacking_id=None) entitlements = [ent1, ent2] sorter = EntitlementCertStackingGroupSorter(entitlements) self.assertEquals(2, len(sorter.groups)) self.assertEquals('', sorter.groups[0].name) self.assertEquals(1, len(sorter.groups[0].entitlements)) self.assertEquals(ent1, sorter.groups[0].entitlements[0]) self.assertEquals('', sorter.groups[1].name) self.assertEquals(1, len(sorter.groups[1].entitlements)) self.assertEquals(ent2, sorter.groups[1].entitlements[0])
def test_get_entry_image_warning(self): ending = datetime.datetime.now() + datetime.timedelta(days=300) cert = StubEntitlementCertificate( StubProduct('product2'), start_date=datetime.datetime(2010, 1, 1), end_date=ending, quantity="10", ent_id='ent') self.my_subs_tab.backend.cs.reasons.get_subscription_reasons = Mock(return_value=['Some detail']) image = self.my_subs_tab._get_entry_image(cert) self.assertEqual(WARNING_IMG, image)
def test_entitlement_for_not_installed_product_shows_not_installed(self): product_directory = StubCertificateDirectory([]) entitlement_directory = StubCertificateDirectory( [StubEntitlementCertificate(StubProduct("product1"))]) product_status = getInstalledProductStatus(product_directory, entitlement_directory) # no product certs installed... self.assertEquals(0, len(product_status))
def test_all_expired_entitlements(self): cert = StubProductCertificate(StubProduct('product1')) prod_dir = StubCertificateDirectory([cert]) cert1 = StubEntitlementCertificate( StubProduct('product1'), start_date=datetime(2000, 1, 1, tzinfo=GMT()), end_date=datetime(2001, 1, 1, tzinfo=GMT())) cert2 = StubEntitlementCertificate( StubProduct('product1'), start_date=datetime(2000, 12, 1, tzinfo=GMT()), end_date=datetime(2005, 1, 1, tzinfo=GMT())) ent_dir = StubCertificateDirectory([cert1, cert2]) # Because all entitlements have expired, we should get back the current # date as the last date of valid entitlements: today = datetime.now(GMT()) last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {}) self.assertEqual(today.year, last_valid_date.year) self.assertEqual(today.month, last_valid_date.month) self.assertEqual(today.day, last_valid_date.day)
def test_currently_unentitled_products(self): cert = StubProductCertificate(StubProduct('unentitledProduct')) prod_dir = StubCertificateDirectory([cert]) cert1 = StubEntitlementCertificate( StubProduct('product1'), start_date=datetime(2010, 1, 1), end_date=datetime(2050, 1, 1)) cert2 = StubEntitlementCertificate( StubProduct('product2'), start_date=datetime(2010, 1, 1), end_date=datetime(2060, 1, 1)) ent_dir = StubCertificateDirectory([cert1, cert2]) # Because we have an unentitled product, we should get back the current # date as the last date of valid entitlements: today = datetime.now(GMT()) last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {}) self.assertEqual(today.year, last_valid_date.year) self.assertEqual(today.month, last_valid_date.month) self.assertEqual(today.day, last_valid_date.day)
def test_entitlement_for_installed_product_shows_subscribed(self): product = StubProduct("product1") product_directory = StubCertificateDirectory( [StubProductCertificate(product)]) entitlement_directory = StubCertificateDirectory( [StubEntitlementCertificate(product, sockets=10)]) product_status = getInstalledProductStatus(product_directory, entitlement_directory) self.assertEquals(1, len(product_status)) self.assertEquals("subscribed", product_status[0][4])
def setUp(self): super(MySubscriptionsTabTest, self).setUp() self.uep = StubUEP self.backend = StubBackend() self.cert1 = StubEntitlementCertificate( StubProduct('product2'), start_date=datetime.datetime(2010, 1, 1), end_date=datetime.datetime(2060, 1, 1), quantity="10", ent_id='prod2') self.cert2 = StubEntitlementCertificate( StubProduct('product3'), start_date=datetime.datetime(2010, 1, 1), end_date=datetime.datetime(2060, 1, 1), quantity="10", ent_id='prod3') self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2]) self.my_subs_tab = MySubscriptionsTab(self.backend, None, self.cert_dir, StubProductDirectory([]))
def stub_ent_cert(parent_pid, provided_pids=[], quantity=1, stack_id=None, sockets=1, start_date=None, end_date=None): provided_prods = [] for provided_pid in provided_pids: provided_prods.append(StubProduct(provided_pid)) parent_prod = StubProduct(parent_pid) return StubEntitlementCertificate(parent_prod, provided_products=provided_prods, quantity=quantity, stacking_id=stack_id, sockets=sockets, start_date=start_date, end_date=end_date)
def test_entitlement_for_installed_product_shows_valid(self): product = StubProduct("product1") product_directory = StubCertificateDirectory([ StubProductCertificate(product)]) entitlement_directory = StubCertificateDirectory([ StubEntitlementCertificate(product)]) facts = Facts(None) facts.product_dir = product_directory facts.entitlement_dir = entitlement_directory facts_dict = facts.get_facts() self.assertEquals("valid", facts_dict['system.entitlements_valid'])
def test_unsubscribe_registered(self): connection.UEPConnection = StubUEP prod = StubProduct('stub_product') ent1 = StubEntitlementCertificate(prod) ent2 = StubEntitlementCertificate(prod) ent3 = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.UnSubscribeCommand() managercli.ConsumerIdentity = StubConsumerIdentity StubConsumerIdentity.existsAndValid = classmethod(lambda cls: True) StubConsumerIdentity.exists = classmethod(lambda cls: True) managercli.CertLib = StubCertLib cmd.main(['unsubscribe', '--all']) self.assertEquals(cmd.cp.called_unbind_uuid, StubConsumerIdentity.CONSUMER_ID) cmd.main(['unsubscribe', '--serial=%s' % ent1.serial]) self.assertEquals(cmd.cp.called_unbind_serial, ['%s' % ent1.serial]) code = cmd.main([ 'unsubscribe', '--serial=%s' % ent2.serial, '--serial=%s' % ent3.serial ]) self.assertEquals( cmd.cp.called_unbind_serial, ['%s' % ent2.serial, '%s' % ent3.serial]) self.assertEquals(code, 0) connection.UEPConnection.unbindBySerial = mock.Mock( side_effect=connection.RestlibException( "Entitlement Certificate with serial number 2300922701043065601 could not be found." )) code = cmd.main(['unsubscribe', '--serial=%s' % '2300922701043065601']) self.assertEquals(code, 1)
def test_entitled_products(self): provided = [StubProduct(INST_PID_1), StubProduct(INST_PID_2), StubProduct(INST_PID_3)] self.ent_dir = StubCertificateDirectory([ StubEntitlementCertificate(StubProduct(INST_PID_5), provided_products=provided)]) self.sorter = CertSorter(self.prod_dir, self.ent_dir, {}) self.assertEquals(3, len(self.sorter.valid_products.keys())) self.assertTrue(INST_PID_1 not in self.sorter.partially_valid_products) self.assertTrue(INST_PID_1 in self.sorter.valid_products) self.assertTrue(INST_PID_2 in self.sorter.valid_products) self.assertTrue(INST_PID_3 in self.sorter.valid_products) self.assertTrue(self.sorter.is_valid())
def test_future_and_currently_entitled(self): provided = [StubProduct(INST_PID_2), StubProduct(INST_PID_3)] self.ent_dir = StubCertificateDirectory([ StubEntitlementCertificate(StubProduct(INST_PID_5), provided_products=provided, start_date=datetime.now() + timedelta(days=30), end_date=datetime.now() + timedelta(days=120)), StubEntitlementCertificate(StubProduct(INST_PID_5), provided_products=provided), ]) self.sorter = CertSorter(self.prod_dir, self.ent_dir, {}) self.assertEquals(2, len(self.sorter.valid_products)) self.assertEquals(2, len(self.sorter.future_products)) self.assertEquals(1, len(self.sorter.unentitled_products)) self.assertTrue(INST_PID_2 in self.sorter.future_products) self.assertTrue(INST_PID_3 in self.sorter.future_products) self.assertTrue(INST_PID_2 in self.sorter.valid_products) self.assertTrue(INST_PID_3 in self.sorter.valid_products) self.assertEquals(SUBSCRIBED, self.sorter.get_status(INST_PID_2)) self.assertEquals(SUBSCRIBED, self.sorter.get_status(INST_PID_3))
def test_future_dated_entitlement_shows_invalid(self): product = StubProduct("product1") product_directory = StubCertificateDirectory([ StubProductCertificate(product)]) entitlement_directory = StubCertificateDirectory([ StubEntitlementCertificate(product, start_date=(datetime.now() + timedelta(days=1365)))]) facts = Facts(None) facts.product_dir = product_directory facts.entitlement_dir = entitlement_directory facts_dict = facts.get_facts() self.assertEquals("invalid", facts_dict['system.entitlements_valid'])
def test_unsubscribe_unregistered(self): connection.UEPConnection = StubUEP prod = StubProduct('stub_product') ent = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.RemoveCommand() managercli.ConsumerIdentity = StubConsumerIdentity StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False) StubConsumerIdentity.exists = classmethod(lambda cls: False) cmd.main(['remove', '--all']) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent.is_deleted) prod = StubProduct('stub_product') ent1 = StubEntitlementCertificate(prod) ent2 = StubEntitlementCertificate(prod) ent3 = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.RemoveCommand() managercli.ConsumerIdentity = StubConsumerIdentity StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False) StubConsumerIdentity.exists = classmethod(lambda cls: False) cmd.main(['remove', '--serial=%s' % ent1.serial, '--serial=%s' % ent3.serial]) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent1.is_deleted) self.assertFalse(ent2.is_deleted) self.assertTrue(ent3.is_deleted)
def test_future_dated_entitlement_shows_future_subscribed(self): product = StubProduct("product1") product_directory = StubCertificateDirectory( [StubProductCertificate(product)]) entitlement_directory = StubCertificateDirectory([ StubEntitlementCertificate(product, start_date=(datetime.now() + timedelta(days=1365))) ]) product_status = getInstalledProductStatus(product_directory, entitlement_directory) self.assertEquals(1, len(product_status)) self.assertEquals("future_subscribed", product_status[0][4])
def _stub_content(self): stub_prod = StubProduct('stub_product', provided_tags="stub-product") stub_content = StubContent("a_test_repo", required_tags="stub-product") stub_ent_cert = StubEntitlementCertificate(stub_prod, content=[stub_content]) stub_prod_cert = StubProductCertificate(stub_prod) stub_ent_dir = StubEntitlementDirectory([stub_ent_cert]) stub_prod_dir = StubProductDirectory([stub_prod_cert]) inj.provide(inj.ENT_DIR, stub_ent_dir) inj.provide(inj.PROD_DIR, stub_prod_dir)
def test_delete(self): ent = StubEntitlementCertificate(StubProduct("Prod")) ent.delete = Mock(side_effect=OSError("Cert has already been deleted")) mock_uep = Mock() mock_uep.getCertificates = Mock(return_value=[]) mock_uep.getCertificateSerials = Mock(return_value=[]) update_action = TestingUpdateAction(mock_uep, StubEntitlementDirectory([ent])) try: updates, exceptions = update_action.perform() except OSError: self.fail("operation failed when certificate wasn't deleted") self.assertEquals(0, updates) self.assertEquals([], exceptions)
def setUp(self): # Setup mock product and entitlement certs: self.prod_dir = StubCertificateDirectory([ # Will be unentitled: StubProductCertificate(StubProduct(INST_PID_1)), # Will be entitled: StubProductCertificate(StubProduct(INST_PID_2)), # Will be entitled but expired: StubProductCertificate(StubProduct(INST_PID_3)), ]) self.ent_dir = StubEntitlementDirectory([ StubEntitlementCertificate(StubProduct(INST_PID_2)), StubEntitlementCertificate(StubProduct(INST_PID_3), start_date=datetime.now() - timedelta(days=365), end_date=datetime.now() - timedelta(days=2)), StubEntitlementCertificate(StubProduct(INST_PID_4), start_date=datetime.now() - timedelta(days=365), end_date=datetime.now() + timedelta(days=365)), StubEntitlementCertificate(StubProduct(INST_PID_5)), # entitled, but not installed StubEntitlementCertificate(StubProduct('not_installed_product')), ])
def setUp(self): self.uep = StubUEP self.backend = StubBackend() self.consumer = Mock() self.facts = StubFacts({}) self.cert1 = StubEntitlementCertificate( StubProduct('product2'), start_date=datetime.datetime(2010, 1, 1), end_date=datetime.datetime(2060, 1, 1), quantity="10", stacking_id=None) self.cert_dir = StubCertificateDirectory([self.cert1])
def test_unsubscribe_unregistered(self): prod = StubProduct('stub_product') ent = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.RemoveCommand() self._inject_mock_invalid_consumer() cmd.main(['remove', '--all']) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent.is_deleted) prod = StubProduct('stub_product') pool = StubPool('stub_pool') ent1 = StubEntitlementCertificate(prod) ent2 = StubEntitlementCertificate(prod) ent3 = StubEntitlementCertificate(prod) ent4 = StubEntitlementCertificate(prod, pool=pool) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3, ent4])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.RemoveCommand() cmd.main([ 'remove', '--serial=%s' % ent1.serial, '--serial=%s' % ent3.serial, '--pool=%s' % ent4.pool.id ]) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent1.is_deleted) self.assertFalse(ent2.is_deleted) self.assertTrue(ent3.is_deleted) self.assertTrue(ent4.is_deleted)
def test_expired_are_not_ignored_when_installing_certs(self, write_mock, build_cert_mock): valid_ent = StubEntitlementCertificate(StubProduct("PValid")) expired_ent = StubEntitlementCertificate(StubProduct("PExpired"), start_date=datetime.now() - timedelta(days=365), end_date=datetime.now() - timedelta(days=10)) cp_certificates = [valid_ent, expired_ent] # get certificates actually returns cert bundles cp_bundles = [{'key': Mock(), 'cert': x} for x in cp_certificates] # so we dont try to build actual x509 objects from stub certs def mock_build_cert(bundle): return (bundle['key'], bundle['cert']) build_cert_mock.side_effect = mock_build_cert mock_uep = Mock() mock_uep.getCertificateSerials.return_value = [x.serial for x in cp_certificates] mock_uep.getCertificates.return_value = cp_bundles # Passed into build_cert(bundle) self.set_consumer_auth_cp(mock_uep) stub_ent_dir = StubEntitlementDirectory([]) inj.provide(inj.ENT_DIR, stub_ent_dir) update_action = TestingUpdateAction() # we skip getting the expected serials, where this is normally # populated update_action.report.expected.append(valid_ent.serial) update_action.report.expected.append(expired_ent.serial) update_action.install([valid_ent.serial, expired_ent.serial]) update_report = update_action.report self.assertEqual(0, len(update_report.exceptions()), "No exceptions should have been thrown") self.assertTrue(valid_ent in update_report.added) self.assertTrue(valid_ent.serial in update_report.expected) self.assertTrue(expired_ent.serial in update_report.expected)
def test_unsubscribe_unregistered(self): prod = StubProduct('stub_product') ent = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.UnSubscribeCommand() self._inject_mock_invalid_consumer() cmd.main(['unsubscribe', '--all']) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent.is_deleted) prod = StubProduct('stub_product') ent1 = StubEntitlementCertificate(prod) ent2 = StubEntitlementCertificate(prod) ent3 = StubEntitlementCertificate(prod) inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent1, ent2, ent3])) inj.provide(inj.PROD_DIR, StubProductDirectory([])) cmd = managercli.UnSubscribeCommand() code = cmd.main([ 'unsubscribe', '--serial=%s' % ent1.serial, '--serial=%s' % ent3.serial ]) self.assertTrue(cmd.entitlement_dir.list_called) self.assertTrue(ent1.is_deleted) self.assertFalse(ent2.is_deleted) self.assertTrue(ent3.is_deleted) self.assertEquals(code, 0) code = cmd.main(['unsubscribe', '--serial=%s' % '33333333']) self.assertEquals(code, 1)
def test_expired_entitlement_for_installed_product_shows_expired(self): product = StubProduct("product1") product_directory = StubCertificateDirectory( [StubProductCertificate(product)]) entitlement_directory = StubCertificateDirectory([ StubEntitlementCertificate(product, end_date=(datetime.now() - timedelta(days=2))) ]) product_status = getInstalledProductStatus(product_directory, entitlement_directory) self.assertEquals(1, len(product_status)) self.assertEquals("expired", product_status[0][4])
def test_multi_product_entitlement_expired(self): # Setup one ent cert that provides several things installed # installed: provided = [StubProduct(INST_PID_2), StubProduct(INST_PID_3)] self.ent_dir = StubCertificateDirectory([ StubEntitlementCertificate(StubProduct(INST_PID_5), provided_products=provided)]) self.sorter = CertSorter(self.prod_dir, self.ent_dir, {}, on_date=datetime(2050, 1, 1, tzinfo=GMT())) self.assertEquals(1, len(self.sorter.expired_entitlement_certs)) self.assertEquals(2, len(self.sorter.expired_products.keys())) self.assertTrue(INST_PID_2 in self.sorter.expired_products) self.assertTrue(INST_PID_3 in self.sorter.expired_products) # Expired should not show up as unentitled also: self.assertEquals(1, len(self.sorter.unentitled_products.keys())) self.assertTrue(INST_PID_1 in self.sorter.unentitled_products) self.assertFalse(self.sorter.is_valid())
def setUp(self): stub_prod = StubProduct("fauxprod", provided_tags="TAG1,TAG2") stub_prod2 = StubProduct("fauxprovidedprod", provided_tags="TAG4") stub_prod_cert = StubProductCertificate(stub_prod, provided_products=[stub_prod2]) stub_prod2 = StubProduct("fauxprod2", provided_tags="TAG5,TAG6") stub_prod2_cert = StubProductCertificate(stub_prod2) stub_prod_dir = StubProductDirectory([stub_prod_cert, stub_prod2_cert]) stub_content = [ StubContent("c1", required_tags="", gpg=None), # no required tags StubContent("c2", required_tags="TAG1", gpg=""), StubContent("c3", required_tags="TAG1,TAG2,TAG3"), # should get skipped StubContent("c4", required_tags="TAG1,TAG2,TAG4,TAG5,TAG6", gpg="/gpg.key"), ] self.stub_ent_cert = StubEntitlementCertificate(stub_prod, content=stub_content) stub_ent_dir = StubCertificateDirectory([self.stub_ent_cert]) repolib.ConsumerIdentity = stubs.StubConsumerIdentity stub_uep = stubs.StubUEP() self.update_action = UpdateAction(prod_dir=stub_prod_dir, ent_dir=stub_ent_dir, uep=stub_uep)
def test_one_subscription_with_bundled_products_lists_once(self): product1 = StubProduct("product1") product2 = StubProduct("product2") product3 = StubProduct("product3") product_directory = StubCertificateDirectory( [StubProductCertificate(product1)]) entitlement_directory = StubCertificateDirectory([ StubEntitlementCertificate(product1, [product2, product3], sockets=10) ]) product_status = getInstalledProductStatus(product_directory, entitlement_directory) # neither product3 or product 2 are installed self.assertEquals(1, len(product_status)) # self.assertEquals("product3", product_status[0][0]) # self.assertEquals("Not Installed", product_status[0][3]) # self.assertEquals("product2", product_status[1][0]) # self.assertEquals("Not Installed", product_status[1][3]) self.assertEquals("product1", product_status[0][0]) self.assertEquals("subscribed", product_status[0][4])
def test_delete(self): ent = StubEntitlementCertificate(StubProduct("Prod")) ent.delete = Mock(side_effect=OSError("Cert has already been deleted")) mock_uep = Mock() mock_uep.getCertificates = Mock(return_value=[]) mock_uep.getCertificateSerials = Mock(return_value=[]) self.set_consumer_auth_cp(mock_uep) stub_ent_dir = StubEntitlementDirectory([ent]) inj.provide(inj.ENT_DIR, stub_ent_dir) # use the injected mock uep update_action = TestingUpdateAction() try: update_report = update_action.perform() except OSError: self.fail("operation failed when certificate wasn't deleted") self.assertEquals(0, update_report.updates()) exceptions = update_action.report.exceptions() self.assertEquals([], exceptions)
def setUp(self): super(RepoUpdateActionTests, self).setUp() stub_prod = StubProduct("fauxprod", provided_tags="TAG1,TAG2") stub_prod2 = StubProduct("fauxprovidedprod", provided_tags="TAG4") stub_prod_cert = StubProductCertificate(stub_prod, provided_products=[stub_prod2]) stub_prod2 = StubProduct("fauxprod2", provided_tags="TAG5,TAG6") stub_prod2_cert = StubProductCertificate(stub_prod2) prod_dir = StubProductDirectory([stub_prod_cert, stub_prod2_cert]) inj.provide(inj.PROD_DIR, prod_dir) stub_content = [ StubContent("c1", required_tags="", gpg=None), # no required tags StubContent("c2", required_tags="TAG1", gpg=""), StubContent("c3", required_tags="TAG1,TAG2,TAG3"), # should get skipped StubContent("c4", required_tags="TAG1,TAG2,TAG4,TAG5,TAG6", gpg="/gpg.key", url="/$some/$path"), StubContent("c5", content_type="file", required_tags="", gpg=None), StubContent("c6", content_type="file", required_tags="", gpg=None), ] self.stub_ent_cert = StubEntitlementCertificate(stub_prod, content=stub_content) ent_dir = StubCertificateDirectory([self.stub_ent_cert]) inj.provide(inj.ENT_DIR, ent_dir) repolib.ConsumerIdentity = StubConsumerIdentity