class BindRequestTests(unittest.TestCase):
def setUp(self):
self.cp = UEPConnection(username="******", password="******", insecure=True)
consumerInfo = self.cp.registerConsumer("test-consumer", "system", owner="admin")
self.consumer_uuid = consumerInfo['uuid']
@patch.object(Restlib, 'validateResponse')
@patch('rhsm.connection.drift_check', return_value=False)
@patch('httplib.HTTPSConnection', auto_spec=True)
def test_bind_no_args(self, mock_conn, mock_drift, mock_validate):
self.cp.bind(self.consumer_uuid)
# verify we called request() with kwargs that include 'body' as None
# Specifically, we are checking that passing in "" to post_request, as
# it does by default, results in None here. bin() passes no args there
# so we use the default, "". See bz #907536
for (name, args, kwargs) in mock_conn.mock_calls:
if name == '().request':
self.assertEqual(None, kwargs['body'])
@patch.object(Restlib, 'validateResponse')
@patch('rhsm.connection.drift_check', return_value=False)
@patch('httplib.HTTPSConnection', auto_spec=True)
def test_bind_by_pool(self, mock_conn, mock_drift, mock_validate):
# this test is just to verify we make the httplib connection with
# right args, we don't validate the bind here
self.cp.bindByEntitlementPool(self.consumer_uuid, '123121111', '1')
for (name, args, kwargs) in mock_conn.mock_calls:
if name == '().request':
self.assertEqual(None, kwargs['body'])
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cp = UEPConnection(username="******", password="******",
insecure=True)
consumerInfo = self.cp.registerConsumer("test-consumer", "system", owner="admin")
self.consumer_uuid = consumerInfo['uuid']
def test_supports_resource(self):
self.assertTrue(self.cp.supports_resource('consumers'))
self.assertTrue(self.cp.supports_resource('admin'))
self.assertFalse(self.cp.supports_resource('boogity'))
def test_update_consumer_can_update_guests_with_empty_list(self):
self.cp.updateConsumer(self.consumer_uuid, guest_uuids=[])
def test_update_consumer_can_update_facts_with_empty_dict(self):
self.cp.updateConsumer(self.consumer_uuid, facts={})
def test_update_consumer_can_update_installed_products_with_empty_list(self):
self.cp.updateConsumer(self.consumer_uuid, installed_products=[])
def tearDown(self):
self.cp.unregisterConsumer(self.consumer_uuid)
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cp = UEPConnection(username="******",
password="******",
insecure=True)
consumerInfo = self.cp.registerConsumer("test-consumer",
"system",
owner="admin")
self.consumer_uuid = consumerInfo['uuid']
def test_supports_resource(self):
self.assertTrue(self.cp.supports_resource('consumers'))
self.assertTrue(self.cp.supports_resource('admin'))
self.assertFalse(self.cp.supports_resource('boogity'))
def test_update_consumer_can_update_guests_with_empty_list(self):
self.cp.updateConsumer(self.consumer_uuid, guest_uuids=[])
def test_update_consumer_can_update_facts_with_empty_dict(self):
self.cp.updateConsumer(self.consumer_uuid, facts={})
def test_update_consumer_can_update_installed_products_with_empty_list(
self):
self.cp.updateConsumer(self.consumer_uuid, installed_products=[])
def tearDown(self):
self.cp.unregisterConsumer(self.consumer_uuid)
class EntitlementRegenerationTests(unittest.TestCase):
def setUp(self):
self.cp = UEPConnection(username="******", password="******", insecure=True)
self.consumer = self.cp.registerConsumer("test-consumer", "system", owner="admin")
self.consumer_uuid = self.consumer['uuid']
# This product is present in the Candlepin test data
self.cp.bindByProduct(self.consumer_uuid, ["awesomeos-instancebased"])
entitlements = self.cp.getEntitlementList(self.consumer_uuid)
self.assertTrue(len(entitlements) > 0)
self.entitlement = entitlements[0]
self.entitlement_id = self.entitlement['id']
def test_regenerate_entitlements_default(self):
result = self.cp.regenEntitlementCertificates(self.consumer_uuid)
self.assertTrue(result)
def test_regenerate_entitlements_lazy(self):
result = self.cp.regenEntitlementCertificates(self.consumer_uuid, True)
self.assertTrue(result)
def test_regenerate_entitlements_eager(self):
result = self.cp.regenEntitlementCertificates(self.consumer_uuid, False)
self.assertTrue(result)
def test_regenerate_entitlements_bad_uuid(self):
result = self.cp.regenEntitlementCertificates("bad_consumer_uuid")
self.assertFalse(result)
def test_regenerate_entitlement_default(self):
result = self.cp.regenEntitlementCertificate(self.consumer_uuid, self.entitlement_id)
self.assertTrue(result)
def test_regenerate_entitlement_lazy(self):
result = self.cp.regenEntitlementCertificate(self.consumer_uuid, self.entitlement_id, True)
self.assertTrue(result)
def test_regenerate_entitlement_eager(self):
result = self.cp.regenEntitlementCertificate(self.consumer_uuid, self.entitlement_id, False)
self.assertTrue(result)
def test_regenerate_entitlement_bad_consumer_uuid(self):
result = self.cp.regenEntitlementCertificate("bad_consumer_uuid", self.entitlement_id)
self.assertFalse(result)
def test_regenerate_entitlement_bad_entitlement_id(self):
result = self.cp.regenEntitlementCertificate(self.consumer_uuid, "bad_entitlement_id")
self.assertFalse(result)
def tearDown(self):
self.cp.unregisterConsumer(self.consumer_uuid)
class CandlepinConnection():
def getOwners(self):
return self.cp.getOwnerList(self.username)
def __init__(self):
self.conn_username = "******"
self.owner = "admin"
self.cp = UEPConnection(username=self.conn_username, password="******",
host="localhost", ssl_port=8443,
handler="/candlepin", insecure=True)
def createConsumer(self, name, facts, installed_products):
consumer = self.cp.registerConsumer(name=name, facts=facts, owner=self.owner, installed_products=installed_products)
print "created consumer with uuid %s. binding.." % consumer['uuid']
self.cp.bind(consumer['uuid'], entitle_date=datetime.now())
print "bind complete"
self.cp.checkin(consumer['uuid'])
return consumer['uuid']
def updateConsumer(self, uuid, facts, installed_products):
self.cp.updateConsumer(uuid, facts=facts, installed_products=installed_products)
self.cp.checkin(uuid)
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cp = UEPConnection(username="******", password="******", insecure=True)
self.consumer = self.cp.registerConsumer("test-consumer", "system", owner="admin")
self.consumer_uuid = self.consumer['uuid']
def test_supports_resource(self):
self.assertTrue(self.cp.supports_resource('consumers'))
self.assertTrue(self.cp.supports_resource('admin'))
self.assertFalse(self.cp.supports_resource('boogity'))
def test_has_capability(self):
self.cp.capabilities = ['cores', 'hypervisors_async']
self.assertTrue(self.cp.has_capability('cores'))
self.assertFalse(self.cp.has_capability('boogityboo'))
def test_update_consumer_can_update_guests_with_empty_list(self):
self.cp.updateConsumer(self.consumer_uuid, guest_uuids=[])
def test_update_consumer_can_update_facts_with_empty_dict(self):
self.cp.updateConsumer(self.consumer_uuid, facts={})
def test_update_consumer_can_update_installed_products_with_empty_list(self):
self.cp.updateConsumer(self.consumer_uuid, installed_products=[])
def test_update_consumer_sets_hypervisor_id(self):
testing_hypervisor_id = random_string("testHypervisor")
self.cp.updateConsumer(self.consumer_uuid, hypervisor_id=testing_hypervisor_id)
hypervisor_id = self.cp.getConsumer(self.consumer_uuid)['hypervisorId']
# Hypervisor ID should be set and lower case
expected = testing_hypervisor_id.lower()
self.assertEqual(expected, hypervisor_id['hypervisorId'])
def test_create_consumer_sets_hypervisor_id(self):
testing_hypervisor_id = random_string("someId")
consumerInfo = self.cp.registerConsumer("other-test-consumer",
"system", owner="admin", hypervisor_id=testing_hypervisor_id)
# Unregister before making assertions, that way it should always happen
self.cp.unregisterConsumer(consumerInfo['uuid'])
# Hypervisor ID should be set and lower case
expected = testing_hypervisor_id.lower()
self.assertEqual(expected, consumerInfo['hypervisorId']['hypervisorId'])
def test_add_single_guest_id_string(self):
testing_guest_id = random_string("guestid")
self.cp.addOrUpdateGuestId(self.consumer_uuid, testing_guest_id)
guestIds = self.cp.getGuestIds(self.consumer_uuid)
self.assertEqual(1, len(guestIds))
def test_add_single_guest_id(self):
testing_guest_id = random_string("guestid")
guest_id_object = {"guestId": testing_guest_id, "attributes": {"some attr": "some value"}}
self.cp.addOrUpdateGuestId(self.consumer_uuid, guest_id_object)
guestId = self.cp.getGuestId(self.consumer_uuid, testing_guest_id)
# This check seems silly...
self.assertEqual(testing_guest_id, guestId['guestId'])
self.assertEqual('some value', guestId['attributes']['some attr'])
def test_remove_single_guest_id(self):
testing_guest_id = random_string("guestid")
self.cp.addOrUpdateGuestId(self.consumer_uuid, testing_guest_id)
guestIds = self.cp.getGuestIds(self.consumer_uuid)
self.assertEqual(1, len(guestIds))
# Delete the guestId
self.cp.removeGuestId(self.consumer_uuid, testing_guest_id)
# Check that no guestIds exist anymore
guestIds = self.cp.getGuestIds(self.consumer_uuid)
self.assertEqual(0, len(guestIds))
def test_update_single_guest_id(self):
testing_guest_id = random_string("guestid")
guest_id_object = {"guestId": testing_guest_id, "attributes": {"some attr": "some value"}}
self.cp.addOrUpdateGuestId(self.consumer_uuid, guest_id_object)
guestId = self.cp.getGuestId(self.consumer_uuid, testing_guest_id)
# check the guestId was created and has the expected attribute
self.assertEqual('some value', guestId['attributes']['some attr'])
guest_id_object['attributes']['some attr'] = 'crazy new value'
self.cp.addOrUpdateGuestId(self.consumer_uuid, guest_id_object)
guestId = self.cp.getGuestId(self.consumer_uuid, testing_guest_id)
# Verify there's still only one guestId
guestIds = self.cp.getGuestIds(self.consumer_uuid)
self.assertEqual(1, len(guestIds))
# Check that the attribute has changed
self.assertEqual('crazy new value', guestId['attributes']['some attr'])
def test_get_owner_hypervisors(self):
testing_hypervisor_id = random_string("testHypervisor")
self.cp.updateConsumer(self.consumer_uuid, hypervisor_id=testing_hypervisor_id)
self.cp.getConsumer(self.consumer_uuid)['hypervisorId']
hypervisors = self.cp.getOwnerHypervisors("admin", [testing_hypervisor_id])
self.assertEqual(1, len(hypervisors))
self.assertEqual(self.consumer_uuid, hypervisors[0]['uuid'])
def tearDown(self):
self.cp.unregisterConsumer(self.consumer_uuid)
