def test_no_ent_certs_installed_products(self): prod_dir = stubs.StubProductDirectory(pids=[1, 2, 3, 4, 5]) inj.provide(inj.PROD_DIR, prod_dir) brand_installer = self.brand_installer_class([]) brand_installer.install() self.assertFalse(self.mock_install.called)
def _inject_mock_invalid_consumer(self, uuid=None): invalid_identity = mock.NonCallableMock(name='InvalidIdentityMock') invalid_identity.is_valid = mock.Mock(return_value=False) invalid_identity.uuid = uuid or "INVALIDCONSUMERUUID" invalid_identity.cert_dir_path = "/not/a/real/path/to/pki/consumer/" inj.provide(inj.IDENTITY, invalid_identity) return invalid_identity
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_list_installed_sca_mode(self, is_simple_content_access_mock): """ Test output of 'subscription-manager list --installed', when SCA mode is used """ is_simple_content_access_mock.return_value = True installed_product_certs = [ StubProductCertificate(product=StubProduct(name="test product", product_id="8675309")), StubProductCertificate(product=StubProduct( name="another test product", product_id="123456")), ] stub_sorter = StubCertSorter() for product_cert in installed_product_certs: product = product_cert.products[0] stub_sorter.installed_products[product.id] = product_cert provide(CERT_SORTER, stub_sorter) with Capture() as captured: list_command = managercli.ListCommand() list_command.main(["--installed"]) assert "Product Name:" in captured.out assert "Product ID:" in captured.out assert "Version:" in captured.out assert "Arch:" in captured.out # Following attributes should not be printed in SCA mode, because it does not make # any sense to print them in SCA mode assert "Status:" not in captured.out assert "Status Details:" not in captured.out assert "Starts:" not in captured.out assert "Ends:" not in captured.out
def setUp(self): super(TestFactlib, self).setUp() #self.stub_uep = stubs.StubUEP() self.expected_facts = {'fact1': 'F1', 'fact2': 'F2'} inj.provide(inj.FACTS, stubs.StubFacts(self.expected_facts)) self.fl = factlib.FactsActionInvoker()
def test_list_installed_with_pidonly(self): installed_product_certs = [ StubProductCertificate(product=StubProduct(name="test product*", product_id="8675309")), StubProductCertificate(product=StubProduct( name="another(?) test\\product", product_id="123456")), ] stub_sorter = StubCertSorter() for product_cert in installed_product_certs: product = product_cert.products[0] stub_sorter.installed_products[product.id] = product_cert provide(CERT_SORTER, stub_sorter) try: with Capture() as captured: list_command = managercli.ListCommand() list_command.main(["--installed", "--pool-only"]) self.fail("Expected error did not occur") except SystemExit: for cert in installed_product_certs: self.assertFalse(cert.products[0].id in captured.out)
def setUp(self): super(TestReleaseIsCorrectRhel, self).setUp() inj.provide(inj.ENT_DIR, self.ent_dir) inj.provide(inj.PROD_DIR, self.prod_dir) self.rb = release.ReleaseBackend()
def test_unregistered(self): id_mock = NonCallableMock() id_mock.is_valid.return_value = False inj.provide(inj.IDENTITY, id_mock) self.calculator = ValidProductDateRangeCalculator(None) for pid in (INST_PID_1, INST_PID_2, INST_PID_3): self.assertTrue(self.calculator.calculate(pid) is None)
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(self): stub_product = DefaultStubProduct() mock_prod_dir = mock.NonCallableMock(name='MockProductDir') mock_prod_dir.get_installed_products.return_value = [stub_product.id] inj.provide(inj.PROD_DIR, mock_prod_dir) mock_ent_cert = mock.Mock(name='MockEntCert') mock_ent_cert.products = [stub_product] brand_installer = self.brand_installer_class([mock_ent_cert]) brand_installer.install() self.assertTrue(self.mock_install.called) call_args = self.mock_install.call_args brand_arg = call_args[0][0] self.assertTrue(isinstance(brand_arg, entbranding.ProductBrand)) self.assertTrue(isinstance(brand_arg, rhelentbranding.RHELProductBrand)) self.assertEqual("Awesome OS super", brand_arg.name) # verify the install on all the installers got called count = 0 for bi in brand_installer.brand_installers: if isinstance(bi, mock.Mock): self.assertTrue(bi.install.called) count = count + 1 self.assertEqual(2, count)
def test_get_brand_branded_unknown_brand_type(self): stub_installed_product = StubProduct(id=123, name="Stub Product Name") # note, no 'brand_type' attribute other_stub_installed_product = StubProduct( id=321, name='A Non Branded Product') mock_product_dir = mock.NonCallableMock() mock_product_dir.get_installed_products.return_value = [ stub_installed_product.id, other_stub_installed_product.id ] inj.provide(inj.PROD_DIR, mock_product_dir) stub_product = StubProduct(id=123, brand_type="middleware", name="Stub Product Name", brand_name="Awesome Middleware") mock_ent_cert = mock.Mock() mock_ent_cert.products = [stub_product] ent_certs = [mock_ent_cert] # NOTE: this looks like a branded product, except the brand type is one # the RHELBrandPicker doesn't know brand_picker = rhelentbranding.RHELBrandPicker(ent_certs) brand = brand_picker.get_brand() self.assertTrue(brand is None)
def setUp(self): super(TestReleaseIsCorrectRhel, self).setUp() inj.provide(inj.ENT_DIR, self.ent_dir) inj.provide(inj.PROD_DIR, self.prod_dir) self.cdn_rv_provider = release.CdnReleaseVersionProvider()
def test(self): stub_product = DefaultStubProduct() stub_installed_product = DefaultStubInstalledProduct() mock_prod_dir = mock.NonCallableMock(name='MockProductDir') mock_prod_dir.get_installed_products.return_value = [ stub_installed_product.id ] inj.provide(inj.PROD_DIR, mock_prod_dir) mock_ent_cert = mock.Mock(name='MockEntCert') mock_ent_cert.products = [stub_product] self._inj_mock_ent_dir([mock_ent_cert]) brand_installer = self.brand_installer_class() brand_installer.install() self.assertTrue(self.mock_install.called) call_args = self.mock_install.call_args brand_arg = call_args[0][0] self.assertTrue(isinstance(brand_arg, entbranding.ProductBrand)) self.assertTrue(isinstance(brand_arg, rhelentbranding.RHELProductBrand)) self.assertEqual('Awesome OS super', brand_arg.name)
def test_get_brand_branded_unknown_brand_type(self): stub_installed_product = StubProduct(id=123, name="Stub Product Name") # note, no 'brand_type' attribute other_stub_installed_product = StubProduct(id=321, name="A Non Branded Product") mock_product_dir = mock.NonCallableMock() mock_product_dir.get_installed_products.return_value = [ stub_installed_product.id, other_stub_installed_product.id, ] inj.provide(inj.PROD_DIR, mock_product_dir) stub_product = StubProduct( id=123, brand_type="middleware", name="Stub Product Name", brand_name="Awesome Middleware" ) mock_ent_cert = mock.Mock() mock_ent_cert.products = [stub_product] ent_certs = [mock_ent_cert] # NOTE: this looks like a branded product, except the brand type is one # the RHELBrandPicker doesn't know brand_picker = rhelentbranding.RHELBrandPicker(ent_certs) brand = brand_picker.get_brand() self.assertTrue(brand is None)
def setUp(self): super(TestManagerGuiMainWindow, self).setUp() id_mock = mock.Mock() id_mock.name = "John Q Consumer" id_mock.uuid = "211211381984" id_mock.exists_and_valid = mock.Mock(return_value=True) provide(IDENTITY, id_mock)
def setUp(self): SubManFixture.setUp(self) self.status = json.loads(INST_PROD_STATUS)['installedProducts'] self.prod_status_cache = NonCallableMock() self.prod_status_cache.load_status = Mock(return_value=self.status) inj.provide(inj.PROD_STATUS_CACHE, self.prod_status_cache) self.calculator = ValidProductDateRangeCalculator(None)
def setUp(self): super(TestFactlib, self).setUp() # As set in fixture.py: self.expected_facts = {"mock.facts": "true"} inj.provide(inj.FACTS, stubs.StubFacts(self.expected_facts)) self.fl = factlib.FactsActionInvoker()
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.assertEqual(cmd.cp.called_unbind_uuid, mock_identity.uuid) cmd.cp.reset() cmd.main(['unsubscribe', '--serial=%s' % ent1.serial]) self.assertEqual(cmd.cp.called_unbind_serial, ['%s' % ent1.serial]) cmd.cp.reset() code = cmd.main(['unsubscribe', '--serial=%s' % ent2.serial, '--serial=%s' % ent3.serial]) self.assertEqual(cmd.cp.called_unbind_serial, ['%s' % ent2.serial, '%s' % ent3.serial]) self.assertEqual(code, 0) expected_exception = connection.RestlibException("Entitlement Certificate with serial number " "2300922701043065601 could not be found.") self.stub_cp_provider.get_consumer_auth_cp().unbindBySerial = mock.Mock(side_effect=expected_exception) code = cmd.main(['unsubscribe', '--serial=%s' % '2300922701043065601'])
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 _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_missing_installed_product(self, mock_update): # Add a new installed product server doesn't know about: prod_dir = StubProductDirectory(pids=[INST_PID_1, INST_PID_2, INST_PID_3, "product4"]) inj.provide(inj.PROD_DIR, prod_dir) sorter = CertSorter() self.assertTrue('product4' in sorter.unentitled_products)
def test_list_installed(self): """ Test output of 'subscription-manager list --installed' """ installed_product_certs = [ StubProductCertificate(product=StubProduct(name="test product", product_id="8675309")), StubProductCertificate(product=StubProduct( name="another test product", product_id="123456")), ] stub_sorter = StubCertSorter() for product_cert in installed_product_certs: product = product_cert.products[0] stub_sorter.installed_products[product.id] = product_cert provide(CERT_SORTER, stub_sorter) with Capture() as captured: list_command = managercli.ListCommand() list_command.main(["--installed"]) assert "Product Name:" in captured.out assert "Product ID:" in captured.out assert "Version:" in captured.out assert "Arch:" in captured.out assert "Status:" in captured.out assert "Status Details:" in captured.out assert "Starts:" in captured.out assert "Ends:" in captured.out
def test(self): stub_product = DefaultStubProduct() mock_prod_dir = mock.NonCallableMock(name="MockProductDir") mock_prod_dir.get_installed_products.return_value = [stub_product.id] inj.provide(inj.PROD_DIR, mock_prod_dir) mock_ent_cert = mock.Mock(name="MockEntCert") mock_ent_cert.products = [stub_product] brand_installer = self.brand_installer_class([mock_ent_cert]) brand_installer.install() self.assertTrue(self.mock_install.called) call_args = self.mock_install.call_args brand_arg = call_args[0][0] self.assertTrue(isinstance(brand_arg, entbranding.ProductBrand)) self.assertTrue(isinstance(brand_arg, rhelentbranding.RHELProductBrand)) self.assertEquals("Awesome OS super", brand_arg.name) # verify the install on all the installers got called count = 0 for bi in brand_installer.brand_installers: if isinstance(bi, mock.Mock): self.assertTrue(bi.install.called) count = count + 1 self.assertEquals(2, count)
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.assertEqual(["d"], list(sorter.expired_products.keys())) self.assertEqual(["e"], list(sorter.future_products.keys())) self.assertEqual(3, len(sorter.valid_entitlement_certs))
def test_missing_installed_product(self, mock_update): # Add a new installed product server doesn't know about: prod_dir = StubProductDirectory( pids=[INST_PID_1, INST_PID_2, INST_PID_3, "product4"]) inj.provide(inj.PROD_DIR, prod_dir) sorter = CertSorter() self.assertTrue("product4" in sorter.unentitled_products)
def _get_rb(self): inj.provide(inj.ENT_DIR, self.ent_dir) inj.provide(inj.PROD_DIR, self.prod_dir) rb = release.ReleaseBackend() return rb
def test_multiple_matching_branded_products(self): stub_product = DefaultStubProduct() stub_installed_product = DefaultStubInstalledProduct() stub_product_2 = StubProduct( id=321, brand_type='OS', name="Awesome", brand_name="Slightly Different Awesome OS Super") stub_installed_product_2 = StubProduct(id=321, name="Awesome") mock_prod_dir = mock.NonCallableMock(name='MockProductDir') mock_prod_dir.get_installed_products.return_value = [ stub_installed_product.id, stub_installed_product_2.id ] inj.provide(inj.PROD_DIR, mock_prod_dir) mock_ent_cert = mock.Mock(name='MockEntCert') mock_ent_cert.products = [stub_product, stub_product_2] brand_installer = self.brand_installer_class([mock_ent_cert]) brand_installer.install() # we give up in this case and leave things as is self.assertFalse(self.mock_install.called)
def test_get_uep_from_options(self, patched_uep): inj.provide(inj.CP_PROVIDER, subscription_manager.cp_provider.CPProvider) options = { 'username': '******', 'password': '******', 'host': 'localhost', 'port': 8443, 'handler': '/candlepin' } self._inject_mock_invalid_consumer() register_service = DomainSocketRegisterDBusObject( conn=self.dbus_connection) register_service.build_uep(options) from rhsmlib.dbus.objects.register import conf as register_conf conf = register_conf['server'] patched_uep.assert_called_once_with( username=options['username'], password=options['password'], host=options['host'], ssl_port=options['port'], handler=options['handler'], proxy_hostname=conf['proxy_hostname'], proxy_port=conf.get_int('proxy_port'), proxy_user=conf['proxy_user'], proxy_password=conf['proxy_password'], no_proxy=conf['no_proxy'], correlation_id=mock.ANY, restlib_class=rhsm.connection.BaseRestLib)
def test_get_brand_multiple_ents_with_branding_different_branded_name( self): # inj a prod dir with some installed products stub_product = DefaultStubProduct() # same product id, different name stub_product_2 = StubProduct( id=123, brand_type='OS', name='A Different Stub Product', brand_name='A Different branded Stub Product') mock_product_dir = mock.NonCallableMock() # note stub_product.id=123 will match the Product from both ents mock_product_dir.get_installed_products.return_value = [ stub_product.id ] inj.provide(inj.PROD_DIR, mock_product_dir) mock_ent_cert = mock.Mock() mock_ent_cert.products = [stub_product] mock_ent_cert_2 = mock.Mock() mock_ent_cert_2.products = [stub_product_2] ent_certs = [mock_ent_cert, mock_ent_cert_2] brand_picker = rhelentbranding.RHELBrandPicker(ent_certs) brand = brand_picker.get_brand() self.assertTrue(brand is None)
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.assertEqual(["d"], list(sorter.expired_products.keys())) self.assertEqual(["e"], list(sorter.future_products.keys())) self.assertEqual(3, len(sorter.valid_entitlement_certs))
def test_main_window(self): provide(PROD_DIR, stubs.StubProductDirectory([])) provide(PRODUCT_DATE_RANGE_CALCULATOR, mock.Mock()) managergui.MainWindow(backend=stubs.StubBackend(), facts=stubs.StubFacts(), ent_dir=stubs.StubCertificateDirectory([]), prod_dir=stubs.StubProductDirectory([]))
def test_main_window(self): provide(PROD_DIR, stubs.StubProductDirectory([])) provide(PRODUCT_DATE_RANGE_CALCULATOR, mock.Mock()) managergui.MainWindow(backend=stubs.StubBackend(), ent_dir=stubs.StubCertificateDirectory([]), prod_dir=stubs.StubProductDirectory([]))
def test_entitlement_for_not_installed_product_shows_nothing(self): product_directory = StubProductDirectory([]) provide(PROD_DIR, product_directory) product_status = InstalledProducts(StubUEP()).list() # no product certs installed... self.assertEqual(0, len(product_status))
def setUp(self): super(TestPreferencesDialog, self).setUp() # FIXME: this is c&p and could be in a fixture sub class # that does the same things StubConsumer does now self.id_mock = mock.Mock() self.id_mock.name = "John Q Consumer" self.id_mock.uuid = "not_actually_a_uuid" self.id_mock.exists_and_valid = mock.Mock(return_value=True) provide(IDENTITY, self.id_mock)
def testShowPreferencesDialogNoConsumer(self): id_mock = mock.Mock() id_mock.name = "John Q Consumer" id_mock.uuid = None id_mock.exists_and_valid = mock.Mock(return_value=True) provide(IDENTITY, id_mock) self._getPrefDialog() self.preferences_dialog.show()
def test_entitlement_for_not_installed_product_shows_nothing(self): product_directory = StubProductDirectory([]) provide(PROD_DIR, product_directory) product_status = get_installed_product_status(product_directory, None, StubUEP()) # no product certs installed... self.assertEquals(0, len(product_status))
def test_idcertlib_noops_when_serialnum_is_same(self, mock_persist): id_update_action = identitycertlib.IdentityUpdateAction() #certlib.ConsumerIdentity = stubs.StubConsumerIdentity #certlib.ConsumerIdentity.getSerialNumber = getSerialNumber inj.provide(inj.IDENTITY, InvalidIdentity()) id_update_action.perform() self.assertFalse(mock_persist.called)
def test_clean_up_remove_68_pem(self, mock_remove, mock_isfile): mock_product_directory = NonCallableMock(spec=ProductDirectory) mock_product_directory.path = "/some/path" inj.provide(inj.PROD_DIR, mock_product_directory) self.engine.db = MagicMock() mock_isfile.side_effect = iter([True, True]) self.engine.clean_up([]) mock_remove.assert_called_with("/some/path/68.pem") self.engine.db.delete.assert_called_with("68") self.engine.db.write.assert_called_with()
def _inject_mock_invalid_consumer(self, uuid=None): """For chaning injected consumer identity to one that fails is_valid() Returns the injected identity if it need to be examined. """ invalid_identity = NonCallableMock(name='InvalidIdentityMock') invalid_identity.is_valid = Mock(return_value=False) invalid_identity.uuid = uuid or "INVALIDCONSUMERUUID" inj.provide(inj.IDENTITY, invalid_identity) return invalid_identity
def setUp(self): super(TestInstalledProductsCache, self).setUp() self.prod_dir = StubCertificateDirectory([ StubProductCertificate(StubProduct('a-product', name="Product A", provided_tags="product,product-a")), StubProductCertificate(StubProduct('b-product', name="Product B", provided_tags="product,product-b")), StubProductCertificate(StubProduct('c-product', name="Product C", provided_tags="product-c")), ]) inj.provide(inj.PROD_DIR, self.prod_dir) self.mgr = InstalledProductsManager()
def test_get_installed_branded_products(self): stub_product = DefaultStubProduct() mock_product_dir = mock.NonCallableMock() mock_product_dir.get_installed_products.return_value = [stub_product.id] inj.provide(inj.PROD_DIR, mock_product_dir) brand_picker = rhelentbranding.RHELBrandPicker([]) irp = brand_picker._is_installed_rhel_branded_product(stub_product) self.assertTrue(irp)
def _inject_mock_valid_consumer(self, uuid=None): """For changing injected consumer identity to one that passes is_valid() Returns the injected identity if it need to be examined. """ identity = NonCallableMock(name='ValidIdentityMock') identity.uuid = uuid or "VALIDCONSUMERUUID" identity.is_valid = Mock(return_value=True) identity.cert_dir_path = "/not/a/real/path/to/pki/consumer/" inj.provide(inj.IDENTITY, identity) return identity
def test_removed(self): # non rhel cert, not in active, with enabled repo self.mock_pdb.find_repos.return_value = ["repo1"] cert = self._create_non_rhel_cert() prod_dir = stubs.StubProductDirectory([]) prod_dir.certs.append(cert) inj.provide(inj.PROD_DIR, prod_dir) pm = yum_product_id.YumProductManager(self.mock_yb) pm.update_removed([]) self.assertTrue(cert.delete.called)
def test_installed_mismatch_unentitled(self, mock_update): # Use a different product directory with something not present # in the response from the server as an unentitled product: prod_dir = StubProductDirectory( pids=[INST_PID_1, INST_PID_2]) inj.provide(inj.PROD_DIR, prod_dir) sorter = CertSorter() self.assertFalse(INST_PID_3 in sorter.installed_products) # Should get filtered out of unentitled products even though # server reported it here: self.assertFalse(INST_PID_3 in sorter.unentitled_products)
def setUp(self): super(TestInstalledProductsCache, self).setUp() self.prod_dir = StubCertificateDirectory( [ StubProductCertificate(StubProduct("a-product", name="Product A")), StubProductCertificate(StubProduct("b-product", name="Product B")), StubProductCertificate(StubProduct("c-product", name="Product C")), ] ) inj.provide(inj.PROD_DIR, self.prod_dir) self.mgr = InstalledProductsManager()
def test_no_entitlement_for_installed_product_shows_no_subscribed(self): product_directory = StubProductDirectory(pids=['product1']) provide(PROD_DIR, product_directory) stub_sorter = StubCertSorter() stub_sorter.unentitled_products['product1'] = None # prod cert unused here provide(CERT_SORTER, stub_sorter) product_status = get_installed_product_status(product_directory, None, StubUEP()) self.assertEquals(1, len(product_status)) self.assertEquals("not_subscribed", product_status[0][4])
def test_get_active_no_packages(self): cert = self._create_server_cert() prod_dir = stubs.StubProductDirectory([]) prod_dir.certs.append(cert) inj.provide(inj.PROD_DIR, prod_dir) self.mock_yb.pkgSack.returnPackages.return_value = [] pm = yum_product_id.YumProductManager(self.mock_yb) active = pm.get_active() self.assertEqual(set([]), active)