def test_unsubscribe_unregistered(self):
connection.UEPConnection = StubUEP
prod = StubProduct('stub_product')
ent = StubEntitlementCertificate(prod)
cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
[ent]),
prod_dir=StubProductDirectory([]))
managercli.ConsumerIdentity = StubConsumerIdentity
StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
StubConsumerIdentity.exists = classmethod(lambda cls: False)
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)
cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
[ent1, ent2]),
prod_dir=StubProductDirectory([]))
managercli.ConsumerIdentity = StubConsumerIdentity
StubConsumerIdentity.existsAndValid = classmethod(lambda cls: False)
StubConsumerIdentity.exists = classmethod(lambda cls: False)
cmd.main(['unsubscribe', '--serial=%s' % ent1.serial])
self.assertTrue(cmd.entitlement_dir.list_called)
self.assertTrue(ent1.is_deleted)
self.assertFalse(ent2.is_deleted)
def test_unsubscribe_registered(self):
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()
mock_identity = self._inject_mock_valid_consumer()
managercli.EntCertActionInvoker = StubEntActionInvoker
cmd.main(['unsubscribe', '--all'])
self.assertEquals(cmd.cp.called_unbind_uuid, mock_identity.uuid)
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)
self.stub_cp_provider.get_consumer_auth_cp(
).unbindBySerial = mock.Mock(side_effect=connection.RestlibException(
"Entitlement Certificate with serial number "
"2300922701043065601 could not be found."))
code = cmd.main(['unsubscribe', '--serial=%s' % '2300922701043065601'])
def test_future_entitled_products(self):
cert = StubProductCertificate(StubProduct('product1'))
product_dir = StubCertificateDirectory([cert])
cert1 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2010,
1,
1,
tzinfo=GMT()),
end_date=datetime(2050,
1,
1,
tzinfo=GMT()))
cert2 = StubEntitlementCertificate(StubProduct('product1'),
start_date=datetime(2049,
1,
1,
tzinfo=GMT()),
end_date=datetime(2070,
1,
1,
tzinfo=GMT()))
ent_dir = StubCertificateDirectory([cert1, cert2])
last_valid_date = find_first_invalid_date(ent_dir=ent_dir,
product_dir=product_dir,
facts_dict={})
self.assertEqual(2070, last_valid_date.year)
self.assertEqual(1, last_valid_date.month)
self.assertEqual(2, last_valid_date.day)
def _stub_content(self, include_content_access=False):
stub_prod = StubProduct('stub_product', provided_tags="stub-product")
stub_content = StubContent("a_test_repo", required_tags="stub-product")
stub_content2 = StubContent("test_repo_2",
required_tags="stub-product")
stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=[stub_content])
stub_prod_cert = StubProductCertificate(stub_prod)
certs = [stub_ent_cert]
if include_content_access:
self.stub_content_access_cert = StubEntitlementCertificate(
stub_prod,
content=[stub_content, stub_content2],
entitlement_type=CONTENT_ACCESS_CERT_TYPE)
# content access cert is first and last, so naively wrong implementations will prioritize it.
certs = [
self.stub_content_access_cert, stub_ent_cert,
self.stub_content_access_cert
]
stub_ent_dir = StubEntitlementDirectory(certs)
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_expired_are_not_ignored_when_installing_certs(self, write_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]
mock_uep = Mock()
mock_uep.getCertificates.return_value = cp_certificates # Passed into build(cert)
update_action = TestingUpdateAction(mock_uep,
StubEntitlementDirectory([]))
report = UpdateReport()
report.expected.append(valid_ent.serial)
report.expected.append(expired_ent.serial)
exceptions = update_action.install(
[valid_ent.serial, expired_ent.serial], report)
self.assertEqual(0, len(exceptions),
"No exceptions should have been thrown")
self.assertTrue(valid_ent in report.added)
self.assertTrue(valid_ent.serial in report.expected)
self.assertTrue(expired_ent.serial in report.expected)
def setUp(self, mock_update):
SubManFixture.setUp(self)
# Setup mock product and entitlement certs:
self.prod_dir = StubProductDirectory(
pids=[INST_PID_1, INST_PID_2, INST_PID_3, INST_PID_4])
self.ent_dir = StubEntitlementDirectory([
StubEntitlementCertificate(PROD_2, ent_id=ENT_ID_2),
StubEntitlementCertificate(PROD_1, ent_id=ENT_ID_1),
StubEntitlementCertificate(product=PROD_4,
stacking_id=STACK_1,
ent_id=ENT_ID_4),
# entitled, but not installed
StubEntitlementCertificate(StubProduct('not_installed_product',
name="Some Product"),
ent_id="SomeSubId"),
])
self.mock_uep = StubUEP()
self.status_mgr = EntitlementStatusCache()
self.status_mgr.load_status = Mock(return_value=SAMPLE_COMPLIANCE_JSON)
self.status_mgr.write_cache = Mock()
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, self.status_mgr)
inj.provide(inj.PROD_DIR, self.prod_dir)
inj.provide(inj.ENT_DIR, self.ent_dir)
self.sorter = CertSorter()
self.sorter.is_registered = Mock(return_value=True)
def test_scan_for_expired_or_future_products(self):
prod_dir = StubProductDirectory(pids=["a", "b", "c", "d", "e"])
ent_dir = StubEntitlementDirectory([
StubEntitlementCertificate(StubProduct("a")),
StubEntitlementCertificate(StubProduct("b")),
StubEntitlementCertificate(StubProduct("c")),
StubEntitlementCertificate(
StubProduct("d"),
start_date=datetime.now() - timedelta(days=365),
end_date=datetime.now() - timedelta(days=2)),
StubEntitlementCertificate(
StubProduct("e"),
start_date=datetime.now() + timedelta(days=365),
end_date=datetime.now() + timedelta(days=730)),
])
inj.provide(inj.PROD_DIR, prod_dir)
inj.provide(inj.ENT_DIR, ent_dir)
sorter = StubCertSorter()
sorter.valid_products = {"a": StubProduct("a")}
sorter.partially_valid_products = {"b": StubProduct("b")}
sorter._scan_entitlement_certs()
self.assertEquals(["d"], sorter.expired_products.keys())
self.assertEquals(["e"], sorter.future_products.keys())
self.assertEquals(3, len(sorter.valid_entitlement_certs))
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 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')
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()
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_all_expired_entitlements(self):
cert = StubProductCertificate(StubProduct('product1'))
product_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=ent_dir,
product_dir=product_dir,
facts_dict={})
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_match(self):
ent_cert = StubEntitlementCertificate(product=StubProduct(name="test*entitlement?", product_id="123456789"), service_level="Premium", provided_products=[
"test product b",
"beta product 1",
"shared product",
"back\\slash"
])
# Order information is hard-coded in the stub, so we've to modify it
# separately:
ent_cert.order.contract = "Contract-A"
no_sla_ent_cert = StubEntitlementCertificate(
product=StubProduct(name="nobodycares", product_id="123456789"),
service_level=None, provided_products=[])
test_data = [
(None, None, ent_cert, False),
("*entitlement*", None, ent_cert, True),
("*shared*", None, ent_cert, True),
("beta*", None, ent_cert, True),
("123456789", None, ent_cert, True),
("prem*", None, ent_cert, True), # service level via --contains-text vs --servicelevel
("*contract*", None, ent_cert, True),
("contract-a", None, ent_cert, True),
("contract-b", None, ent_cert, False),
("*entitlement*", "Premium", ent_cert, True),
("*shared*", "Premium", ent_cert, True),
("beta*", "Premium", ent_cert, True),
("123456789", "Premium", ent_cert, True),
("prem*", "Premium", ent_cert, True), # ^
("*contract*", "Premium", ent_cert, True),
("contract-a", "Premium", ent_cert, True),
("contract-b", "Premium", ent_cert, False),
("*entitlement*", "Standard", ent_cert, False),
("*shared*", "Standard", ent_cert, False),
("beta*", "Standard", ent_cert, False),
("123456789", "Standard", ent_cert, False),
("prem*", "Standard", ent_cert, False), # ^
("*contract*", "Standard", ent_cert, False),
("contract-a", "Standard", ent_cert, False),
("contract-b", "Standard", ent_cert, False),
(None, "Premium", ent_cert, True),
(None, "pReMiUm", ent_cert, True),
(None, "Standard", ent_cert, False),
(None, "sTANDard", ent_cert, False),
(None, "aslfk;", ent_cert, False),
(None, "", ent_cert, False),
(None, "", no_sla_ent_cert, True),
]
for (index, data) in enumerate(test_data):
cert_filter = EntitlementCertificateFilter(
filter_string=data[0], service_level=data[1])
result = cert_filter.match(data[2])
self.assertEquals(result, data[3], "EntitlementCertificateFilter.match failed with data set %i.\nActual: %s\nExpected: %s" % (index, result, data[3]))
def setUp(self):
self.sorter = Mock()
self.sorter.valid_products = [INST_PID_1]
self.sorter.valid_entitlement_certs = [
StubEntitlementCertificate(PROD_2, ent_id=ENT_ID_2),
StubEntitlementCertificate(PROD_1, ent_id=ENT_ID_1),
StubEntitlementCertificate(product=PROD_4,
stacking_id=STACK_1,
ent_id=ENT_ID_4),
StubEntitlementCertificate(StubProduct('not_installed_product',
name="Some Product"),
ent_id="SomeSubId")
]
reason_list = []
reason_list.append(
self.build_reason('NOTCOVERED',
'Not covered by a valid subscription.', {
'product_id': '801',
'name': 'RAM Limiting Product'
}))
reason_list.append(
self.build_ent_reason_with_attrs(
'CORES',
'Only covers 16 of 32 cores.',
'32',
'16',
name='Multi-Attribute Stackable (16 cores, 4 sockets, 8GB RAM)',
stack='multiattr-stack-test'))
reason_list.append(
self.build_ent_reason_with_attrs(
'SOCKETS',
'Only covers 4 of 8 sockets.',
'8',
'4',
name='Multi-Attribute Stackable (16 cores, 4 sockets, 8GB RAM)',
stack='multiattr-stack-test'))
reason_list.append(
self.build_ent_reason_with_attrs(
'RAM',
'Only covers 8GB of 31GB of RAM.',
'31',
'8',
name='Multi-Attribute Stackable (16 cores, 4 sockets, 8GB RAM)',
stack='multiattr-stack-test'))
reason_list.append(
self.build_ent_reason_with_attrs(
'ARCH',
'Covers architecture ppc64 but the system is x86_64.',
'x86_64',
'ppc64',
name='Awesome OS for ppc64',
ent='ff8080813e468fd8013e4694a4921179'))
self.sorter.reasons = Reasons(reason_list, self.sorter)
def test_just_entitlements(self):
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])
prod_dir = StubCertificateDirectory([])
last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {})
self.assertTrue(last_valid_date is None)
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 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 test_one_product_with_two_entitlements_lists_product_twice(self):
product = StubProduct("product1")
product_directory = StubCertificateDirectory(
[StubProductCertificate(product)])
entitlement_directory = StubCertificateDirectory([
StubEntitlementCertificate(product),
StubEntitlementCertificate(product)
])
product_status = getInstalledProductStatus(product_directory,
entitlement_directory)
# only "product" is installed
self.assertEquals(1, len(product_status))
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_expired_but_provided_in_another_entitlement(self):
self.ent_dir = StubCertificateDirectory([
StubEntitlementCertificate(StubProduct(INST_PID_5),
provided_products=[StubProduct(INST_PID_3)]),
StubEntitlementCertificate(StubProduct(INST_PID_5),
start_date=datetime.now() - timedelta(days=365),
end_date=datetime.now() - timedelta(days=2),
provided_products=[StubProduct(INST_PID_3)]),
StubEntitlementCertificate(StubProduct(INST_PID_4))
])
self.sorter = CertSorter(self.prod_dir, self.ent_dir, {})
self.assertEquals(1, len(self.sorter.valid_products.keys()))
self.assertTrue(INST_PID_3 in self.sorter.valid_products)
self.assertEquals(0, len(self.sorter.expired_products.keys()))
def test_entitled_products(self):
cert = StubProductCertificate(StubProduct('product1'))
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])
last_valid_date = find_first_invalid_date(ent_dir, prod_dir, {})
self.assertEqual(2050, last_valid_date.year)
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 = StubEntitlementDirectory([self.stub_ent_cert])
inj.provide(inj.ENT_DIR, ent_dir)
repolib.ConsumerIdentity = StubConsumerIdentity
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 setUp(self):
super(TestPoolTypeCache, self).setUp()
self.cp_provider = inj.require(inj.CP_PROVIDER)
self.cp_provider.consumer_auth_cp = Mock()
self.cp = self.cp_provider.consumer_auth_cp
certs = [StubEntitlementCertificate(StubProduct('pid1'), pool=StubPool('someid'))]
self.ent_dir = StubEntitlementDirectory(certificates=certs)
def test_partial_and_invalid_fact(self, mock_sorter):
ents = []
stub_product = StubProduct('1005')
stub_ent_cert = StubEntitlementCertificate(stub_product, quantity=2, stacking_id='stack1', sockets=2)
ents.append(stub_ent_cert)
entitlement_directory = StubCertificateDirectory(ents)
product = StubProduct("product1")
product_directory = StubCertificateDirectory([
StubProductCertificate(product)])
mock_sorter_instance = mock_sorter.return_value
mock_sorter_instance.partially_valid_products = {'foo': 'blah'}
mock_sorter_instance.unentitled_products = {'bar': 'apple'}
mock_sorter_instance.expired_products = {}
mock_sorter_instance.partial_stacks = {}
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 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",
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)
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_print_consumed_one_ent_one_product(self):
product = StubProduct("product1")
self.ent_dir.certs.append(StubEntitlementCertificate(product))
self.cc.sorter = Mock()
self.cc.sorter.get_subscription_reasons_map = Mock()
self.cc.sorter.get_subscription_reasons_map.return_value = {}
self.cc.print_consumed()
def test_sorter_adds_group_for_stackable_entitlement(self):
ent1_prod = StubProduct("Product 1")
ent1 = StubEntitlementCertificate(ent1_prod, stacking_id=3)
entitlements = [ent1]
sorter = EntitlementCertStackingGroupSorter(entitlements)
self._assert_1_group_with_1_entitlement('Product 1', ent1, sorter)
def test_check_key(self, MockAccess, MockExists):
ent_dir = EntitlementDirectory()
MockAccess.return_value = True
MockExists.return_value = True
product = StubProduct("product1")
ent_cert = StubEntitlementCertificate(product)
ret = ent_dir._check_key(ent_cert)
self.assertTrue(ret)
def test_get_entry_image_expired(self):
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2011, 1, 1),
quantity="10", stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRED_IMG, image)
def test_sorter_adds_group_for_non_stackable_entitlement(self):
ent1_prod = StubProduct("Product 1")
ent1 = StubEntitlementCertificate(ent1_prod, stacking_id=None)
entitlements = [ent1]
sorter = EntitlementCertStackingGroupSorter(entitlements)
# With no stacking id, we expect an empty group name
self._assert_1_group_with_1_entitlement("", ent1, sorter)
def test_get_entry_image_expiring(self):
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=tomorrow,
quantity="10", stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRING_IMG, image)
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 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_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 test_expired_order_date_gives_invalid_cert(self):
cert = StubEntitlementCertificate(StubProduct('product'),
start_date=datetime(2010, 7, 27),
end_date=yesterday())
self.assertFalse(cert.is_valid())
def test_valid_order_date_gives_valid_cert(self):
cert = StubEntitlementCertificate(StubProduct('product'),
start_date=datetime(2010, 7, 27),
end_date=datetime(2050, 7, 26))
self.assertTrue(cert.is_valid())
class MySubscriptionsTabTest(unittest.TestCase):
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 tearDown(self):
pass
def test_correct_cert_data_inserted_into_store(self):
self.cert1.order.stacking_id = None
column_entries = self._get_entries_for_test()
self.assertEquals(1, len(column_entries))
entry = column_entries[0]
self._assert_entry(entry)
def test_stacking_entry_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
column_entries = self._get_entries_for_test()
self.assertEquals(2, len(column_entries))
self._assert_group_entry(column_entries[0])
self._assert_entry(column_entries[1])
def _get_entries_for_test(self):
column_entries = []
def collect_entries(iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
my_subs_tab = MySubscriptionsTab(self.backend, self.consumer, self.facts,
None, self.cert_dir)
my_subs_tab.store.add_map = collect_entries
my_subs_tab.update_subscriptions()
return column_entries
def _assert_entry(self, entry):
self.assertEquals(self.cert1.getOrder().getName(), entry['subscription'])
self.assertEquals(self.cert1.validRange().begin(), entry['start_date'])
self.assertEquals(self.cert1.validRange().end(), entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
self.assertEquals(self.cert1.getOrder().getQuantityUsed(), entry['quantity'])
self.assertEquals(self.cert1.serialNumber(), entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_group_entry(self, entry):
self.assertEquals(self.cert1.getProduct().getName(),
entry['subscription'])
self.assertFalse('start_date' in entry)
self.assertFalse('expiration_date' in entry)
self.assertFalse('installed_text' in entry)
self.assertEquals(0.0, entry['installed_value'])
self.assertFalse('quantity' in entry)
self.assertFalse('serial' in entry)
self.assertTrue(entry['is_group_row'])
