def test_events_more_limit(self):
"""When events fetched > 100, they are processed in 2 batches."""
events1 = [{
'tenantId': '1234',
'groupId': 'scal44',
'policyId': 'pol4{}'.format(i),
'trigger': 'now',
'cron': None,
'bucket': 1
} for i in range(100)]
events2 = [{
'tenantId': '1235',
'groupId': 'scal54',
'policyId': 'pol4{}'.format(i),
'trigger': 'now',
'cron': None,
'bucket': 1
} for i in range(10)]
self.returns = [events1, events2]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1, 'now',
100)
self.successResultOf(d)
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls,
[mock.call(1, 'now', 100)] * 2)
self.assertEqual(self.process_events.mock_calls, [
mock.call(events1, "disp", self.mock_store, self.log.bind()),
mock.call(events2, "disp", self.mock_store, self.log.bind())
])
def test_no_events(self):
"""
When no events are fetched, they are not processed
"""
d = check_events_in_bucket(self.log, self.mock_store, 1, 'utcnow', 100)
self.successResultOf(d)
self.process_events.assert_called_once_with([], self.mock_store, self.log.bind())
def test_events_batch_error(self):
"""
When error occurs after first batch of events are processed, then it
logs errors and does not try to fetch again.
"""
events = [{
'tenantId': '1234',
'groupId': 'scal44',
'policyId': 'pol4{}'.format(i),
'trigger': 'now',
'cron': None,
'bucket': 1
} for i in range(100)]
self.returns = [events, ValueError('some')]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1, 'now',
100)
self.successResultOf(d)
self.log.bind.return_value.err.assert_called_once_with(
CheckFailure(ValueError))
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls,
[mock.call(1, 'now', 100)] * 2)
self.process_events.assert_called_once_with(events, "disp",
self.mock_store,
self.log.bind())
def test_fetch_called(self):
"""
`fetch_and_delete` called correctly
"""
d = check_events_in_bucket(self.log, self.mock_store, 1, 'utcnow', 100)
self.successResultOf(d)
self.mock_store.fetch_and_delete.assert_called_once_with(1, 'utcnow', 100)
self.log.bind.assert_called_once_with(bucket=1)
def test_no_events(self):
"""When no events are fetched, they are not processed."""
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1,
'utcnow', 100)
self.successResultOf(d)
self.process_events.assert_called_once_with([], "disp",
self.mock_store,
self.log.bind())
def test_fetch_called(self):
"""
`fetch_and_delete` called correctly
"""
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1,
'utcnow', 100)
self.successResultOf(d)
self.mock_store.fetch_and_delete.assert_called_once_with(
1, 'utcnow', 100)
self.log.bind.assert_called_once_with(bucket=1)
def test_events_process_error(self):
"""
error is logged if `process_events` returns error
"""
self.returns = [ValueError('e')]
d = check_events_in_bucket(self.log, self.mock_store, 1, 'now', 100)
self.successResultOf(d)
self.log.bind.return_value.err.assert_called_once_with(CheckFailure(ValueError))
self.assertFalse(self.process_events.called)
def test_events_process_error(self):
"""
Error is logged if `process_events` returns error.
"""
self.returns = [ValueError('e')]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1,
'utcnow', 100)
self.successResultOf(d)
self.log.bind.return_value.err.assert_called_once_with(
CheckFailure(ValueError))
self.assertFalse(self.process_events.called)
def test_events_in_limit(self):
"""
When events fetched < 100, they are processed
"""
events = [{'tenantId': '1234', 'groupId': 'scal44', 'policyId': 'pol4{}'.format(i),
'trigger': 'now', 'cron': None, 'bucket': 1} for i in range(10)]
self.returns = [events]
d = check_events_in_bucket(self.log, self.mock_store, 1, 'utcnow', 100)
self.successResultOf(d)
# Ensure fetch_and_delete and process_events is called only once
self.mock_store.fetch_and_delete.assert_called_once_with(1, 'utcnow', 100)
self.process_events.assert_called_once_with(events, self.mock_store, self.log.bind())
def test_events_batch_process(self):
"""
When events fetched > 100, they are processed in batches until all
events are processed
"""
events1 = [
{
"tenantId": "1234",
"groupId": "scal44",
"policyId": "pol4{}".format(i),
"trigger": "now",
"cron": None,
"bucket": 1,
}
for i in range(100)
]
events2 = [
{
"tenantId": "1235",
"groupId": "scal54",
"policyId": "pol4{}".format(i),
"trigger": "now",
"cron": None,
"bucket": 1,
}
for i in range(100)
]
events3 = [
{
"tenantId": "1236",
"groupId": "scal64",
"policyId": "pol4{}".format(i),
"trigger": "now",
"cron": None,
"bucket": 1,
}
for i in range(10)
]
self.returns = [events1, events2, events3]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1, "now", 100)
self.successResultOf(d)
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls, [mock.call(1, "now", 100)] * 3)
self.assertEqual(
self.process_events.mock_calls,
[mock.call(events, "disp", self.mock_store, self.log.bind()) for events in [events1, events2, events3]],
)
def test_events_batch_error(self):
"""
When error occurs after first batch of events are processed, then it
logs errors and does not try to fetch again
"""
events = [{'tenantId': '1234', 'groupId': 'scal44', 'policyId': 'pol4{}'.format(i),
'trigger': 'now', 'cron': None, 'bucket': 1} for i in range(100)]
self.returns = [events, ValueError('some')]
d = check_events_in_bucket(self.log, self.mock_store, 1, 'now', 100)
self.successResultOf(d)
self.log.bind.return_value.err.assert_called_once_with(CheckFailure(ValueError))
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls,
[mock.call(1, 'now', 100)] * 2)
self.process_events.assert_called_once_with(events, self.mock_store,
self.log.bind())
def test_events_more_limit(self):
"""
When events fetched > 100, they are processed in 2 batches
"""
events1 = [{'tenantId': '1234', 'groupId': 'scal44', 'policyId': 'pol4{}'.format(i),
'trigger': 'now', 'cron': None, 'bucket': 1} for i in range(100)]
events2 = [{'tenantId': '1235', 'groupId': 'scal54', 'policyId': 'pol4{}'.format(i),
'trigger': 'now', 'cron': None, 'bucket': 1} for i in range(10)]
self.returns = [events1, events2]
d = check_events_in_bucket(self.log, self.mock_store, 1, 'now', 100)
self.successResultOf(d)
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls,
[mock.call(1, 'now', 100)] * 2)
self.assertEqual(self.process_events.mock_calls,
[mock.call(events1, self.mock_store, self.log.bind()),
mock.call(events2, self.mock_store, self.log.bind())])
def test_events_in_limit(self):
"""
When events fetched < 100, they are processed
"""
events = [
{
"tenantId": "1234",
"groupId": "scal44",
"policyId": "pol4{}".format(i),
"trigger": "now",
"cron": None,
"bucket": 1,
}
for i in range(10)
]
self.returns = [events]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1, "utcnow", 100)
self.successResultOf(d)
# Ensure fetch_and_delete and process_events is called only once
self.mock_store.fetch_and_delete.assert_called_once_with(1, "utcnow", 100)
self.process_events.assert_called_once_with(events, "disp", self.mock_store, self.log.bind())
def test_events_in_limit(self):
"""
When events fetched < 100, they are processed
"""
events = [{
'tenantId': '1234',
'groupId': 'scal44',
'policyId': 'pol4{}'.format(i),
'trigger': 'now',
'cron': None,
'bucket': 1
} for i in range(10)]
self.returns = [events]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1,
'utcnow', 100)
self.successResultOf(d)
# Ensure fetch_and_delete and process_events is called only once
self.mock_store.fetch_and_delete.assert_called_once_with(
1, 'utcnow', 100)
self.process_events.assert_called_once_with(events, "disp",
self.mock_store,
self.log.bind())
def test_events_batch_error(self):
"""
When error occurs after first batch of events are processed, then it
logs errors and does not try to fetch again.
"""
events = [
{
"tenantId": "1234",
"groupId": "scal44",
"policyId": "pol4{}".format(i),
"trigger": "now",
"cron": None,
"bucket": 1,
}
for i in range(100)
]
self.returns = [events, ValueError("some")]
d = check_events_in_bucket(self.log, "disp", self.mock_store, 1, "now", 100)
self.successResultOf(d)
self.log.bind.return_value.err.assert_called_once_with(CheckFailure(ValueError))
self.assertEqual(self.mock_store.fetch_and_delete.mock_calls, [mock.call(1, "now", 100)] * 2)
self.process_events.assert_called_once_with(events, "disp", self.mock_store, self.log.bind())
