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_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 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_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, 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 _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_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(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_no_subscriptions_unregister_button_is_blank(self):
cert_dir = StubCertificateDirectory([])
my_subs_tab = MySubscriptionsTab(self.backend,
None,
cert_dir,
StubProductDirectory([]))
self.assertFalse(my_subs_tab.unsubscribe_button.get_property('sensitive'))
def setUp(self):
self.fact_cache_dir = tempfile.mkdtemp()
fact_cache = self.fact_cache_dir + "/facts.json"
fd = open(fact_cache, "w")
fd.write(facts_buf)
fd.close()
self.f = facts.Facts(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
self.f.CACHE_FILE = fact_cache
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 test_unsubscribe_unregistered(self):
connection.UEPConnection = StubUEP
prod = StubProduct('stub_product')
ent = StubEntitlementCertificate(prod)
inj.provide(inj.ENT_DIR, StubEntitlementDirectory([ent]))
inj.provide(inj.PROD_DIR, StubProductDirectory([]))
cmd = managercli.UnSubscribeCommand()
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)
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: False)
StubConsumerIdentity.exists = classmethod(lambda cls: False)
code = cmd.main([
'unsubscribe',
'--serial=%s' % ent1.serial,
'--serial=%s' % ent3.serial
])
self.assertTrue(cmd.entitlement_dir.list_called)
self.assertTrue(ent1.is_deleted)
self.assertFalse(ent2.is_deleted)
self.assertTrue(ent3.is_deleted)
self.assertEquals(code, 0)
code = cmd.main(['unsubscribe', '--serial=%s' % '33333333'])
self.assertEquals(code, 1)
def setUp(self):
self.cc = self.command_class(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
# neuter the _do_command, since this is mostly
# for testing arg parsing
self.cc._do_command = self._do_command
self.cc.assert_should_be_registered = self._asert_should_be_registered
# stub out uep
managercli.connection.UEPConnection = self._uep_connection
sys.stdout = MockStdout()
sys.stderr = MockStderr()
def _stub_content(self):
stub_prod = StubProduct('stub_product', provided_tags="stub-product")
stub_content = StubContent("a_test_repo", required_tags="stub-product")
stub_ent_cert = StubEntitlementCertificate(stub_prod,
content=[stub_content])
stub_prod_cert = StubProductCertificate(stub_prod)
stub_ent_dir = StubEntitlementDirectory([stub_ent_cert])
stub_prod_dir = StubProductDirectory([stub_prod_cert])
inj.provide(inj.ENT_DIR, stub_ent_dir)
inj.provide(inj.PROD_DIR, stub_prod_dir)
def 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])
self.my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, None, self.cert_dir,
StubProductDirectory([]))
def test_installed_products_cache_written(self):
connection.UEPConnection = StubUEP
cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
cmd._persist_identity_cert = self.stub_persist
ConsumerIdentity.exists = classmethod(lambda cls: False)
# Mock out facts and installed products:
cmd.facts.get_facts = Mock(return_value={
'fact1': 'val1',
'fact2': 'val2'
})
cmd.facts.write_cache = Mock()
cmd.installed_mgr.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
self.assertEquals(1, cmd.installed_mgr.write_cache.call_count)
def test_unsubscribe_registered(self):
connection.UEPConnection = StubUEP
cmd = managercli.UnSubscribeCommand(ent_dir=StubEntitlementDirectory(
[]),
prod_dir=StubProductDirectory([]))
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)
serial = '123456'
cmd.main(['unsubscribe', '--serial=%s' % serial])
self.assertEquals(cmd.cp.called_unbind_serial, serial)
def setUp(self):
super(MySubscriptionsTabTest, self).setUp()
self.uep = StubUEP
self.backend = StubBackend()
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod2')
self.cert2 = StubEntitlementCertificate(
StubProduct('product3'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod3')
self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2])
self.my_subs_tab = MySubscriptionsTab(self.backend,
None,
self.cert_dir,
StubProductDirectory([]))
def test_register_persists_consumer_cert(self):
connection.UEPConnection = StubUEP
# When
cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
ConsumerIdentity.exists = classmethod(lambda cls: False)
cmd._persist_identity_cert = self.stub_persist
cmd.facts.get_facts = Mock(return_value={
'fact1': 'val1',
'fact2': 'val2'
})
cmd.facts.write_cache = Mock()
cmd.installed_mgr.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
# Then
self.assertEqual('dummy-consumer-uuid',
self.persisted_consumer["uuid"])
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)
