def test_request_response(): response = get_users() assert_dict_contains_subset( {'Content-Type': 'application/json; charset=utf-8'}, response.headers) assert_true(response.ok) assert_is_instance(response.json(), list)
def test_perform_requests_called_correctly_for_post_method( self, mock_request): url = 'https://rundeck.example.com/api/13/test_endpoint' mock_request.return_value = self.resp self.client._perform_request(url, method='POST', params={'xmlBatch': '123\n456'}) args = mock_request.call_args nt.assert_equal(2, len(args)) nt.assert_equal(( 'POST', url, ), args[0]) nt.assert_in('headers', args[1]) nt.assert_in('data', args[1]) headers = args[1]['headers'] nt.assert_dict_contains_subset( { 'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__ }, headers) data = args[1]['data'] nt.assert_dict_contains_subset({'xmlBatch': '123\n456'}, data)
def test_api001(self,datas): #近一步优化,将request请求进行封装 base_url = datas['base_url'] api_command = datas['api_command'] url = base_url+api_command # unicode 转换为str # 当params为空的unicode时,使用eval会报错,所以,需要判断一下: # 当params为非空时,使用eval(datas['params'])将unicode转换为str # 当params为空的nnicode类型时,重新定义params='',此时params为空的str类型; params = datas['params'] if params != '': params = eval(datas['params']) print 'ok' else: params = '' print 'nothing' # set_trace() res = requests.get(url=url, params=params) res_code = res.status_code # 字典 res_result = res.json() expect_code = int(datas['expect_code']) # excel中读取的expect_result是unicode格式,使用eval转换dict expect_result = eval(datas['expect_result']) # 比较状态码和结果 # return expect_code,expect_result,res_code,res_result assert_equal(expect_code, res_code,msg=u'请求错误%d'%res_code) assert_dict_contains_subset(expect_result,res_result,msg=u'预期结果错误%s'%res_result)
def test_modelmapper_model_save(): db = get_db() users = dibble.mapper.ModelMapper(AdvancedUserModel, db.user) user = users() user.logincount.inc(1) user.username.set('Foo Bar') user.usernames.push('Foo Bar') user.save() u = dict(users.collection.find_one()) expected = { 'logincount': 1, 'username': '******', 'usernames': ['Foo Bar'] } assert_dict_contains_subset(expected, u) users.collection.update({}, {'$set': {'username': '******'}}) user.logincount.inc(41) user.save() u = dict(users.collection.find_one()) expected = { 'logincount': 42, 'username': '******', 'usernames': ['Foo Bar'] } assert_dict_contains_subset(expected, u)
def test_createColumns(): columns_to_create = [Column(name="FirstTestColumn", columnType="INTEGER"), Column(name="SecondTestColumn", columnType="DOUBLE")] created_columns = syn.createColumns(columns_to_create) assert_equals(len(columns_to_create), len(created_columns)) for col_to_create, created_col in zip(columns_to_create, created_columns): assert_in('id', created_col) assert_dict_contains_subset(col_to_create, created_col)
def test_set_evar(): test_evars = {'ekey': 'evalue'} for k, v in test_evars.items(): lpa.set_evar(k, v) lpa_evars = lpa.get_cfg('evars') assert_dict_contains_subset(test_evars, lpa_evars)
def test_get_all_evars(): test_evars = {'ekey1': 'evalue1', 'ekey2': 'evalue2'} for k, v in test_evars.items(): lpa.set_evar(k, v) lpa_evars = lpa.get_evar() assert_dict_contains_subset(test_evars, lpa_evars)
def test_basic_put(self): "A basic put should work." r1 = requests.put(self.url, self.simple_params) n.assert_equal(r1.status_code, 204) n.assert_equal(r1.content, '') r2 = requests.get(self.url) n.assert_equal(r2.status_code, 200) n.assert_dict_contains_subset(self.http_params, json.loads(r2.text))
def test_creates_user_no_email(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'e350cb61-ed72-4335-b915-7617b5e931f0', 'name': u'741c5e3e-53d0-431e-9f10-b6ebd39590f4', 'email': u'noemail', }, user )
def test_api001_case(self): set_trace() # self.rr1,没有test_api001()属性,有'test_api001_1', 'test_api001_2',属性 expect_code, expect_result, res_code, res_result = self.rr1.test_api001( ) assert_equal(expect_code, res_code, msg=u'请求错误%d' % res_code) assert_dict_contains_subset(expect_result, res_result, msg=u'预期结果错误%s' % res_result)
def test_creates_user_no_email(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'e350cb61-ed72-4335-b915-7617b5e931f0', 'name': '*****@*****.**', 'email': u'noemail', 'sysadmin': True, }, user )
def test_request_response(self): mock_users_url = 'http://localhost:{port}/users'.format(port=self.mock_server_port) # Patch USERS_URL so that the service uses the mock server URL instead of the real URL. with patch.dict('project.services.__dict__', {'USERS_URL': mock_users_url}): response = get_users() assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers) assert_true(response.ok) assert_list_equal(response.json(), [])
def test_dict(test_controller): """verify that __iter__() (used by dict()) works""" test_controller.duty = .1 assert_dict_contains_subset( { 'interval': 1, 'duty': .1, }, dict(test_controller) )
def test_request_response(self): mock_users_url = 'http://localhost:{port}/users'.format(port=self.mock_server_port) # Patch USERS_URL so that the service uses the mock server URL instead of the real URL. with patch.dict('example.services.__dict__', {'USERS_URL': mock_users_url}): response = get_users() assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, response.headers) assert_true(response.ok) assert_list_equal(response.json(), [])
def test_creates_user_no_email(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'dcfb1b12-fe52-4d71-9aad-c60fc4c6952c', 'name': u'johndoe', 'about': u'Description', 'email': u'noemail', }, user )
def test_creates_user_no_email(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'e350cb61-ed72-4335-b915-7617b5e931f0', 'name': '*****@*****.**', 'fullname': '*****@*****.**', 'email': u'noemail', }, user )
def test_creates_users(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'dcfb1b12-fe52-4d71-9aad-c60fc4c6952c', 'name': u'johndoe', 'fullname': u'John Doe', 'about': u'Description', 'email': u'*****@*****.**', }, user )
def test_recording(self): recorder = MongodbEnvironLagRecorder( self.collection, 'PATH', 'REMOTE_USER') environ = {'PATH': '/', 'REMOTE_USER': '******'} recorder(2.5, environ) eq_(1, self.collection.count()) mongo_document = self.collection.find_one() assert_dict_contains_subset(environ, mongo_document)
def simpledec(decorator=None, f=None, *args, **kwargs): sd_dec = sd.simple_decorator(decorator) decorated_f = sd_dec(f) nt.assert_dict_contains_subset( meta_comp(f), meta_comp(decorated_f), msg = "decorated function failed. function: %s - %r decorator: %s - %r" % ( f.__name__, meta_comp(f),decorator.__name__,meta_comp(decorated_f))) nt.assert_dict_contains_subset( meta_comp(decorator), meta_comp(sd_dec), msg = "simple_decorator on decorator fn %s failed" % decorator.__name__)
def test_get_context(awsclient): actual = get_context(awsclient, 'dev', 'kumo', 'deploy') expected_subset = { 'tool': 'kumo', 'command': 'deploy', 'env': 'dev', } assert_dict_contains_subset(expected_subset, actual) # the api_key is currently not rolled out see OPS-126 # assert_in('_datadog_api_key', actual) assert_in('user', actual) assert_in('version', actual)
def test_creates_user_no_email(self): user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'e350cb61-ed72-4335-b915-7617b5e931f0', 'name': '*****@*****.**', 'email': u'noemail', }, user ) members = helpers.call_action('member_list', id=self.test_org['id']) assert_equals('Admin', members[1][2])
def _assert_credentials_set_in_request(key_class, expected_key_name): authentication_key_value = get_uuid4_str() authentication_key = key_class(authentication_key_value) connection = \ _MockPortalConnection(authentication_key=authentication_key) connection.send_get_request(_STUB_URL_PATH) expected_credentials = {expected_key_name: [authentication_key_value]} prepared_request = connection.prepared_requests[0] query_string_args = \ _get_query_string_args_from_url(prepared_request.url) assert_dict_contains_subset(expected_credentials, query_string_args)
def response_content_element_has(step, element, identifier): from lettuce.django.steps.models import hashes_data element_data = world.response.data[element] element_data_by_id = {data.get(identifier): dict(data) for data in element_data} # Transform tabular data. step_data_by_id = {data.get(identifier): data for data in hashes_data(step)} assert_equal(len(element_data_by_id), len(step_data_by_id)) for identifier, data in step_data_by_id.items(): assert_dict_contains_subset(actual=element_data_by_id[identifier], expected=data)
def user_should_see_the_created_article(self, step): """User should see the created article""" stc = get_selenium_config(step.context) stc_conduit = get_conduit_config(step.context) art = ViewArticlePageObject(stc.driver) article = stc_conduit.test_data.data.get('last_article') current_title = art.read_title() current_article = art.read_article() assert_dict_contains_subset( { 'title': current_title, 'article': current_article }, article) stc.attach_screenshot_to_tests_report(step)
def test_user_create(self, mock_request): content = {"UserName": '******', "About": "about", "DisplayName": "display name", "Roles": ['OrganisationEditor'], "FirstName": "firstname", "LastName": "lastname", "UserId": "userid123", "IsRegistered": False, "OrganisationId": 'organisation123', "Email": "*****@*****.**" } mock_request.return_value = mock.Mock( status_code=200, content=json.dumps(content), **{ 'raise_for_status.return_value': None, 'json.return_value': content, } ) site_user = helpers.call_action('get_site_user') handle_user_update( context={ 'model': model, 'ignore_auth': True, 'local_action': True, 'user': site_user['name'] }, audit={'CustomProperties':{'UserName':'******'}}, harvest_object=None, ) user = helpers.call_action('user_show', id='testuser') membership = helpers.call_action('member_list', id='organisation123') nt.assert_dict_contains_subset( {'about': u'about', 'display_name': u'display name', 'email_hash': '6dc2fde946483a1d8a84b89345a1b638', 'fullname': u'display name', 'id': u'userid123', 'name': u'testuser', 'state': u'active', 'sysadmin': False }, user ) nt.assert_equals(membership[1], (u'userid123', u'user', u'Editor')) membership = helpers.call_action('member_list', id='an_org') nt.assert_false(u'userid123' in set(i[0] for i in membership))
def test_glider_information(): assert_dict_contains_subset( dict(model='', reg='', cid=''), read_igc_headers(['AFLA6NG', 'HFDTE', 'HFGTYGLIDERTYPE:', 'HFGIDGLIDERID:', 'HFCIDCOMPETITIONID:'])) assert_dict_contains_subset( dict(model='HORNET', reg='D_4449', cid='TH'), read_igc_headers(['AFLA6NG', 'HFDTE150812', 'HFGTYGLIDERTYPE:HORNET', 'HFGIDGLIDERID:D_4449', 'HFCIDCOMPETITIONID:TH']))
def test_modelmapper_unsafe_update(): db = get_db() mapper = dibble.mapper.ModelMapper(ReloadTestModel, db.reloadtest) m = mapper() m.foo.set('bar') m.counter.set(1) m.save() m._update.inc('counter', 41) m.save() expected = {'foo': 'bar', 'counter': 42} assert_dict_contains_subset(expected, dict(m))
def test_chart_new(self): chart1 = self.new_basic_chart()["chart"] assert_dict_contains_subset(self.basic_chart, chart1) # test chart created successful rv = self.app.get("/api/chart/{}".format(chart1["id"])) assert_equal(rv.status_code, 200) chart2 = _load_json(rv)["chart"] assert_equal(chart1, chart2) # test the new created chart in charts list charts = _load_json(self.app.get("/api/charts"))["charts"] assert_in(chart1, charts)
def test_glider_information(): assert_dict_contains_subset( dict(model='', reg='', cid=''), read_igc_headers([ 'AFLA6NG', 'HFDTE', 'HFGTYGLIDERTYPE:', 'HFGIDGLIDERID:', 'HFCIDCOMPETITIONID:' ])) assert_dict_contains_subset( dict(model='HORNET', reg='D_4449', cid='TH'), read_igc_headers([ 'AFLA6NG', 'HFDTE150812', 'HFGTYGLIDERTYPE:HORNET', 'HFGIDGLIDERID:D_4449', 'HFCIDCOMPETITIONID:TH' ]))
def test_dashboard_new(self): dashboard1 = self.new_basic_dashboard()["dashboard"] assert_dict_contains_subset(self.basic_dashboard, dashboard1) # test dashboard created successful rv = self.app.get("/api/dashboard/{}".format(dashboard1["id"])) assert_equal(rv.status_code, 200) dashboard2 = _load_json(rv)["dashboard"] assert_equal(dashboard1, dashboard2) # test the new created dashboard in dashboards list dashboards = _load_json(self.app.get("/api/dashboards"))["dashboards"] assert_in(dashboard1, dashboards)
def test_change_source(self): change_source = get_uuid4_str() connection = _MockPortalConnection(change_source=change_source) connection.send_get_request(_STUB_URL_PATH) prepared_request = connection.prepared_requests[0] query_string_args = \ _get_query_string_args_from_url(prepared_request.url) expected_change_source_args = {'auditId': [change_source]} assert_dict_contains_subset( expected_change_source_args, query_string_args, )
def test_subfield_mapper(): mapper = get_mapper() tm = mapper() tm.foo['bar']['baz'].set('fumm') tm.save() res = mapper.collection.find_one() expected = {'foo': {'bar': {'baz': 'fumm'}}} assert_dict_contains_subset(expected, res) tm.foo['bar']['baz'].set('fnorb') tm.save() res = mapper.collection.find_one() expected = {'foo': {'bar': {'baz': 'fnorb'}}} assert_dict_contains_subset(expected, res) tm.foo['bar'].set({'baz': 'ding'}) tm.save() res = mapper.collection.find_one() expected = {'foo': {'bar': {'baz': 'ding'}}} assert_dict_contains_subset(expected, res) tm.foo.set({'bar': {'baz': 'yadda'}}) tm.save() res = mapper.collection.find_one() expected = {'foo': {'bar': {'baz': 'yadda'}}} assert_dict_contains_subset(expected, res)
def test_modelmapper_model_reload(): db = get_db() users = dibble.mapper.ModelMapper(AdvancedUserModel, db.user) user = users() user.username.set('Foo Bar') user.save() users.collection.update({}, {'$set': {'username': '******'}}) user.reload() expected = {'username': '******'} assert_dict_contains_subset(expected, dict(user))
def test_perform_request_called_correctly_for_get_method(self, mock_request): url = 'https://rundeck.example.com/api/13/test_endpoint' mock_request.return_value = self.resp self.client._perform_request(url) args = mock_request.call_args nt.assert_equal(2, len(args)) nt.assert_equal(('GET', url,), args[0]) nt.assert_in('headers', args[1]) headers = args[1]['headers'] nt.assert_dict_contains_subset({'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__}, headers)
def test_with_extra_query_string_args(self): """ Any extra query string argument co-exists with authentication-related arguments. """ connection = _MockPortalConnection() extra_query_string_args = {'foo': ['bar']} connection.send_get_request(_STUB_URL_PATH, extra_query_string_args) prepared_request = connection.prepared_requests[0] query_string_args = \ _get_query_string_args_from_url(prepared_request.url) assert_dict_contains_subset(extra_query_string_args, query_string_args)
def test_get_form_kwargs_populates_form_with_data_to_be_cloned(self): """ When accessed via the tasks.clone url, the view displays a form whose initial data is that of the task being cloned, except for the 'name' field, which should be prefixed with 'Copy of ' """ user = UserFactory.create() original_task = TaskFactory.create() TaskKeywordFactory.create_batch(3, task=original_task) original_data = get_filled_taskform(original_task).data self.view.kwargs = {'clone': original_task.pk} self.view.request = Mock(user=user) with patch('oneanddone.tasks.views.generic.CreateView.get_form_kwargs') as get_form_kwargs: get_form_kwargs.return_value = {'initial': {}} initial = self.view.get_form_kwargs()['initial'] eq_(initial['keywords'], original_task.keywords_list) eq_(initial['name'], ' '.join(['Copy of', original_task.name])) del original_data['name'] assert_dict_contains_subset(original_data, initial)
def test_perform_request_calls_request_correctly_with_https(self, mock_request): mock_request.return_value = self.resp https_url = 'https://rundeck.example.com' client = RundeckApiClient(self.token, https_url) client._perform_request(https_url) args, kwargs = mock_request.call_args nt.assert_dict_contains_subset({'verify': True}, kwargs) path_to_pem = '/path/to/pem/file' other_client = RundeckApiClient(self.token, https_url, pem_file_path=path_to_pem) other_client._perform_request(https_url) args, kwargs = mock_request.call_args nt.assert_dict_contains_subset({'verify': path_to_pem}, kwargs)
def test_creates_user_no_email(self, mock_request): mock_request.return_value = mock.Mock( status_code=200, content=json.dumps(self.org_dict), **{ 'raise_for_status.return_value': None, 'json.return_value': self.org_dict, } ) user = create_user(self.ec_dict) assert_dict_contains_subset({ 'id': u'e350cb61-ed72-4335-b915-7617b5e931f0', 'name': '*****@*****.**', 'email': u'noemail', }, user ) org = helpers.call_action('organization_show', id='2') assert_equals('microsoft', org['name'])
def test_perform_request_calls_request_correctly_with_https( self, mock_request): mock_request.return_value = self.resp https_url = 'https://rundeck.example.com' client = RundeckApiClient(self.token, https_url) client._perform_request(https_url) args, kwargs = mock_request.call_args nt.assert_dict_contains_subset({'verify': True}, kwargs) path_to_pem = '/path/to/pem/file' other_client = RundeckApiClient(self.token, https_url, pem_file_path=path_to_pem) other_client._perform_request(https_url) args, kwargs = mock_request.call_args nt.assert_dict_contains_subset({'verify': path_to_pem}, kwargs)
def test_get_form_kwargs_populates_form_with_data_to_be_cloned(self): """ When accessed via the tasks.clone url, the view displays a form whose initial data is that of the task being cloned, except for the 'name' field, which should be prefixed with 'Copy of ' """ user = UserFactory.create() original_task = TaskFactory.create() TaskKeywordFactory.create_batch(3, task=original_task) original_data = get_filled_taskform(original_task).data self.view.kwargs = {'clone': original_task.pk} self.view.request = Mock(user=user) with patch('oneanddone.tasks.views.generic.CreateView.get_form_kwargs' ) as get_form_kwargs: get_form_kwargs.return_value = {'initial': {}} initial = self.view.get_form_kwargs()['initial'] eq_(initial['keywords'], original_task.keywords_list) eq_(initial['name'], ' '.join(['Copy of', original_task.name])) del original_data['name'] assert_dict_contains_subset(original_data, initial)
def test_create_signature_string(): test = yaml_read("request.yaml") for http_trace in test["test_rsa"]: trace = http_trace["http"] for t in http_trace["tests"]: s_data = t["params"] with create_mock_request(trace): ss = Signature(**s_data) ret = ss.sign_http_message(request) p = parse_signature_header(ret) assert_dict_contains_subset(s_data, p) sstring = ss.signature_string(request.method, request.path, request.headers) assert_equal(t["expected_string"], sstring) check_ss = Signature(**p) check_ss.verify(request.method, request.path, request.headers) headers = dict(**request.headers) assert headers
def test_initialization_sets_up_default_client_correctly(self): nt.assert_equal(self.token, self.client.token) nt.assert_dict_contains_subset({'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__}, self.client.client_args['headers']) new_client = RundeckApiClient(self.token, config.root_url, client_args={'headers': {'User-Agent': 'dummy agent string'}}) nt.assert_equal(self.token, new_client.token) nt.assert_dict_contains_subset({ 'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'dummy agent string' }, new_client.client_args['headers']) newest_client = RundeckApiClient(self.token, config.root_url, client_args={ 'headers': { 'bogus_header': 'bogus_value' } }) nt.assert_dict_contains_subset({'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__}, newest_client.client_args['headers']) nt.assert_equal(self.token, newest_client.token)
def test_initialization_sets_up_default_client_correctly(self): nt.assert_equal(self.token, self.client.token) nt.assert_dict_contains_subset( { 'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__ }, self.client.client_args['headers']) new_client = RundeckApiClient( self.token, config.root_url, client_args={'headers': { 'User-Agent': 'dummy agent string' }}) nt.assert_equal(self.token, new_client.token) nt.assert_dict_contains_subset( { 'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'dummy agent string' }, new_client.client_args['headers']) newest_client = RundeckApiClient( self.token, config.root_url, client_args={'headers': { 'bogus_header': 'bogus_value' }}) nt.assert_dict_contains_subset( { 'X-Rundeck-Auth-Token': self.token, 'User-Agent': 'PyRundeck v ' + __version__ }, newest_client.client_args['headers']) nt.assert_equal(self.token, newest_client.token)
def test_get_recordings_and_identify_kiwi(self): from configuration import Configurator from ornithokrites import ParallelOrnithokrites results_test = './tests/results_test.out' results_expected = './tests/results_expected.csv' app_config = Configurator().parse_arguments() ornithokrites = ParallelOrnithokrites(app_config) handler = logging.FileHandler(results_test, 'w') formatter = logging.Formatter('%(message)s') handler.setFormatter(formatter) log = logging.getLogger('log.html') log.addHandler(handler) ornithokrites.run() results_expected_dict = load_expected_results(results_expected) results_text_dict = load_results(results_test) nt.assert_dict_contains_subset(results_expected_dict, results_text_dict)
def test_record_list(): driver.get("http://127.0.0.1:8765/ProjectGlass/") # assert there are four records rows = driver.find_elements_by_tag_name('tr') assert_equal(len(rows), 4 + 1) # first row is the header column_headers = [ elem.text for elem in rows[0].find_elements_by_tag_name('th') ] # assert the labels are correct and that the reason and outcome fields are correct expected_content = substitute_labels([{ 'label': 0, 'outcome': 'works fine', 'reason': 'initial run', 'version': '6038f9c...', 'main': 'glass_sem_analysis.py' }, { 'label': 1, 'outcome': '', 'reason': 'No filtering' }, { 'label': 2, 'outcome': 'The default colourmap is nicer', 'reason': 'Trying a different colourmap' }, { 'label': 3, 'outcome': '', 'reason': 'Added labels to output', 'version': '6038f9c...*' }])(utils.env) for row, expected in zip(rows[1:], reversed(expected_content)): cells = row.find_elements_by_tag_name('td') label = cells[0].text assert_equal(row.get_attribute('id'), label) actual = dict((key.lower(), cell.text) for key, cell in zip(column_headers, cells)) assert_dict_contains_subset(expected, actual)
def test_api002(self,datas): # set_trace() base_url = datas['base_url'] api_command = datas['api_command'] url = base_url+api_command # 当params为空的unicode时,使用eval会报错,所以,需要判断一下: # 当params为非空时,使用eval(datas['params'])将unicode转换为str # 当params为空的nnicode类型时,重新定义params='',此时params为空的str类型; params = datas['params'] if params != '': params = eval(datas['params']) else: params = '' # set_trace() res = requests.get(url=url, params=params) res_code = res.status_code res_result = res.json() expect_code = int(datas['expect_code']) expect_result = eval(datas['expect_result']) assert_equal(expect_code, res_code, msg=u'请求错误%d' % res_code) assert_dict_contains_subset(expect_result, res_result, msg=u'预期结果错误%s' % res_result)
def test_to_dict(self): ev = Event(**self.record) nt.assert_dict_contains_subset(self.record, ev.to_dict()) nt.assert_dict_contains_subset({'DELETED': 0, 'ID': 1}, ev.to_dict())
def test_to_dict(self): test = Partner(**self.record) nt.assert_dict_contains_subset(self.record, test.to_dict())
def get_response(step): assert_dict_contains_subset({'Content-Type': 'application/json; charset=utf-8'}, world.response.headers) assert_true(world.response.ok) assert_list_equal(world.response.json(), [])
def get_response_with_dict(step): assert_dict_contains_subset(step.hashes.first, world.response.json())
def get_response_with_list(step): for expected, actual in izip_longest(list(step.hashes), world.response.json()): assert_dict_contains_subset(expected, actual)
def assert_params_contain(first, second): assert_dict_contains_subset(first, parse_qs(second))