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
