def get_doc_returner(style, ds_name):
strategy = MagicMock()
if style == 'cycle':
strategy.data = {"groups": yaml.safe_load(tdgm._CYCLE_GROUPS_YAML)}
elif style == 'clean':
strategy.data = {"groups": yaml.safe_load(tdgm._GROUPS_YAML)}
def doc_returner(revision_id, rendered, **filters):
if not revision_id == 99:
doc = filters['metadata.name']
if doc == 'deployment-configuration':
dc = MagicMock()
dc.data = {
"physical_provisioner": {
"deployment_strategy": ds_name
},
"armada": {
"manifest": "full-site"
}
}
# if passed a name of 'defaulted' clear the section
if ds_name == 'defaulted':
dc.data["physical_provisioner"] = None
print(dc.__dict__)
return [dc]
elif doc == 'dep-strat':
return [strategy]
return []
return doc_returner
def test_that_it_emits_quorum_status_events(self, client):
new = MagicMock()
old = MagicMock()
old.data = {
"election_epoch": 2,
"monmap": {
"created": "0.000000",
"epoch": 1,
"fsid": "fc0dc0f5-fe35-48c1-8c9c-f2ae0770fce7",
"modified": "0.000000",
"mons": [
{
"addr": "198.199.75.124:6789/0",
"name": "vagrant-ubuntu-trusty-64",
"rank": 0
}
]
},
"quorum": [
0
],
"quorum_leader_name": "",
"quorum_names": [
"vagrant-ubuntu-trusty-64"
]
}
new.data = {
"election_epoch": 2,
"monmap": {
"created": "0.000000",
"epoch": 1,
"fsid": "fc0dc0f5-fe35-48c1-8c9c-f2ae0770fce7",
"modified": "0.000000",
"mons": [
{
"addr": "198.199.75.124:6789/0",
"name": "vagrant-ubuntu-trusty-64",
"rank": 0
}
]
},
"quorum": [
0
],
"quorum_leader_name": "vagrant-ubuntu-trusty-64",
"quorum_names": [
"vagrant-ubuntu-trusty-64"
]
}
self.eventer._emit = MagicMock()
self.eventer._on_quorum_status(12345, new, new)
self.assertFalse(self.eventer._emit.called)
self.eventer._on_quorum_status(12345, new, old)
message = '\n'.join([str(x) for x in self.eventer._emit.call_args_list])
print message
self.assertIn('now quorum leader', message)
def test_coverage(self):
chn = MagicMock()
chn.is_loaded.return_value = True
chn.shape = 3712, 3712
chn.mask = np.zeros(chn.shape, dtype=bool)
chn.mask[:1250, :] = True
chn.mask[2500:, :] = True
chn.mask[:, :1250] = True
chn.mask[:, 2500:] = True
chn.data = np.ma.array(np.ones(chn.shape), mask=chn.mask)
chn.area = AreaDefinition(
"chn_area", "chn_area", "geos 0.0", {
"proj": "geos",
"lon_0": "0.0",
"a": "6378169.00",
"b": "6356583.80",
"h": "35785831.0"
}, 3712, 3712, [
-5567248.074173444, -5570248.4773392612, 5570248.4773392612,
5567248.074173444
])
hrv = MagicMock()
hrv.is_loaded.return_value = True
hrv.shape = 11136, 11136
hrv.mask = np.zeros(hrv.shape, dtype=bool)
hrv.mask[:3500, :] = True
hrv.mask[7700:, :] = True
hrv.mask[:, :3500] = True
hrv.mask[:, 7700:] = True
hrv.data = np.ma.array(np.ones(hrv.shape), mask=hrv.mask)
hrv.area = AreaDefinition(
"hrv_area", "hrv_area", "geos 0.0", {
"proj": "geos",
"lon_0": "0.0",
"a": "6378169.00",
"b": "6356583.80",
"h": "35785831.0"
}, 11136, 11136, [
-5570248.2560258955, -5567247.8529792884, 5567247.8529792884,
5570248.2560258955
])
scene = MagicMock()
scene.channels = (chn, hrv)
mali = AreaDefinition("mali_area", "mali_area", "merc", {
"proj": "merc",
"ellps": "WGS84",
"lon_0": "-1.0",
"lat_0": "19.0"
}, 1024, 1024, (-1224514.3987260093, 1111475.1028522244,
1224514.3987260093, 3228918.5790461157))
self.assertEquals(0.44009280754700542, coverage(scene, mali))
def test_load_all_modules(self):
self.firestarter.config = {
"modules": [{
"name": "my_rest_api",
"type": "http_api",
"parameters": {
"url": "http://drunken.guru/"
}
}, {
"name": "hive_query",
"type": "http_api",
"parameters": {
"url": "http://original.guru/"
}
}, {
"name": "crunch_the_numbers",
"type": "lighter",
"parameters": {
"math_rules": "2+2=4"
}
}, {
"name": "data_center_cluster",
"type": "hdfs",
"parameters": {
"hive_table": "mydb.table.name"
}
}]
}
with patch.object(HttpApi, '__init__', return_value=None):
with patch.object(Lighter, '__init__', return_value=None):
with patch.object(HadoopFileSystem,
'__init__',
return_value=None):
mock_http_api = MagicMock()
mock_lighter = MagicMock()
mock_hdfs = MagicMock()
mock_http_api.data = ['hello']
mock_lighter.data = ['world']
mock_hdfs.data = ['yall']
self.firestarter.mappings = mappings = {
'http_api': mock_http_api,
'lighter': mock_lighter,
'hdfs': mock_hdfs
}
self.firestarter.load_modules()
self.assertIn('my_rest_api', self.firestarter.modules)
self.assertEqual(
id(self.firestarter.modules['my_rest_api'].data),
id(mock_http_api.data))
self.assertIn('hive_query', self.firestarter.modules)
self.assertIn('data_center_cluster',
self.firestarter.modules)
self.assertIn('my_rest_api', self.firestarter.data)
self.assertIn('hive_query', self.firestarter.data)
self.assertIn('data_center_cluster', self.firestarter.data)
def test_run(self, strp_fun):
"""Test running the ReqMan
"""
socket = self.context.socket.return_value
socks = ((socket, server.POLLIN), )
cnt = [0]
def side_effect(timeout):
del timeout
time.sleep(0.1)
cnt[0] += 1
return socks
ping = MagicMock()
ping.type = "ping"
req = MagicMock()
req.type = "request"
req.data = {
"type": "scanline",
"satellite": MagicMock(),
"utctime": MagicMock()
}
notice = MagicMock()
notice.type = "notice"
notice.data = {"type": "scanline"}
unknown = MagicMock()
msgs = [ping, req, notice, unknown]
def msg(*args, **kwargs):
if "rawstr" in kwargs:
return msgs[cnt[0] % len(msgs)]
else:
return MagicMock()
server.Message.side_effect = msg
self.reqman.pong = MagicMock()
self.reqman.notice = MagicMock()
self.reqman.scanline = MagicMock()
self.reqman.unknown = MagicMock()
sys.modules["zmq"].Poller.return_value.poll.side_effect = side_effect
self.reqman.start()
time.sleep(0.4)
self.reqman.stop()
self.reqman.join()
self.reqman.pong.assert_called_once_with()
self.reqman.notice.assert_called_once_with(notice)
self.reqman.scanline.assert_called_once_with(req)
self.reqman.unknown.assert_called_once_with(unknown)
sys.modules["zmq"].Poller.return_value.side_effect = None
server.Message.side_effect = None
def test_that_it_emits_quorum_status_events(self, client):
new = MagicMock()
old = MagicMock()
old.data = {
"election_epoch": 2,
"monmap": {
"created":
"0.000000",
"epoch":
1,
"fsid":
"fc0dc0f5-fe35-48c1-8c9c-f2ae0770fce7",
"modified":
"0.000000",
"mons": [{
"addr": "198.199.75.124:6789/0",
"name": "vagrant-ubuntu-trusty-64",
"rank": 0
}]
},
"quorum": [0],
"quorum_leader_name": "",
"quorum_names": ["vagrant-ubuntu-trusty-64"]
}
new.data = {
"election_epoch": 2,
"monmap": {
"created":
"0.000000",
"epoch":
1,
"fsid":
"fc0dc0f5-fe35-48c1-8c9c-f2ae0770fce7",
"modified":
"0.000000",
"mons": [{
"addr": "198.199.75.124:6789/0",
"name": "vagrant-ubuntu-trusty-64",
"rank": 0
}]
},
"quorum": [0],
"quorum_leader_name": "vagrant-ubuntu-trusty-64",
"quorum_names": ["vagrant-ubuntu-trusty-64"]
}
self.eventer._emit = MagicMock()
self.eventer._on_quorum_status(12345, new, new)
self.assertFalse(self.eventer._emit.called)
self.eventer._on_quorum_status(12345, new, old)
message = '\n'.join(
[str(x) for x in self.eventer._emit.call_args_list])
print message
self.assertIn('now quorum leader', message)
def test_run(self, strp_fun):
"""Test running the ReqMan
"""
socket = self.context.socket.return_value
socks = ((socket, server.POLLIN),)
cnt = [0]
def side_effect(timeout):
del timeout
time.sleep(0.1)
cnt[0] += 1
return socks
ping = MagicMock()
ping.type = "ping"
req = MagicMock()
req.type = "request"
req.data = {"type": "scanline",
"satellite": MagicMock(),
"utctime": MagicMock()}
notice = MagicMock()
notice.type = "notice"
notice.data = {"type": "scanline"}
unknown = MagicMock()
msgs = [ping, req, notice, unknown]
def msg(*args, **kwargs):
if "rawstr" in kwargs:
return msgs[cnt[0] % len(msgs)]
else:
return MagicMock()
server.Message.side_effect = msg
self.reqman.pong = MagicMock()
self.reqman.notice = MagicMock()
self.reqman.scanline = MagicMock()
self.reqman.unknown = MagicMock()
sys.modules["zmq"].Poller.return_value.poll.side_effect = side_effect
self.reqman.start()
time.sleep(0.4)
self.reqman.stop()
self.reqman.join()
self.reqman.pong.assert_called_once_with()
self.reqman.notice.assert_called_once_with(notice)
self.reqman.scanline.assert_called_once_with(req)
self.reqman.unknown.assert_called_once_with(unknown)
sys.modules["zmq"].Poller.return_value.side_effect = None
server.Message.side_effect = None
def create_mocked_result_set(self, n):
rs = []
for i in range(n):
mock_record = MagicMock()
mock_record.data = 'data{0}'.format(i)
rs.append(mock_record)
mock_conn.search.return_value = rs
def test_load(self):
"""tests load method"""
mock_run_statement = MagicMock()
PostgreSqlDatabase.run_statement = mock_run_statement
config = MagicMock()
config.schema = self.schema
config.data = self.data
fixture = PostgreSqlFixture(config=config)
fixture.load()
# Brittle way of testing that insert statement is run
# Assumes the keys of first row in self.data are the fields to insert
data_row = self.data[0]
stmnt_fields, expected_statement = PostgreSqlInsertStatementMixin.create_insert_statement(
table=self.schema.config.get_table(),
fields=list(data_row.keys()),
statement_string=True)
expected_params = [data_row[field] for field in stmnt_fields]
mock_run_statement.assert_called_with(expected_statement,
params=expected_params,
commit=True)
def test_load(self):
"""tests load method"""
mock_run_statement = MagicMock()
MySqlDatabase.run_statement = mock_run_statement
config = MagicMock()
config.schema = self.schema
config.data = self.data
fixture = MySqlFixture(
config=config
)
fixture.load()
# Brittle way of testing that insert statement is run
# Assumes the keys of first row in self.data are the fields to insert
data_row = self.data[0]
stmnt_fields, expected_statement = MySqlInsertStatementMixin.create_insert_statement(
table=self.schema.config.get_table(),
fields=data_row.keys(),
statement_string=True
)
expected_params = [data_row[field] for field in stmnt_fields]
mock_run_statement.assert_called_with(
expected_statement,
params=expected_params,
commit=True
)
def create_mocked_result_set(self, n):
rs = []
for i in range(n):
mock_record = MagicMock()
mock_record.data = 'data{0}'.format(i)
rs.append(mock_record)
mock_conn.search.return_value = rs
def test_filter_message_with_uri_gets_expanded(self):
filter_message = json.dumps({
'filter': {
'actions': {},
'match_policy':
'include_all',
'clauses': [{
'field': '/uri',
'operator': 'equals',
'value': 'http://example.com',
}],
}
})
with patch('h.api.uri.expand') as expand:
expand.return_value = [
'http://example.com', 'http://example.com/alter',
'http://example.com/print'
]
msg = MagicMock()
msg.data = filter_message
self.s.received_message(msg)
uri_filter = self.s.filter.filter['clauses'][0]
uri_values = uri_filter['value']
assert len(uri_values) == 3
assert 'http://example.com' in uri_values
assert 'http://example.com/alter' in uri_values
assert 'http://example.com/print' in uri_values
def test_makes_request_with_proxy(self, mock_manager):
response_mock = MagicMock()
response_mock.status = 200
response_mock.data = 'test_data'
mock_connection = MagicMock()
mock_connection.request.return_value = response_mock
mock_manager.return_value = mock_connection
url = '/my_test_url/'
# Test http
host = 'http://whynotestsforthisstuff.com'
with patch.dict(os.environ, {'http_proxy': 'host:333'}):
utils.make_request('GET', host, url, 'a_user', 'a_pass')
mock_manager.assert_called_once_with(num_pools=1,
proxy_headers=Any(),
proxy_url='http://host:333')
mock_connection.request.assert_called_once()
# Test https
host = 'https://whynotestsforthisstuff.com'
with patch.dict(os.environ, {'https_proxy': 'host:333'}):
utils.make_request('GET', host, url, 'a_user', 'a_pass')
mock_manager.assert_called_with(num_pools=1,
proxy_headers=Any(),
proxy_url='https://host:333',
ca_certs=Any(),
cert_reqs=Any())
self.assertEqual(mock_connection.request.call_count, 2)
def test_get_properties(self):
# given
exp = MagicMock()
exp.experiment_id = 123
exp.name = 'EXPeriMENT-NaMe'
# and
run = MagicMock()
# and
run.info = MagicMock()
run.info.run_uuid = str(uuid.uuid4())
# and
run.data = MagicMock()
run.data.tags = {'key1': 'value1', 'key2': 'value2'}
# expect
# pylint: disable=protected-access
self.assertEqual(
DataLoader._get_properties(exp, run), {
'mlflow/experiment/id': str(exp.experiment_id),
'mlflow/experiment/name': exp.name,
'mlflow/run/uuid': run.info.run_uuid,
'mlflow/run/name': '',
'key1': 'value1',
'key2': 'value2'
})
def test_create_patient_subrecord(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {'name': 'blue', 'episode_id': self.episode.pk,
'patient_id': self.patient.pk}
response = self.patientviewset().create(mock_request)
self.assertEqual('blue', response.data['name'])
def test_parse_int_list_post(self):
"""Tests parsing a required list of int parameters that are provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({'test': ['1', '2']})
self.assertEqual(rest_util.parse_int_list(request, 'test'), [1, 2])
def test_update_item_changed(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
consistency_token='frist',
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': 'wat'
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
colour = Colour.objects.get()
self.assertEqual(created, colour.created)
self.assertEqual(self.user, colour.created_by)
self.assertIsNone(colour.updated)
self.assertIsNone(colour.updated_by)
self.assertEqual(409, response.status_code)
def test_prepare_contract_data_with_exception(
self, mocked_loop, mocked_contract_client, mocked_tender_client,
mocked_sync_client, mocked_db, mocked_logger, mocked_gevent):
static_number = 12
true_list = [True for i in xrange(0, static_number)]
true_list.append(False)
mocked_loop.__nonzero__.side_effect = true_list
cb = ContractingDataBridge({'main': {}})
for i in range(static_number):
cb.handicap_contracts_queue.put({'id': i, 'tender_id': i + 1111})
tender_data = MagicMock()
tender_data.data = {'no_owner': '', 'no_tender_token': ''}
cb.get_tender_credentials = MagicMock(return_value=tender_data)
cb.prepare_contract_data()
list_calls = mocked_gevent.sleep.call_args_list
calls_logs = mocked_logger.info.call_args_list
calls_with_error_delay = call(cb.on_error_delay)
self.assertEqual(
self._get_calls_count(list_calls, calls_with_error_delay),
static_number)
reconnecting_log = call('Reconnecting tenders client',
extra={
'JOURNAL_TENDER_ID': 1120,
'MESSAGE_ID': 'c_bridge_reconnect',
'JOURNAL_CONTRACT_ID': 9
})
self.assertEqual(self._get_calls_count(calls_logs, reconnecting_log),
1)
def mm(package_name):
""" Mock packages for packages_to_dict """
p = MagicMock()
p.filename = package_name
p.get_url.return_value = package_name + ".ext"
p.data = {}
return p
def test_update(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': colour.consistency_token,
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
updated_colour = Colour.objects.get()
self.assertEqual(created, updated_colour.created)
self.assertEqual(self.user, updated_colour.created_by)
self.assertEqual(date.today(), updated_colour.updated.date())
self.assertEqual(202, response.status_code)
self.assertEqual('green',
json.loads(response.content.decode('UTF-8'))['name'])
def test_filter_message_with_uri_gets_expanded(self):
filter_message = json.dumps({
'filter': {
'actions': {},
'match_policy': 'include_all',
'clauses': [{
'field': '/uri',
'operator': 'equals',
'value': 'http://example.com',
}],
}
})
with patch('h.api.uri.expand') as expand:
expand.return_value = ['http://example.com',
'http://example.com/alter',
'http://example.com/print']
msg = MagicMock()
msg.data = filter_message
self.s.received_message(msg)
uri_filter = self.s.filter.filter['clauses'][0]
uri_values = uri_filter['value']
assert len(uri_values) == 3
assert 'http://example.com' in uri_values
assert 'http://example.com/alter' in uri_values
assert 'http://example.com/print' in uri_values
def test_create(self, bulk_create):
request = MagicMock()
expected_dict = dict(messages=[], hospital_number="1")
request.data = json.dumps(expected_dict)
endpoint = GlossEndpointApi()
endpoint.create(request)
bulk_create.assert_called_once_with(expected_dict)
def test_makes_request(self, mock_manager):
response_mock = MagicMock()
response_mock.status = 200
response_mock.data = 'test_data'
mock_connection = MagicMock()
mock_connection.request.return_value = response_mock
mock_manager.return_value = mock_connection
host = 'http://whynotestsforthisstuff.com'
url = '/my_test_url/'
utils.make_request('GET', host, url, 'a_user', 'a_pass')
mock_manager.assert_called_once_with(num_pools=1)
mock_connection.request.assert_called_once()
# In case the http proxy variable exists but is empty,
# it shouldn't break things
with patch.dict(os.environ, {'http_proxy': ''}):
utils.make_request('GET', host, url, 'a_user', 'a_pass')
mock_manager.assert_called_with(num_pools=1)
self.assertEqual(mock_connection.request.call_count, 2)
# In case the https proxy variable exists but is empty,
# it shouldn't break things
with patch.dict(os.environ, {'https_proxy': ''}):
utils.make_request('GET', host, url, 'a_user', 'a_pass')
mock_manager.assert_called_with(num_pools=1)
self.assertEqual(mock_connection.request.call_count, 3)
def test_update_item_changed(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
consistency_token='frist',
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': 'wat'
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
colour = Colour.objects.get()
self.assertEqual(created, colour.created)
self.assertEqual(self.user, colour.created_by)
self.assertIsNone(colour.updated)
self.assertIsNone(colour.updated_by)
self.assertEqual(409, response.status_code)
def test_create_patient_subrecord(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {'name': 'blue', 'episode_id': self.episode.pk,
'patient_id': self.patient.pk}
response = self.patientviewset().create(mock_request)
self.assertEqual('blue', json.loads(response.content)['name'])
def test_60_finalize(self, sleep, get_dns_driver, get_driver):
auth = Authentication([{
'id': 'one',
'type': 'GCE',
'username': '******',
'password': '******',
'project': 'proj'
}])
gce_cloud = self.get_gce_cloud()
radl_data = """
network net (outbound = 'yes')
system test (
cpu.count=2 and
memory.size=2048m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test.domain.com' and
net_interface.0.ip = '158.42.1.1'
)"""
radl = radl_parse.parse_radl(radl_data)
inf = MagicMock()
vm = VirtualMachine(inf, "1", gce_cloud.cloud, radl, radl, gce_cloud,
1)
driver = MagicMock()
get_driver.return_value = driver
dns_driver = MagicMock()
get_dns_driver.return_value = dns_driver
node = MagicMock()
node.destroy.return_value = True
node.extra = {'disks': [{'source': 'vol'}]}
node.driver = driver
driver.ex_get_node.return_value = node
volume = MagicMock()
volume.detach.return_value = True
volume.destroy.return_value = True
driver.ex_get_volume.return_value = volume
zone = MagicMock()
zone.domain = "domain.com."
dns_driver.iterate_zones.return_value = [zone]
record = MagicMock()
record.name = 'test.domain.com.'
record.data = {'rrdatas': ['158.42.1.1'], 'ttl': 300}
dns_driver.iterate_records.return_value = [record]
success, _ = gce_cloud.finalize(vm, True, auth)
self.assertTrue(success, msg="ERROR: finalizing VM info.")
self.assertEquals(dns_driver.delete_record.call_count, 1)
self.assertEquals(
dns_driver.delete_record.call_args_list[0][0][0].name,
'test.domain.com.')
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_parse_bool_post(self):
"""Tests parsing a required bool parameter that is provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': 'true',
})
self.assertTrue(rest_util.parse_bool(request, 'test'))
def test_data_messages(self):
client, collection, data, subset = self._create_objects()
m = MagicMock()
m.data = data
client.add_layer(data)
client._update_data(m)
client._remove_data(m)
assert not client.layer_present(data)
def test_parse_float_post(self):
'''Tests parsing a required float parameter that is provided via POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': '10.1',
})
self.assertEqual(rest_util.parse_float(request, 'test'), 10.1)
def test_data_messages(self):
client, collection, data, subset = self._create_objects()
m = MagicMock()
m.data = data
client.add_layer(data)
client._update_data(m)
client._remove_data(m)
assert not client.layer_present(data)
def test_check_update(self):
'''Tests checking a white-list of parameters allowed to be updated during a POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': 'value1',
})
self.assertTrue(rest_util.check_update(request, ['test']))
def test_parse_int_post(self):
"""Tests parsing a required int parameter that is provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': '10',
})
self.assertEqual(rest_util.parse_int(request, 'test'), 10)
def test_that_it_emits_added_osd_events(self):
self.eventer._emit = MagicMock()
new = MagicMock()
old = MagicMock()
new.data = {}
new.data['osds'] = [{'osd': 0}]
self.eventer._on_osd_map(12345, new, old)
self.assertIn('added to the cluster map', '\n'.join([str(x) for x in self.eventer._emit.call_args_list]))
def test_parse_float_post(self):
"""Tests parsing a required float parameter that is provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': '10.1',
})
self.assertEqual(rest_util.parse_float(request, 'test'), 10.1)
def test_functions_pubsub_subscribe_should_print_message(capsys):
pubsub_message = MagicMock()
pubsub_message.data = base64.b64encode(b"Hello, world!")
main.subscribe(pubsub_message)
out, _ = capsys.readouterr()
assert "Hello, world!" in out
def test_check_update(self):
"""Tests checking a white-list of parameters allowed to be updated during a POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': 'value1',
})
self.assertTrue(rest_util.check_update(request, ['test']))
def test_parse_string_list_post(self):
'''Tests parsing a required list of string parameters that are provided via POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({'test': ['value1', 'value2']})
self.assertEqual(rest_util.parse_string_list(request, 'test'),
['value1', 'value2'])
def test_parse_int_post(self):
'''Tests parsing a required int parameter that is provided via POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': '10',
})
self.assertEqual(rest_util.parse_int(request, 'test'), 10)
def test_incorrect_content_type(incorrect_content_type):
data_payload = '0'
mock_request = MagicMock()
mock_request.data = data_payload
mock_request.content_type = incorrect_content_type
with pytest.raises(exc.UserError):
serve._parse_content_data(mock_request)
def test_parse_bool_post(self):
'''Tests parsing a required bool parameter that is provided via POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': 'true',
})
self.assertTrue(rest_util.parse_bool(request, 'test'))
def test_refer_sets_tag_names(self):
mock_request = MagicMock(name='Mock request')
mock_request.data = {
'hospital_number': self.demographics.hospital_number
}
mock_request.user = self.user
self.viewset().create(mock_request)
episode = self.patient.episode_set.get(category_name='testing')
self.assertEqual(['test'], list(episode.get_tag_names(None)))
def test_refer_sets_tag_names(self):
mock_request = MagicMock(name='Mock request')
mock_request.data = {
'hospital_number': self.demographics.hospital_number
}
mock_request.user = self.user
self.viewset().create(mock_request)
episode = self.patient.episode_set.get(category_name='testing')
self.assertEqual(['test'], list(episode.get_tag_names(None)))
def test_refer_creates_correct_episode_category(self):
mock_request = MagicMock(name='Mock request')
mock_request.data = {
'hospital_number': self.demographics.hospital_number
}
mock_request.user = self.user
self.assertEqual(0, self.patient.episode_set.filter(category_name='testing').count())
self.viewset().create(mock_request)
self.assertEqual(1, self.patient.episode_set.filter(category_name='testing').count())
def test_check_bad_param_type(self):
"""Tests checking a white-list of invalid parameters allowed to be updated during a POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test1': 'value1',
'test2': 'value2',
})
self.assertRaises(AssertionError, rest_util.check_update, request, 'test1')
def test_check_update_invalid(self):
'''Tests checking a white-list of invalid parameters allowed to be updated during a POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test1': 'value1',
'test2': 'value2',
})
self.assertRaises(ReadOnly, rest_util.check_update, request, ['test1'])
def test_parse_int_list_post(self):
'''Tests parsing a required list of int parameters that are provided via POST.'''
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': ['1', '2']
})
self.assertEqual(rest_util.parse_int_list(request, 'test'), [1, 2])
def test_check_update_invalid(self):
"""Tests checking a white-list of invalid parameters allowed to be updated during a POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test1': 'value1',
'test2': 'value2',
})
self.assertRaises(ReadOnly, rest_util.check_update, request, ['test1'])
def test_parse_string_list_post(self):
"""Tests parsing a required list of string parameters that are provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': ['value1', 'value2']
})
self.assertEqual(rest_util.parse_string_list(request, 'test'), ['value1', 'value2'])
def test_handle_error(self, mymock):
"""Test handle error method."""
resp = MagicMock()
resp.status_code = 0
resp.data = INVALID_HEADER_TOKEN
mymock.return_value = resp
tmp = handle_error_upstream(INVALID_HEADER_TOKEN)
assert tmp.status_code == 401
assert tmp.data == INVALID_HEADER_TOKEN, tmp.data
def test_refer_calls_post_create(self):
mock_request = MagicMock(name='Mock request')
mock_request.data = {
'hospital_number': self.demographics.hospital_number
}
mock_request.user = self.user
with patch.object(TestRoute, 'post_create') as mock_create:
response = self.viewset().create(mock_request)
episode = self.patient.episode_set.get(category_name='testing')
mock_create.assert_called_with(episode, mock_request.user)
def create_mock_request(self, **kwargs):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {
'name': 'Jane',
'episode_id': self.episode.id,
}
mock_request.data.update(kwargs)
return mock_request
def test_that_it_emits_added_osd_events(self):
self.eventer._emit = MagicMock()
new = MagicMock()
old = MagicMock()
new.data = {}
new.data['osds'] = [{'osd': 0}]
self.eventer._on_osd_map(12345, new, old)
self.assertIn(
'added to the cluster map',
'\n'.join([str(x) for x in self.eventer._emit.call_args_list]))
def test_create(self, bulk_create):
request = MagicMock()
expected_dict = dict(
messages=[],
hospital_number="1"
)
request.data = json.dumps(expected_dict)
endpoint = GlossEndpointApi()
endpoint.create(request)
bulk_create.assert_called_once_with(expected_dict)
def verse_order_no_warning_test(self):
"""
Test if the verse order warning is not shown
"""
# GIVEN: Mocked methods.
given_verse_order = 'V1 V2'
self.form.verse_list_widget.rowCount = MagicMock(return_value=2)
# Mock out the verse.
first_verse = MagicMock()
first_verse.data = MagicMock(return_value='V1')
second_verse = MagicMock()
second_verse.data = MagicMock(return_value= 'V2')
self.form.verse_list_widget.item = MagicMock(side_effect=[first_verse, second_verse])
self.form._extract_verse_order = MagicMock(return_value=given_verse_order.split())
# WHEN: Call the method.
self.form.on_verse_order_text_changed(given_verse_order)
# THEN: No text should be shown.
assert self.form.warning_label.text() == '', 'There should be no warning.'
def test_create(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {'name': 'blue', 'episode_id': self.episode.pk}
response = self.viewset().create(mock_request)
colour = Colour.objects.get()
self.assertEqual(date.today(), colour.created.date())
self.assertEqual(self.user, colour.created_by)
self.assertIsNone(colour.updated)
self.assertIsNone(colour.updated_by)
self.assertEqual('blue', response.data['name'])
def test_refer_creates_new_patient(self):
mock_request = MagicMock(name='Mock request')
new_number = 'n' + str(time.time())
mock_request.data = {
'hospital_number': new_number,
}
mock_request.user = self.user
self.assertEqual(0, Patient.objects.filter(demographics__hospital_number=new_number).count())
response = self.viewset().create(mock_request)
self.assertEqual(201, response.status_code)
self.assertEqual(1, Patient.objects.filter(demographics__hospital_number=new_number).count())
def verse_order_incomplete_warning_test(self):
"""
Test if the verse-order-incomple warning is shown
"""
# GIVEN: Mocked methods.
given_verse_order = 'V1'
self.form.verse_list_widget.rowCount = MagicMock(return_value=2)
# Mock out the verse.
first_verse = MagicMock()
first_verse.data = MagicMock(return_value='V1')
second_verse = MagicMock()
second_verse.data = MagicMock(return_value= 'V2')
self.form.verse_list_widget.item = MagicMock(side_effect=[first_verse, second_verse])
self.form._extract_verse_order = MagicMock(return_value=[given_verse_order])
# WHEN: Call the method.
self.form.on_verse_order_text_changed(given_verse_order)
# THEN: The verse-order-incomplete text should be shown.
assert self.form.warning_label.text() == self.form.not_all_verses_used_warning, \
'The verse-order-incomplete warning should be shown.'
def test_update_pings_integration(self, change):
colour = Colour.objects.create(name='blue', episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name' : 'green',
'episode_id' : self.episode.pk,
'id' : colour.pk,
'consistency_token': colour.consistency_token
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
self.assertEqual(202, response.status_code)
self.assertEqual(1, change.call_count)
def test_update_unexpected_field(self):
colour = Colour.objects.create(name='blue', episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name' : 'green',
'hue' : 'sea',
'episode_id' : self.episode.pk,
'id' : colour.pk,
'consistency_token': colour.consistency_token
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
self.assertEqual(400, response.status_code)
def test_dont_create(self):
self.episode.set_tag_names(["old_team"], self.user)
mock_request = MagicMock(name='Mock request')
mock_request.data = {
'hospital_number': self.demographics.hospital_number
}
mock_request.user = self.user
self.assertEqual(1, self.patient.episode_set.count())
response = self.dont_create_viewset().create(mock_request)
self.assertEqual(201, response.status_code)
self.assertEqual(1, self.patient.episode_set.count())
new_team_names = set(self.episode.get_tag_names(self.user))
self.assertEqual(new_team_names, {'old_team', 'test'})
