def test_all_successful(self):
send_mock = Mock()
send_mock.return_value = [self.success_notification, self.success_notification]
FakeEmailJob.build_notifications = send_mock
expected_updates = [call.update(status='started'), call.update(status='success')]
FakeEmailJob().run_job(self.job)
self.assertEquals(self.job.mock_calls, expected_updates)
def test_non_unique_job_unique_key_includes_context(
self, hashlib, random, mock_time, os
):
now = time.time()
random.random.return_value = 1010
os.getpid.return_value = 777
mock_time.time.return_value = now
message = json.dumps({
"module": test_job_func.__module__,
"func": test_job_func.__name__,
"args": ["foo", "bar"],
"kwargs": {"bar": 1234},
})
job = Payload.deserialize(message)
hashlib.md5().assert_has_calls([
call.update(test_job_func.__module__),
call.update(test_job_func.__name__),
call.update("testqueue"),
call.update('foo'),
call.update('bar'),
call.update("bar=1234"),
call.update(str(now)),
call.update('777'),
call.update('1010'),
call.hexdigest()
])
eq_(job.unique_key, hashlib.md5().hexdigest.return_value)
def test_some_failures(self):
send_mock = Mock()
send_mock.return_value = [self.success_notification, self.failure_notification]
FakeEmailJob.build_notifications = send_mock
expected_updates = [
call.update(status='started'),
call.update(status='failed', info='something went wrong!')
]
FakeEmailJob().run_job(self.job)
self.assertEquals(self.job.mock_calls, expected_updates)
def test_some_failures(self):
send_mock = Mock()
send_mock.return_value = [
self.success_notification, self.failure_notification
]
FakeEmailJob.build_notifications = send_mock
expected_updates = [
call.update(status='started'),
call.update(status='failed', info='something went wrong!')
]
FakeEmailJob().run_job(self.job)
self.assertEquals(self.job.mock_calls, expected_updates)
def test_all_successful(self):
send_mock = Mock()
send_mock.return_value = [
self.success_notification, self.success_notification
]
FakeEmailJob.build_notifications = send_mock
expected_updates = [
call.update(status='started'),
call.update(status='success')
]
FakeEmailJob().run_job(self.job)
self.assertEquals(self.job.mock_calls, expected_updates)
def test_update_no_kwargs(self):
mock_db = Mock(name='mock_db')
mock_dbconn = Mock(name='mock_dbconn')
setattr(mock_dbconn, MONGO_DB_NAME, mock_db)
mock_coll = Mock(spec_set=Collection)
setattr(mock_db, COLL_SENSORS, mock_coll)
mock_coll.update.return_value = {
'updatedExisting': True,
'connectionId': 1,
'ok': 1.0,
'err': None,
'n': 1
}
res = update_sensor(mock_dbconn, 'myhost', 'mysensor', 123.45)
data = {
'_id': 'myhost_mysensor',
'host_id': 'myhost',
'sensor_id': 'mysensor',
'last_reading_C': 123.45,
'update_time': datetime(2016, 7, 1, 2, 3, 4)
}
assert_not_twisted_failure(res.result)
assert res.result == 'myhost_mysensor'
assert mock_coll.mock_calls == [
call.update({'_id': 'myhost_mysensor'},
data,
upsert=True,
safe=True)
]
def test_update_overrides_cache(self, mock_set, mock_supports):
mock_supports.return_value = True
repo_settings = {
'enabled': '0',
}
self.invoker.get_repos.return_value = [
Repo('hello', repo_settings.items()),
]
self.repo_file.items.return_value = repo_settings.items()
@api.request_injection
def munge_injection():
self._inject_mock_valid_consumer("123")
return api.enable_yum_repositories('hello')
result = munge_injection()
expected_overrides = [{
'contentLabel': 'hello',
'name': 'enabled',
'value': '1',
}]
self.assertTrue(call("123", expected_overrides) in mock_set.mock_calls)
self.assertTrue(call.update() in self.invoker.mock_calls)
self.assertEquals(1, result)
def test_dict_multi_key(self):
mock = Mock()
class DiffTuple(Diff):
extract_imported = extract_existing = DictExtractor('k', 'k2')
add = mock.add
update = mock.update
delete = mock.delete
a = dict(k='a', k2=0, v=1)
b = dict(k='b', k2=0, v=2)
c = dict(k='c', k2=0, v=3)
c_ = dict(k='c', k2=0, v=4)
d = dict(k='d', k2=0, v=5)
diff = DiffTuple([a, b, c], [b, c_, d])
diff.apply()
compare([
call.delete(('a', 0), a, a),
call.update(('c', 0), c, c, c_, c_),
call.add(('d', 0), d, d),
], mock.mock_calls)
def test_named_tuple(self):
mock = Mock()
X = namedtuple('X', 'foo bar')
Y = namedtuple('Y', 'foo bar')
class DiffTuple(Diff):
extract_imported = extract_existing = NamedTupleExtractor('foo')
add = mock.add
update = mock.update
delete = mock.delete
aX = X('a', 1)
bX = X('b', 2)
cX = X('c', 3)
bY = Y('b', 2)
cY = Y('c', 4)
dY = Y('d', 5)
daX = dict(foo='a', bar=1)
dcX = dict(foo='c', bar=3)
dcY = dict(foo='c', bar=4)
ddY = dict(foo='d', bar=5)
diff = DiffTuple([aX, bX, cX], [bY, cY, dY])
diff.apply()
compare([
call.delete(('a',), aX, daX),
call.update(('c',), cX, dcX, cY, dcY),
call.add(('d', ), dY, ddY),
], mock.mock_calls)
def test_update_no_kwargs(self):
mock_db = Mock(name='mock_db')
mock_dbconn = Mock(name='mock_dbconn')
setattr(mock_dbconn, MONGO_DB_NAME, mock_db)
mock_coll = Mock(spec_set=Collection)
setattr(mock_db, COLL_SENSORS, mock_coll)
mock_coll.update.return_value = {
'updatedExisting': True,
'connectionId': 1,
'ok': 1.0,
'err': None,
'n': 1
}
res = update_sensor(
mock_dbconn,
'myhost',
'mysensor',
123.45
)
data = {
'_id': 'myhost_mysensor',
'host_id': 'myhost',
'sensor_id': 'mysensor',
'last_reading_C': 123.45,
'update_time': datetime(2016, 7, 1, 2, 3, 4)
}
assert_not_twisted_failure(res.result)
assert res.result == 'myhost_mysensor'
assert mock_coll.mock_calls == [
call.update({'_id': 'myhost_mysensor'}, data, upsert=True,
safe=True)
]
def test_removing_subscribers_from_observable_works(mocked_output_service):
expected_calls = [call.update("printed"), call.finished()]
obs = Observable()
obs.add_subscriber(mocked_output_service)
obs.next("printed")
obs.remove_subscriber(mocked_output_service)
obs.next("not displayed")
mocked_output_service.assert_has_calls(expected_calls)
def test(self):
config = Mock()
settings = Mock(changed=False)
gevent.spawn(self.call_it, config, settings, check_interval=0.01)
gevent.sleep(0.05)
self.assertFalse(settings.reload.called)
settings.changed = True
gevent.sleep(0.05)
self.assertTrue(settings.reload.called)
self.assertEqual(config.mock_calls[-1], call.update(settings))
def test(self):
config = Mock()
settings = Mock(changed=False)
gevent.spawn(self.call_it, config, settings, check_interval=0.01)
gevent.sleep(0.05)
self.assertFalse(settings.reload.called)
settings.changed = True
gevent.sleep(0.05)
self.assertTrue(settings.reload.called)
self.assertEqual(config.mock_calls[-1], call.update(settings))
def test_should_update_before_building(self):
out = StringIO()
err = StringIO()
parent_mock = Mock()
build_mock = Mock()
update_mock = Mock()
parent_mock.build = build_mock
parent_mock.update = update_mock
with patch('probes.models.Probes.build_rules', build_mock), patch('rules.models.Ruleset.update', update_mock):
call_command('refreshprobes', '-bu', 'probe1', stdout=out, stderr=err)
parent_mock.assert_has_calls([call.update(), call.build()])
def test_post_actions(self):
mock = Mock()
class DiffTuple(Diff):
def extract_existing(self, obj):
return obj[0], obj
extract_imported = extract_existing
add = mock.add
update = mock.update
delete = mock.delete
post_add = mock.post_add
post_update = mock.post_update
post_delete = mock.post_delete
diff = DiffTuple(
[('a1', 2), ('a2', 2), ('c1', 6), ('c2', 6)],
[('c1', 7), ('c2', 7), ('d1', 8), ('d2', 8)]
)
compare([], mock.mock_calls)
diff.apply()
compare([
call.delete('a1', ('a1', 2), ('a1', 2)),
call.delete('a2', ('a2', 2), ('a2', 2)),
call.post_delete(),
call.update('c1', ('c1', 6), ('c1', 6), ('c1', 7), ('c1', 7)),
call.update('c2', ('c2', 6), ('c2', 6), ('c2', 7), ('c2', 7)),
call.post_update(),
call.add('d1', ('d1', 8), ('d1', 8)),
call.add('d2', ('d2', 8), ('d2', 8)),
call.post_add(),
], mock.mock_calls)
def testChangeListenersCalled(self):
mock_listener = MagicMock(name='listener')
# If should_listen returns True, the listener will not be added to the
# WorkUnit, and will therefor not have its handler triggered on
# updates.
mock_listener.should_listen.return_value = False
test = build_logging.WorkUnit('test')
test.add_change_listener(mock_listener)
# Listeners should be triggered when updates occur anywhere along a WorkUnit
# tree.
child = build_logging.WorkUnit('child')
parent = build_logging.WorkUnit('parent')
parent.add_child(child)
mock_child_listener = MagicMock(name='child_listener')
mock_child_listener.should_listen.return_value = True
mock_parent_listener = MagicMock(name='parent_listener')
mock_parent_listener.should_listen.return_value = True
child.add_change_listener(mock_child_listener)
parent.add_change_listener(mock_parent_listener)
child.total = 100
parent.total = 100
parent.complete = 100
expected_child_calls = [
call.should_listen(child),
call.update(child, 'total', 100)
]
expected_parent_calls = [
call.should_listen(parent),
call.update(parent, 'total', 100),
call.update(parent, 'total', 200),
call.update(parent, 'complete', 100)
]
self.assertTrue(expected_child_calls == mock_child_listener.mock_calls)
self.assertTrue(
expected_parent_calls == mock_parent_listener.mock_calls)
def testChangeListenersCalled(self):
mock_listener = MagicMock(name='listener')
# If should_listen returns True, the listener will not be added to the
# WorkUnit, and will therefor not have its handler triggered on
# updates.
mock_listener.should_listen.return_value = False
test = build_logging.WorkUnit('test')
test.add_change_listener(mock_listener)
# Listeners should be triggered when updates occur anywhere along a WorkUnit
# tree.
child = build_logging.WorkUnit('child')
parent = build_logging.WorkUnit('parent')
parent.add_child(child)
mock_child_listener = MagicMock(name='child_listener')
mock_child_listener.should_listen.return_value = True
mock_parent_listener = MagicMock(name='parent_listener')
mock_parent_listener.should_listen.return_value = True
child.add_change_listener(mock_child_listener)
parent.add_change_listener(mock_parent_listener)
child.total = 100
parent.total = 100
parent.complete = 100
expected_child_calls = [
call.should_listen(child),
call.update(child, 'total', 100)
]
expected_parent_calls = [
call.should_listen(parent),
call.update(parent, 'total', 100),
call.update(parent, 'total', 200),
call.update(parent, 'complete', 100)
]
self.assertTrue(expected_child_calls == mock_child_listener.mock_calls)
self.assertTrue(expected_parent_calls == mock_parent_listener.mock_calls)
def test_tuple(self):
DiffTuple, mock = self.make_differ()
diff = DiffTuple(
[('a', 1, 2), ('b', 3, 4), ('c', 5, 6)],
[('b', 3, 4), ('c', 5, 7), ('d', 7, 8)]
)
compare([], mock.mock_calls)
diff.apply()
compare([
call.delete('a', ('a', 1, 2), ('a', 2)),
call.update('c', ('c', 5, 6), ('c', 6), ('c', 5, 7), ('c', 7)),
call.add('d', ('d', 7, 8), ('d', 8)),
], mock.mock_calls)
def test_unique_job_excludes_context_in_unique_key(self, hashlib):
message = json.dumps({
"module": test_unique_job_func.__module__,
"func": test_unique_job_func.__name__,
"args": ["foo", "bar"],
"kwargs": {"bar": 1234},
})
job = Payload.deserialize(message)
hashlib.md5().assert_has_calls([
call.update(test_unique_job_func.__module__),
call.update(test_unique_job_func.__name__),
call.update("testqueue"),
call.update('foo'),
call.update('bar'),
call.update("bar=1234"),
call.hexdigest()
])
eq_(job.unique_key, hashlib.md5().hexdigest.return_value)
def test_sync(self, load_mock, create_mock):
provider = Ns1Provider('test', 'api-key')
desired = Zone('unit.tests.', [])
for r in self.expected:
desired.add_record(r)
plan = provider.plan(desired)
# everything except the root NS
expected_n = len(self.expected) - 1
self.assertEquals(expected_n, len(plan.changes))
# Fails, general error
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = ResourceException('boom')
with self.assertRaises(ResourceException) as ctx:
provider.apply(plan)
self.assertEquals(load_mock.side_effect, ctx.exception)
# Fails, bad auth
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = \
ResourceException('server error: zone not found')
create_mock.side_effect = AuthException('unauthorized')
with self.assertRaises(AuthException) as ctx:
provider.apply(plan)
self.assertEquals(create_mock.side_effect, ctx.exception)
# non-existant zone, create
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = \
ResourceException('server error: zone not found')
# ugh, need a mock zone with a mock prop since we're using getattr, we
# can actually control side effects on `meth` with that.
mock_zone = Mock()
mock_zone.add_SRV = Mock()
mock_zone.add_SRV.side_effect = [
RateLimitException('boo', period=0),
None,
]
create_mock.side_effect = [mock_zone]
got_n = provider.apply(plan)
self.assertEquals(expected_n, got_n)
# Update & delete
load_mock.reset_mock()
create_mock.reset_mock()
nsone_zone = DummyZone(self.nsone_records + [{
'type': 'A',
'ttl': 42,
'short_answers': ['9.9.9.9'],
'domain': 'delete-me.unit.tests.',
}])
nsone_zone.data['records'][0]['short_answers'][0] = '2.2.2.2'
nsone_zone.loadRecord = Mock()
zone_search = Mock()
zone_search.return_value = [
{
"domain": "geo.unit.tests",
"zone": "unit.tests",
"type": "A",
"answers": [
{'answer': ['1.1.1.1'], 'meta': {}},
{'answer': ['1.2.3.4'],
'meta': {'ca_province': ['ON']}},
{'answer': ['2.3.4.5'], 'meta': {'us_state': ['NY']}},
{'answer': ['3.4.5.6'], 'meta': {'country': ['US']}},
{'answer': ['4.5.6.7'],
'meta': {'iso_region_code': ['NA-US-WA']}},
],
'ttl': 34,
},
]
nsone_zone.search = zone_search
load_mock.side_effect = [nsone_zone, nsone_zone]
plan = provider.plan(desired)
self.assertEquals(3, len(plan.changes))
self.assertIsInstance(plan.changes[0], Update)
self.assertIsInstance(plan.changes[2], Delete)
# ugh, we need a mock record that can be returned from loadRecord for
# the update and delete targets, we can add our side effects to that to
# trigger rate limit handling
mock_record = Mock()
mock_record.update.side_effect = [
RateLimitException('one', period=0),
None,
None,
]
mock_record.delete.side_effect = [
RateLimitException('two', period=0),
None,
None,
]
nsone_zone.loadRecord.side_effect = [mock_record, mock_record,
mock_record]
got_n = provider.apply(plan)
self.assertEquals(3, got_n)
nsone_zone.loadRecord.assert_has_calls([
call('unit.tests', u'A'),
call('geo', u'A'),
call('delete-me', u'A'),
])
mock_record.assert_has_calls([
call.update(answers=[{'answer': [u'1.2.3.4'], 'meta': {}}],
filters=[],
ttl=32),
call.update(answers=[{u'answer': [u'1.2.3.4'], u'meta': {}}],
filters=[],
ttl=32),
call.update(
answers=[
{u'answer': [u'101.102.103.104'], u'meta': {}},
{u'answer': [u'101.102.103.105'], u'meta': {}},
{
u'answer': [u'201.202.203.204'],
u'meta': {
u'iso_region_code': [u'NA-US-NY']
},
},
],
filters=[
{u'filter': u'shuffle', u'config': {}},
{u'filter': u'geotarget_country', u'config': {}},
{u'filter': u'select_first_n', u'config': {u'N': 1}},
],
ttl=34),
call.delete(),
call.delete()
])
def test_sync(self, load_mock, create_mock):
provider = Ns1Provider('test', 'api-key')
desired = Zone('unit.tests.', [])
for r in self.expected:
desired.add_record(r)
plan = provider.plan(desired)
# everything except the root NS
expected_n = len(self.expected) - 1
self.assertEquals(expected_n, len(plan.changes))
# Fails, general error
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = ResourceException('boom')
with self.assertRaises(ResourceException) as ctx:
provider.apply(plan)
self.assertEquals(load_mock.side_effect, ctx.exception)
# Fails, bad auth
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = \
ResourceException('server error: zone not found')
create_mock.side_effect = AuthException('unauthorized')
with self.assertRaises(AuthException) as ctx:
provider.apply(plan)
self.assertEquals(create_mock.side_effect, ctx.exception)
# non-existant zone, create
load_mock.reset_mock()
create_mock.reset_mock()
load_mock.side_effect = \
ResourceException('server error: zone not found')
# ugh, need a mock zone with a mock prop since we're using getattr, we
# can actually control side effects on `meth` with that.
mock_zone = Mock()
mock_zone.add_SRV = Mock()
mock_zone.add_SRV.side_effect = [
RateLimitException('boo', period=0),
None,
]
create_mock.side_effect = [mock_zone]
got_n = provider.apply(plan)
self.assertEquals(expected_n, got_n)
# Update & delete
load_mock.reset_mock()
create_mock.reset_mock()
nsone_zone = DummyZone(self.nsone_records +
[{
'type': 'A',
'ttl': 42,
'short_answers': ['9.9.9.9'],
'domain': 'delete-me.unit.tests.',
}])
nsone_zone.data['records'][0]['short_answers'][0] = '2.2.2.2'
nsone_zone.loadRecord = Mock()
load_mock.side_effect = [nsone_zone, nsone_zone]
plan = provider.plan(desired)
self.assertEquals(2, len(plan.changes))
self.assertIsInstance(plan.changes[0], Update)
self.assertIsInstance(plan.changes[1], Delete)
# ugh, we need a mock record that can be returned from loadRecord for
# the update and delete targets, we can add our side effects to that to
# trigger rate limit handling
mock_record = Mock()
mock_record.update.side_effect = [
RateLimitException('one', period=0),
None,
]
mock_record.delete.side_effect = [
RateLimitException('two', period=0),
None,
]
nsone_zone.loadRecord.side_effect = [mock_record, mock_record]
got_n = provider.apply(plan)
self.assertEquals(2, got_n)
nsone_zone.loadRecord.assert_has_calls([
call('unit.tests', u'A'),
call('delete-me', u'A'),
])
mock_record.assert_has_calls(
[call.update(answers=[u'1.2.3.4'], ttl=32),
call.delete()])
