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