def step_remove_directory(context, directory): path_ = directory if not os.path.isabs(directory): path_ = os.path.join(context.workdir, os.path.normpath(directory)) if os.path.isdir(path_): shutil.rmtree(path_, ignore_errors=True) assert_that(not os.path.isdir(path_))
def GetCompletions_ServerIsNotRunning_test( app ): StopCompleterServer( app, filetype = 'typescript' ) filepath = PathToTestFile( 'test.ts' ) contents = ReadFile( filepath ) # Check that sending a request to TSServer (the response is ignored) raises # the proper exception. event_data = BuildRequest( filepath = filepath, filetype = 'typescript', contents = contents, event_name = 'BufferVisit' ) assert_that( calling( app.post_json ).with_args( '/event_notification', event_data ), raises( AppError, 'TSServer is not running.' ) ) # Check that sending a command to TSServer (the response is processed) raises # the proper exception. completion_data = BuildRequest( filepath = filepath, filetype = 'typescript', contents = contents, force_semantic = True, line_num = 17, column_num = 6 ) assert_that( calling( app.post_json ).with_args( '/completions', completion_data ), raises( AppError, 'TSServer is not running.' ) )
def test_queries_for_hour_period_spanning_less_than_seven_days_are_allowed(self): validation_result = validate_request_args({ 'period': 'hour', 'start_at': '2000-02-02T00:00:00+00:00', 'end_at': '2000-02-08T00:00:00+00:00' }, False) assert_that(validation_result, is_valid())
def GetCompletions_IgoreNonJSFiles_test(app): trivial1 = {"filetypes": ["python"], "contents": ReadFile(PathToTestFile("trivial.js"))} trivial2 = {"filetypes": ["javascript"], "contents": ReadFile(PathToTestFile("trivial2.js"))} request = { "line_num": 1, "column_num": 3, "file_data": {PathToTestFile("trivial.js"): trivial1, PathToTestFile("trivial2.js"): trivial2}, } app.post_json( "/event_notification", _Merge(request, {"filepath": PathToTestFile("trivial2.js"), "event_name": "FileReadyToParse"}), ) response = app.post_json("/completions", _Merge(request, {"filepath": PathToTestFile("trivial2.js")})).json print("completer response: {0}".format(pformat(response, indent=2))) assert_that( response, has_entries( { "completion_start_column": 3, # Note: we do *not* see X.y and X.z because tern is not told about # the trivial.js file because we pretended it was Python "completions": empty(), "errors": empty(), } ), )
def GetCompletions_AfterRestart_test( app ): filepath = PathToTestFile( 'test.ts' ) app.post_json( '/run_completer_command', BuildRequest( completer_target = 'filetype_default', command_arguments = [ 'RestartServer' ], filetype = 'typescript', filepath = filepath ) ) completion_data = BuildRequest( filepath = filepath, filetype = 'typescript', contents = ReadFile( filepath ), force_semantic = True, line_num = 17, column_num = 6 ) response = app.post_json( '/completions', completion_data ) assert_that( response.json, has_entries( { 'completions': contains_inanyorder( CompletionEntryMatcher( 'methodA', extra_params = { 'menu_text': 'methodA (method) Foo.methodA(): void' } ), CompletionEntryMatcher( 'methodB', extra_params = { 'menu_text': 'methodB (method) Foo.methodB(): void' } ), CompletionEntryMatcher( 'methodC', extra_params = { 'menu_text': ( 'methodC (method) Foo.methodC(a: ' '{ foo: string; bar: number; }): void' ) } ), ) } ) )
def test_queries_with_dates_at_beginning_of_day_are_allowed(self): validation_result = validate_request_args({ 'period': 'day', 'start_at': '2000-02-02T00:00:00+00:00', 'end_at': '2000-02-19T00:00:00+00:00' }, False) assert_that(validation_result, is_valid())
def test_queries_for_hour_period_with_dates_at_middle_of_day_are_allowed(self): validation_result = validate_request_args({ 'period': 'hour', 'start_at': '2000-02-02T12:00:00+00:00', 'end_at': '2000-02-19T13:00:00+00:00' }, False) assert_that(validation_result, is_valid())
def test_period_with_just_positive_duration(self): validation_result = validate_request_args({ 'period': 'day', 'duration': '3', }) assert_that(validation_result, is_valid())
def test_just_end_at_isnt_allowed(self): validation_result = validate_request_args({ 'end_at': '2000-02-02T00:00:00+00:00', }) assert_that(validation_result, is_invalid_with_message( "Use of 'end_at' requires 'start_at' or 'duration'"))
def test_queries_sorting_by_invalid_field_names_are_disallowed(self): validation_result = validate_request_args({ 'sort_by': 'with-hyphen:ascending' }) assert_that(validation_result, is_invalid_with_message( 'Cannot sort by an invalid field name' ))
def test_that_inclusive_queries(self): validation_result = validate_request_args({ 'inclusive': 'true', 'start_at': '2012-12-01T00:00:00Z', 'end_at': '2012-12-01T00:00:00Z', }) assert_that(validation_result, is_valid())
def test_queries_with_grouping_on_internal_fields_are_disallowed(self): validation_result = validate_request_args({ "group_by": "_internal" }) assert_that(validation_result, is_invalid_with_message( "Cannot group by internal fields, internal fields " "start with an underscore"))
def test_queries_with_unrecognized_sort_by_values_are_disallowed(self): validation_result = validate_request_args({ 'sort_by': 'foo:random', }) assert_that( validation_result, is_invalid_with_message( 'Unrecognised sort direction. Supported directions ' 'include: ascending, descending') )
def test_filter_by_prefix_with_invalid_field_names_is_disallowed(self): validation_result = validate_request_args({ 'filter_by_prefix': 'with-hyphen:bar' }) assert_that(validation_result, is_invalid_with_message( 'Cannot filter by an invalid field name' ))
def test_queries_with_will_formatted_starts_and_ends_are_allowed(self): validation_result = validate_request_args({ 'period': 'week', 'start_at': '2010-01-01T00:10:10+00:00', 'end_at': '2010-01-07T00:10:10+00:00', }) assert_that( validation_result, is_valid() )
def test_find_virtual_disk(self): spec = vim.vm.ConfigSpec() vm_config = self.vm_config devices = self.dummy_devices() for device in devices: vm_config.add_device(spec, device) cfg_info = FakeConfigInfo() device_type = vim.vm.device.VirtualDisk datastore = "ds1" filename = "folder/foo" path = vmdk_path(datastore, filename) find_disk = vm_config.disk_matcher(datastore, filename) disk = vm_config.find_device(devices, device_type, matcher=find_disk) assert_that(disk, equal_to(None)) vm_config.add_scsi_disk(cfg_info, spec, datastore, "nope") self.assertRaises(DeviceNotFoundException, vm_config.get_device, devices, device_type, matcher=find_disk) vm_config.add_scsi_disk(cfg_info, spec, datastore, filename) device_changes = spec.deviceChange device_list = [] for device_change in device_changes: device_list.append(device_change.device) disk = vm_config.find_device(device_list, device_type, matcher=find_disk) assert_that(disk.backing.fileName, equal_to(path))
def RawResponse_ConvertedFromOmniCompleter_test(): vim_results = [ { "word": "WORD", "abbr": "ABBR", "menu": "MENU", "kind": "KIND", "info": "INFO" }, { "word": "WORD2", "abbr": "ABBR2", "menu": "MENU2", "kind": "KIND2", "info": "INFO" }, { "word": "WORD", "abbr": "ABBR", }, { }, ] expected_results = [ has_entries( { "insertion_text": "WORD", "menu_text": "ABBR", "extra_menu_info": "MENU", "kind": [ "KIND" ], "detailed_info": "INFO" } ), has_entries( { "insertion_text": "WORD2", "menu_text": "ABBR2", "extra_menu_info": "MENU2", "kind": [ "KIND2" ], "detailed_info": "INFO" } ), has_entries( { "insertion_text": "WORD", "menu_text": "ABBR", } ), has_entries( { } ), ] request = BuildOmnicompletionRequest( vim_results ) results = request.RawResponse() eq_( len( results ), len( expected_results ) ) for result, expected_result in zip( results, expected_results ): assert_that( result, expected_result )
def test_create_lun_with_muitl_property(self): pool = UnityPool(_id='pool_1', cli=t_rest()) lun = pool.create_lun("LunName", 100, description="Hello World", is_thin=True, is_repl_dst=True, tiering_policy=TieringPolicyEnum.AUTOTIER_HIGH) assert_that(lun, instance_of(UnityLun))
def test_calls_subscribed(broker, listener): event = "test" sentinel = object() broker.subscribe(event, listener.test_cb) broker.publish(event, s=sentinel) assert_that(listener.test_cb, called_once_with(s=sentinel))
def test_encode_list(self): call_log_1 = { 'Call Date': '01/30/2013 00:00:00', 'Caller': 'source1 (1001)', 'Called': '2001', 'Period': '1', 'user Field': '' } call_log_2 = { 'Call Date': '01/31/2013 00:00:00', 'Caller': u'soùrce2 (1002)', 'Called': '2002', 'Period': '2', 'user Field': 'userfield' } call_logs = [call_log_1, call_log_2] expected_result = textwrap.dedent('''\ %s\r 01/30/2013 00:00:00,source1 (1001),2001,1,\r 01/31/2013 00:00:00,soùrce2 (1002),2002,2,userfield\r ''' % ','.join(CSV_HEADERS)) result = serializer.encode_list(call_logs) assert_that(result, equal_to(expected_result))
def test_create_filesystem_success(self): pool = UnityPool(_id='pool_1', cli=t_rest()) fs = pool.create_filesystem( 'nas_2', 'fs3', 3 * 1024 ** 3, proto=FSSupportedProtocolEnum.CIFS, tiering_policy=TieringPolicyEnum.AUTOTIER_HIGH) assert_that(fs.get_id(), equal_to('fs_12'))
def test_it_offers_a_way_to_mark_a_goal(self): self.browser.visit("http://localhost:{port}/#new_goal".format(port=CLIENT_SERVER_PORT)) self.browser.fill("scoredBy", "23") self.browser.fill("assistedBy", "10") self.browser.find_by_id('markGoal').click() assert_that(self.browser.find_by_id("message").text, equal_to("Goal marked"))
def test_moves_track_of_album(): chevere = build.track(track_title="Chevere!") salsa_coltrane = build.track(track_title="Salsa Coltrane") honeycomb = build.album(tracks=[salsa_coltrane, chevere]) director.move_track_of(honeycomb)(0, 1) assert_that(honeycomb.tracks, contains(chevere, salsa_coltrane), "reordered tracks")
def GetCompletions_ClangCompleter_ForceSemantic_OnlyFileteredCompletions_test(): app = TestApp( handlers.app ) contents = """ int main() { int foobar; int floozar; int gooboo; int bleble; fooar } """ # 0-based line and column! completion_data = BuildRequest( filepath = '/foo.cpp', filetype = 'cpp', force_semantic = True, contents = contents, line_num = 8, column_num = 7, start_column = 7, query = 'fooar', compilation_flags = ['-x', 'c++'] ) results = app.post_json( '/completions', completion_data ).json assert_that( results, contains_inanyorder( CompletionEntryMatcher( 'foobar' ), CompletionEntryMatcher( 'floozar' ) ) )
def test_ignores_invalid_tracks(track_catalog): valid_track = track_catalog.add_track("valid.mp3") album = build.album() director.add_tracks(album, "invalid.mp3", "valid.mp3", from_catalog=track_catalog) assert_that(album.tracks, contains(valid_track), "valid tracks in album")
def edit(self, config): result = self.nc.edit_config(target="candidate", config=dict_2_etree({ "config": { "configuration": config } })) assert_that(result.xpath("//rpc-reply/ok"), has_length(1))
def GetCompletions_ClangCompleter_WorksWithExplicitFlags_test(): app = TestApp( handlers.app ) contents = """ struct Foo { int x; int y; char c; }; int main() { Foo foo; foo. } """ # 0-based line and column! completion_data = BuildRequest( filepath = '/foo.cpp', filetype = 'cpp', contents = contents, line_num = 10, column_num = 6, start_column = 6, compilation_flags = ['-x', 'c++'] ) results = app.post_json( '/completions', completion_data ).json assert_that( results, has_items( CompletionEntryMatcher( 'c' ), CompletionEntryMatcher( 'x' ), CompletionEntryMatcher( 'y' ) ) )
def test_adds_selected_tracks_to_album_in_order(track_catalog): tracks = [track_catalog.add_track(filename) for filename in ("first.mp3", "second.mp3", "third.mp3")] album = build.album() director.add_tracks(album, "first.mp3", "second.mp3", "third.mp3", from_catalog=track_catalog) assert_that(album.tracks, contains(*tracks), "tracks added to album")
def RunTest(app, test): """ Method to run a simple completion test and verify the result test is a dictionary containing: 'request': kwargs for BuildRequest 'expect': { 'response': server response code (e.g. httplib.OK) 'data': matcher for the server response json } """ contents = ReadFile(test["request"]["filepath"]) app.post_json( "/event_notification", _CombineRequest(test["request"], {"event_name": "FileReadyToParse", "contents": contents}), expect_errors=True, ) # We ignore errors here and we check the response code ourself. # This is to allow testing of requests returning errors. response = app.post_json( "/completions", _CombineRequest(test["request"], {"contents": contents}), expect_errors=True ) print("completer response: {0}".format(pformat(response.json))) eq_(response.status_code, test["expect"]["response"]) assert_that(response.json, test["expect"]["data"])
def _check_that(actual, expected): try: hamcrest.assert_that(actual, expected) except AssertionError as ex: msg = ex.args[0] return False, msg return True, None
def step_then_no_colors_are_used(context): assert_that(context.used_colors, has_length(0))
def test_unit(self, sample_merch): item = create_merch() assert_that(item.unit, is_("szt.")) item.by_meter = True assert_that(item.unit, is_("m.b."))
def test_not_eq(self, sample_merch): other = create_merch(2) assert_that(sample_merch == other, is_(False))
def test_eq(self, sample_merch): other = create_merch(1) assert_that(sample_merch == other, is_(True))
def test_reset(self, create_merchandise_dialog): create_merchandise_dialog.line_edit_code.insert("sample code") create_merchandise_dialog.line_edit_description.insert( "sample description") create_merchandise_dialog.radio_button_metre.setChecked(True) create_merchandise_dialog.line_edit_discount_group.insert( "sample discount group") create_merchandise_dialog.spin_box_price.setValue(9.99) create_merchandise_dialog.reset() assert_that(create_merchandise_dialog.line_edit_code.text(), is_(empty())) assert_that(create_merchandise_dialog.line_edit_description.text(), is_(empty())) assert_that(create_merchandise_dialog.radio_button_metre, is_(unchecked())) assert_that(create_merchandise_dialog.radio_button_piece, is_(checked())) assert_that(create_merchandise_dialog.line_edit_discount_group.text(), is_(empty())) assert_that(create_merchandise_dialog.spin_box_price.value(), is_(0.0))
def test_initial_state(self, create_merchandise_dialog, sample_groups): # todo: other translations assert_that(create_merchandise_dialog.windowTitle(), is_("Create merchandise")) model = create_merchandise_dialog.line_edit_discount_group.completer( ).completionModel() assert_that( model.match(model.index(0, 0), Qt.DisplayRole, sample_groups[0])) assert_that( model.match(model.index(1, 0), Qt.DisplayRole, sample_groups[1])) assert_that(create_merchandise_dialog.line_edit_code.text(), is_(empty())) assert_that(create_merchandise_dialog.line_edit_description.text(), is_(empty())) assert_that(create_merchandise_dialog.radio_button_metre, is_(unchecked())) assert_that(create_merchandise_dialog.radio_button_piece, is_(checked())) assert_that(create_merchandise_dialog.line_edit_discount_group.text(), is_(empty())) assert_that(create_merchandise_dialog.spin_box_price.decimals(), is_(2)) assert_that(create_merchandise_dialog.spin_box_price.minimum(), is_(0.0)) assert_that(create_merchandise_dialog.spin_box_price.singleStep(), is_(1.0)) assert_that(create_merchandise_dialog.spin_box_price.maximum(), is_(100000.0)) assert_that(create_merchandise_dialog.spin_box_price.value(), is_(0.0))
def step_then_following_colors_are_used(context): assert context.table, "table<color> is required" used_colors = sorted(context.used_colors) expected_colors = [row[0] for row in context.table] # -- LIST-COMPARISON: assert_that(used_colors, contains(*sorted(expected_colors)))
def test_it_can_construct_default_core_props(self): core_props = CoreProperties.default() # verify ----------------------- assert_that(core_props, is_(instance_of(CoreProperties))) assert_that(core_props.content_type, is_(CT.OPC_CORE_PROPERTIES)) assert_that(core_props.partname, is_('/docProps/core.xml')) assert_that(core_props._element, is_(instance_of(CT_CoreProperties))) assert_that(core_props.title, is_('PowerPoint Presentation')) assert_that(core_props.last_modified_by, is_('python-pptx')) assert_that(core_props.revision, is_(1)) # core_props.modified only stores time with seconds resolution, so # comparison needs to be a little loose (within two seconds) modified_timedelta = datetime.utcnow() - core_props.modified max_expected_timedelta = timedelta(seconds=2) assert_that(modified_timedelta, less_than(max_expected_timedelta))
def step_impl(context): global GLOBAL_TIMESTAMP while not GLOBAL_TIMESTAMP: time.sleep(1) assert_that(context.msg.header.timestamp, equal_to(GLOBAL_TIMESTAMP))
def test_list(self, token_1, token_2, tenant_uuid): result = self._session_dao.list_() assert_that( result, contains_inanyorder( has_entries( uuid=token_1['session_uuid'], user_uuid=token_1['auth_id'], tenant_uuid=tenant_uuid, ), has_entries(uuid=token_2['session_uuid'], user_uuid=token_2['auth_id']), ), ) result = self._session_dao.list_(tenant_uuids=[TENANT_UUID_1]) assert_that( result, contains_inanyorder(has_entries(uuid=token_1['session_uuid'])) ) result = self._session_dao.list_(tenant_uuids=[]) assert_that(result, empty()) result = self._session_dao.list_(order='mobile', direction='desc') assert_that( result, contains( has_entries(uuid=token_1['session_uuid']), has_entries(uuid=token_2['session_uuid']), ), ) result = self._session_dao.list_(order='mobile', direction='asc', limit=1) assert_that(result, contains(has_entries(uuid=token_2['session_uuid']))) result = self._session_dao.list_(order='mobile', direction='asc', offset=1) assert_that(result, contains(has_entries(uuid=token_1['session_uuid']))) result = self._session_dao.list_(user_uuid=token_1['auth_id']) assert_that(result, contains(has_entries(uuid=token_1['session_uuid'])))
def step_impl(context, exceptions): assert_that(context.exceptions, is_(exceptions))
def check_normal_resp_base_info(context): """ 只校验code为0000 """ assert_that(context.data['code'], equal_to(str(RESP_CODE_ENUM.SUCCESS)), "返回正常报文,code应该为0000")
def step_impl(context, leader_name): assert_that(str(context.leader_allotype), is_(leader_name))
def step_impl(context, unknowns): assert_that(context.unknowns, is_(unknowns))
def test_given_no_rabbitmq_when_status_then_rabbitmq_fail(self): result = self.calld.status() assert_that(result['bus_consumer']['status'], equal_to('fail'))
def step_impl(context, known): assert_that(str(context.known), is_(known))
def test_given_no_ari_when_status_then_ari_fail(self): result = self.calld.status() assert_that(result['ari']['status'], equal_to('fail'))
def rabbitmq_is_down(): result = self.calld.status() assert_that(result['bus_consumer']['status'], equal_to('fail'))
def CompatibleWithCurrentCore_Compatible_test( logger ): assert_that( CompatibleWithCurrentCore(), equal_to( 0 ) ) assert_that( logger.method_calls, empty() )
def ari_is_down(): result = self.calld.status() assert_that(result['ari']['status'], equal_to('fail'))
def GetStandardLibraryIndexInSysPath_ErrorIfNoStandardLibrary_test( *args ): assert_that( calling( GetStandardLibraryIndexInSysPath ), raises( RuntimeError, 'Could not find standard library path in Python path.' ) )
def assert_bits(context): assert_that(context.outcome, is_(close_to(value=context.expected, delta=DELTA))) assert_that(context.reverse_outcome, is_(close_to(value=context.source, delta=DELTA))) return
def AddNearestThirdPartyFoldersToSysPath_Failure_test(): assert_that( calling( AddNearestThirdPartyFoldersToSysPath ).with_args( os.path.expanduser( '~' ) ), raises( RuntimeError, '.*third_party folder.*' ) )
def GetStandardLibraryIndexInSysPath_FindEmbeddedStandardLibrary_test( *args ): assert_that( GetStandardLibraryIndexInSysPath(), equal_to( 1 ) )
def test_parse_empty_csv(self): csv_stream = _string_io("") data = _traverse(parse_csv(csv_stream)) assert_that(data, is_([]))
def AddNearestThirdPartyFoldersToSysPath_ErrorIfNoStandardLibrary_test( *args ): assert_that( calling( AddNearestThirdPartyFoldersToSysPath ).with_args( __file__ ), raises( RuntimeError, 'Could not find standard library path in Python path.' ) )
def test_handles_emptylines(self): text = "q\n\rw\r\r\ne" lines_list = list(lines(_string_io(text))) assert_that(lines_list, is_(["q\n", "\r", "w\r", "\r\n", "e"]))
def CompatibleWithCurrentCore_Outdated_NoVersionMatch_test( logger, *args ): assert_that( CompatibleWithCurrentCore(), equal_to( 7 ) ) assert_that( logger.method_calls, has_length( 1 ) ) logger.error.assert_called_with( 'ycm_core library too old; PLEASE RECOMPILE by running the build.py ' 'script. See the documentation for more details.' )
def test_handles_CR_LF_and_CRLF(self): text = "1\n2\r3\r\n4" lines_list = list(lines(_string_io(text))) assert_that(lines_list, is_(["1\n", "2\r", "3\r\n", "4"]))
def test_ignores_trailing_empty_line(self): text = "asd\n" lines_list = list(lines(_string_io(text))) assert_that(lines_list, is_(["asd\n"]))