def test_update(self):
# Setup
self.populate()
# Test
unit_key = dict(name='zsh')
unit = dict(type_id='rpm', unit_key=unit_key)
units = [unit,]
options = dict(importkeys=True)
itineraries = consumer_group_content_update_itinerary(self.GROUP_ID, units, options)
self.assertEqual(len(itineraries), 2)
for itinerary in itineraries:
call_report = self.coordinator.execute_call_asynchronously(itinerary)
# Verify
self.assertNotEqual(call_report.state, dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual bind)
self.run_next()
# verify agent called
mock_agent.Content.update.assert_called_with(units, options)
# simulated asynchronous task result
report = DispatchReport()
report.details = {'A':1}
self.coordinator.complete_call_success(call_report.call_request_id, report.dict())
# verify result
call_report = self.coordinator.find_call_reports(call_request_id=call_report.call_request_id)[0]
self.assertEqual(call_report.state, dispatch_constants.CALL_FINISHED_STATE)
self.assertTrue(call_report.result['succeeded'])
self.assertEqual(call_report.result['details'], report.details)
self.assertEqual(call_report.result['reboot'], report.reboot)
def test_bind(self):
# Setup
self.populate()
# Test
options = {}
itinerary = bind_itinerary(
self.CONSUMER_ID,
self.REPO_ID,
self.DISTRIBUTOR_ID,
self.NOTIFY_AGENT,
self.BINDING_CONFIG,
options)
call_reports = self.coordinator.execute_multiple_calls(itinerary)
# Verify
self.assertEqual(len(call_reports), 2)
self.assertEqual(call_reports[0].call_request_tags, self.BIND_TAGS)
self.assertEqual(call_reports[1].call_request_tags, self.AGENT_BIND_TAGS)
for call in call_reports:
self.assertNotEqual(call.state, dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual bind)
self.run_next()
# verify bind created
manager = factory.consumer_bind_manager()
binds = manager.find_by_consumer(self.CONSUMER_ID)
self.assertEquals(len(binds), 1)
bind = binds[0]
self.assertEqual(bind['consumer_id'], self.CONSUMER_ID)
self.assertEqual(bind['repo_id'], self.REPO_ID)
self.assertEqual(bind['distributor_id'], self.DISTRIBUTOR_ID)
self.assertEqual(bind['notify_agent'], self.NOTIFY_AGENT)
self.assertEqual(bind['binding_config'], self.BINDING_CONFIG)
# run task #2 (notify consumer)
self.run_next()
# verify pending consumer request (pending)
request_id = call_reports[1].call_request_id
bind = manager.get_bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.BIND)
self.assertEqual(actions[0]['status'], Bind.Status.PENDING)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
# verify agent notified
self.assertTrue(mock_agent.Consumer.bind.called)
# simulated asynchronous task result
report = DispatchReport()
self.coordinator.complete_call_success(request_id, report.dict())
# verify pending consumer request (confirmed)
manager = factory.consumer_bind_manager()
bind = manager.get_bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
self.assertEqual(len(bind['consumer_actions']), 0)
def dispatch(*args):
# test json serialization
for a in args:
json.dumps(a)
# return a dispatch report
r = DispatchReport()
return r.dict()
def dispatch(*args):
# test json serialization
for a in args:
json.dumps(a)
# return a dispatch report
r = DispatchReport()
return r.dict()
def test_bind(self):
# Setup
self.populate()
# Test
options = {}
itinerary = bind_itinerary(
self.CONSUMER_ID,
self.REPO_ID,
self.DISTRIBUTOR_ID,
self.NOTIFY_AGENT,
self.BINDING_CONFIG,
options)
call_reports = self.coordinator.execute_multiple_calls(itinerary)
# Verify
self.assertEqual(len(call_reports), 2)
self.assertEqual(call_reports[0].call_request_tags, self.BIND_TAGS)
self.assertEqual(call_reports[1].call_request_tags, self.AGENT_BIND_TAGS)
for call in call_reports:
self.assertNotEqual(call.state, dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual bind)
self.run_next()
# verify bind created
manager = factory.consumer_bind_manager()
binds = manager.find_by_consumer(self.CONSUMER_ID)
self.assertEquals(len(binds), 1)
bind = binds[0]
self.assertEqual(bind['consumer_id'], self.CONSUMER_ID)
self.assertEqual(bind['repo_id'], self.REPO_ID)
self.assertEqual(bind['distributor_id'], self.DISTRIBUTOR_ID)
self.assertEqual(bind['notify_agent'], self.NOTIFY_AGENT)
self.assertEqual(bind['binding_config'], self.BINDING_CONFIG)
# run task #2 (notify consumer)
self.run_next()
# verify pending consumer request (pending)
request_id = call_reports[1].call_request_id
bind = manager.get_bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.BIND)
self.assertEqual(actions[0]['status'], Bind.Status.PENDING)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
# verify agent notified
self.assertTrue(mock_agent.Consumer.bind.called)
# simulated asynchronous task result
report = DispatchReport()
self.coordinator.complete_call_success(request_id, report.dict())
# verify pending consumer request (confirmed)
manager = factory.consumer_bind_manager()
bind = manager.get_bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
self.assertEqual(len(bind['consumer_actions']), 0)
def test_update(self):
# Setup
self.populate()
# Test
unit_key = dict(name='zsh')
unit = dict(type_id='rpm', unit_key=unit_key)
units = [
unit,
]
options = dict(importkeys=True)
itineraries = consumer_group_content_update_itinerary(
self.GROUP_ID, units, options)
self.assertEqual(len(itineraries), 2)
for itinerary in itineraries:
call_report = self.coordinator.execute_call_asynchronously(
itinerary)
# Verify
self.assertNotEqual(call_report.state,
dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual bind)
self.run_next()
# verify agent called
mock_agent.Content.update.assert_called_with(units, options)
# simulated asynchronous task result
report = DispatchReport()
report.details = {'A': 1}
self.coordinator.complete_call_success(call_report.call_request_id,
report.dict())
# verify result
call_report = self.coordinator.find_call_reports(
call_request_id=call_report.call_request_id)[0]
self.assertEqual(call_report.state,
dispatch_constants.CALL_FINISHED_STATE)
self.assertTrue(call_report.result['succeeded'])
self.assertEqual(call_report.result['details'], report.details)
self.assertEqual(call_report.result['reboot'], report.reboot)
def test_unbind_failed_on_consumer(self):
# Setup
self.populate()
manager = factory.consumer_bind_manager()
bind = manager.bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID,
self.NOTIFY_AGENT, self.BINDING_CONFIG)
# Test
options = {}
itinerary = unbind_itinerary(
self.CONSUMER_ID,
self.REPO_ID,
self.DISTRIBUTOR_ID,
options)
call_reports = self.coordinator.execute_multiple_calls(itinerary)
# Verify
self.assertEqual(len(call_reports), 3)
for call in call_reports:
self.assertNotEqual(call.state, dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual unbind)
self.run_next()
# verify bind marked deleted
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind['deleted'])
# run task #2 (notify consumer)
self.run_next()
# verify agent notified
self.assertTrue(mock_agent.Consumer.unbind.called)
# verify consumer request (pending)
request_id = call_reports[1].call_request_id
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind is not None)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.UNBIND)
self.assertEqual(actions[0]['status'], Bind.Status.PENDING)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
# simulated asynchronous task result
report = DispatchReport()
report.succeeded = False
self.coordinator.complete_call_success(request_id, report.dict())
# verify not found (marked deleted)
binds = manager.find_by_consumer(self.CONSUMER_ID)
self.assertEquals(len(binds), 0)
# run task #3 (bind actually deleted)
self.run_next()
# verify bind not deleted
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind is not None)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.UNBIND)
self.assertEqual(actions[0]['status'], Bind.Status.FAILED)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
def uninstall(self, units, options):
report = DispatchReport()
report.details = \
dict(units=units, options=options)
return (202, report.dict())
def update(self, units, options):
report = DispatchReport()
report.details = \
dict(units=units, options=options)
return report.dict()
def test_unbind_failed_on_consumer(self):
# Setup
self.populate()
manager = factory.consumer_bind_manager()
bind = manager.bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID,
self.NOTIFY_AGENT, self.BINDING_CONFIG)
# Test
options = {}
itinerary = unbind_itinerary(
self.CONSUMER_ID,
self.REPO_ID,
self.DISTRIBUTOR_ID,
options)
call_reports = self.coordinator.execute_multiple_calls(itinerary)
# Verify
self.assertEqual(len(call_reports), 3)
for call in call_reports:
self.assertNotEqual(call.state, dispatch_constants.CALL_REJECTED_RESPONSE)
# run task #1 (actual unbind)
self.run_next()
# verify bind marked deleted
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind['deleted'])
# run task #2 (notify consumer)
self.run_next()
# verify agent notified
self.assertTrue(mock_agent.Consumer.unbind.called)
# verify consumer request (pending)
request_id = call_reports[1].call_request_id
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind is not None)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.UNBIND)
self.assertEqual(actions[0]['status'], Bind.Status.PENDING)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
# simulated asynchronous task result
report = DispatchReport()
report.succeeded = False
self.coordinator.complete_call_success(request_id, report.dict())
# verify not found (marked deleted)
binds = manager.find_by_consumer(self.CONSUMER_ID)
self.assertEquals(len(binds), 0)
# run task #3 (bind actually deleted)
self.run_next()
# verify bind not deleted
collection = Bind.get_collection()
bind = collection.find_one(self.QUERY)
self.assertTrue(bind is not None)
actions = bind['consumer_actions']
self.assertEqual(len(actions), 1)
self.assertEqual(actions[0]['id'], request_id)
self.assertEqual(actions[0]['action'], Bind.Action.UNBIND)
self.assertEqual(actions[0]['status'], Bind.Status.FAILED)
self.assertTrue(isinstance(actions[0]['timestamp'], float))
