async def test_update_status_no_data_returned(self):
persistence = MagicMock()
persistence.get.return_value = test_utilities.awaitable(None)
work_description = wd.WorkDescription(persistence, old_data)
with self.assertRaises(wd.EmptyWorkDescriptionError):
await work_description.update()
def test_constructor(self):
persistence = MagicMock()
work_description = wd.WorkDescription(persistence, input_data)
self.assertEqual(work_description.outbound_status,
wd.MessageStatus.OUTBOUND_MESSAGE_PREPARED)
self.assertEqual(work_description.version, 1)
self.assertEqual(work_description.created_timestamp, '11:59')
self.assertEqual(work_description.last_modified_timestamp, '12:00')
async def test_publish_saves_new_data(self):
future = test_utilities.awaitable(old_data)
persistence = MagicMock()
persistence.add.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
await work_description.publish()
persistence.add.assert_called_with(input_data[wd.MESSAGE_ID],
input_data)
async def test_publish_update_latest_is_none(self, time_mock):
time_mock.return_value = '12:00'
future = test_utilities.awaitable(None)
persistence = MagicMock()
persistence.get.return_value = future
persistence.add.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
await work_description.publish()
persistence.add.assert_called_with(input_data[wd.DATA_KEY], input_data)
def test_constructor(self):
persistence = MagicMock()
work_description = wd.WorkDescription(persistence, input_data)
self.assertEqual(work_description.message_id,
input_data[wd.MESSAGE_ID])
self.assertEqual(work_description.workflow, input_data[wd.WORKFLOW])
self.assertEqual(work_description.inbound_status,
input_data[wd.INBOUND_STATUS])
self.assertEqual(work_description.outbound_status,
input_data[wd.OUTBOUND_STATUS])
self.assertEqual(work_description.created_timestamp,
input_data[wd.CREATED_TIMESTAMP])
async def test_set_inbound_status(self, time_mock):
time_mock.return_value = '12:00'
future = test_utilities.awaitable(old_data)
persistence = MagicMock()
persistence.get.return_value = future
persistence.add.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
new_data = copy.deepcopy(input_data)
new_data[wd.DATA][
wd.INBOUND_STATUS] = wd.MessageStatus.INBOUND_RESPONSE_FAILED
await work_description.set_inbound_status(
wd.MessageStatus.INBOUND_RESPONSE_FAILED)
persistence.add.assert_called_with(input_data[wd.DATA_KEY], new_data)
async def test_out_of_date_version(self):
future = test_utilities.awaitable({
wd.DATA_KEY: 'aaa-aaa-aaa',
wd.DATA: {
wd.VERSION_KEY: 3,
wd.LATEST_TIMESTAMP: '11:00',
wd.OUTBOUND_STATUS: wd.MessageStatus.OUTBOUND_MESSAGE_PREPARED
}
})
persistence = MagicMock()
persistence.get.return_value = future
persistence.add.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
with self.assertRaises(wd.OutOfDateVersionError):
await work_description.publish()
async def test_set_inbound_status(self):
updated_data = copy.deepcopy(input_data)
updated_data[
wd.INBOUND_STATUS] = wd.MessageStatus.INBOUND_RESPONSE_FAILED
future = test_utilities.awaitable(updated_data)
persistence = MagicMock()
persistence.update.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
await work_description.set_inbound_status(
wd.MessageStatus.INBOUND_RESPONSE_FAILED)
persistence.update.assert_called_with(
input_data[wd.MESSAGE_ID],
{wd.INBOUND_STATUS: wd.MessageStatus.INBOUND_RESPONSE_FAILED})
self.assertEqual(work_description.inbound_status,
wd.MessageStatus.INBOUND_RESPONSE_FAILED)
async def test_update_status(self):
new_data = {
wd.DATA_KEY: 'aaa-aaa-aaa',
wd.DATA: {
wd.CREATED_TIMESTAMP: '11:59',
wd.LATEST_TIMESTAMP: '13:00',
wd.VERSION_KEY: 1,
wd.INBOUND_STATUS: None,
wd.OUTBOUND_STATUS: wd.MessageStatus.OUTBOUND_MESSAGE_ACKD,
wd.WORKFLOW: workflow.SYNC
}
}
persistence = MagicMock()
persistence.get.return_value = test_utilities.awaitable(new_data)
work_description = wd.WorkDescription(persistence, old_data)
await work_description.update()
self.assertEqual(work_description.version, 1)
self.assertEqual(work_description.outbound_status,
wd.MessageStatus.OUTBOUND_MESSAGE_ACKD)
self.assertEqual(work_description.last_modified_timestamp, '13:00')
async def test_auto_increase_version(self, time_mock):
time_mock.return_value = '12:00'
future = test_utilities.awaitable({
wd.DATA_KEY: 'aaa-aaa-aaa',
wd.DATA: {
wd.VERSION_KEY: 1,
wd.LATEST_TIMESTAMP: '11:00',
wd.OUTBOUND_STATUS: wd.MessageStatus.OUTBOUND_MESSAGE_PREPARED,
}
})
persistence = MagicMock()
persistence.get.return_value = future
persistence.add.return_value = future
work_description = wd.WorkDescription(persistence, input_data)
await work_description.publish()
updated = copy.deepcopy(input_data)
updated[wd.DATA][wd.VERSION_KEY] = 2
# Check local version updated
self.assertEqual(work_description.version, 2)
persistence.add.assert_called_with('aaa-aaa-aaa', updated)
async def test_deserialize(self):
new_data = {
wd.DATA_KEY: 'aaa-aaa-aaa',
wd.DATA: {
wd.CREATED_TIMESTAMP: '12:00',
wd.LATEST_TIMESTAMP: '13:00',
wd.VERSION_KEY: 1,
wd.INBOUND_STATUS: wd.MessageStatus.INBOUND_RESPONSE_FAILED,
wd.OUTBOUND_STATUS: wd.MessageStatus.OUTBOUND_MESSAGE_ACKD,
wd.WORKFLOW: workflow.SYNC_ASYNC
}
}
work_description = wd.WorkDescription(MagicMock(), old_data)
work_description._deserialize_data(new_data)
self.assertEqual(work_description.version, 1)
self.assertEqual(work_description.created_timestamp, '12:00')
self.assertEqual(work_description.last_modified_timestamp, '13:00')
self.assertEqual(work_description.inbound_status,
wd.MessageStatus.INBOUND_RESPONSE_FAILED)
self.assertEqual(work_description.outbound_status,
wd.MessageStatus.OUTBOUND_MESSAGE_ACKD)
self.assertEqual(work_description.workflow, workflow.SYNC_ASYNC)
def test_null_persistence(self):
with self.assertRaises(ValueError):
wd.WorkDescription(None, {'None': 'None'})
