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 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_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_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_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'})