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_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 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'])