a24d97ca6b
When the client sends a request to the server, if an extra conf file is found that is not already white/blacklisted, the server stops processing the request and tells the client that an unknown extra conf file has been found. The client then asks the user if that file should be loaded or not. Depending on the user's answer, the client sends a request to the server to load or ignore the extra conf file. Finally, the server loads the file or adds it to the blacklist. However, the initial request was not processed by the server and should be sent again.
604 lines
22 KiB
Python
604 lines
22 KiB
Python
# coding: utf-8
|
|
#
|
|
# Copyright (C) 2015-2018 YouCompleteMe contributors
|
|
#
|
|
# This file is part of YouCompleteMe.
|
|
#
|
|
# YouCompleteMe is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# YouCompleteMe is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import unicode_literals
|
|
from __future__ import print_function
|
|
from __future__ import division
|
|
from __future__ import absolute_import
|
|
# Not installing aliases from python-future; it's unreliable and slow.
|
|
from builtins import * # noqa
|
|
|
|
from ycm.tests.test_utils import ( CurrentWorkingDirectory, ExtendedMock,
|
|
MockVimBuffers, MockVimModule, VimBuffer,
|
|
VimSign )
|
|
MockVimModule()
|
|
|
|
import contextlib
|
|
import os
|
|
|
|
from ycm.tests import ( PathToTestFile, test_utils, YouCompleteMeInstance,
|
|
WaitUntilReady )
|
|
from ycm.vimsupport import SIGN_BUFFER_ID_INITIAL_VALUE
|
|
from ycmd.responses import ( BuildDiagnosticData, Diagnostic, Location, Range,
|
|
UnknownExtraConf, ServerError )
|
|
|
|
from hamcrest import ( assert_that, contains, empty, has_entries, has_entry,
|
|
has_item, has_items, has_key, is_not )
|
|
from mock import call, MagicMock, patch
|
|
from nose.tools import eq_, ok_
|
|
|
|
|
|
def PresentDialog_Confirm_Call( message ):
|
|
"""Return a mock.call object for a call to vimsupport.PresentDialog, as called
|
|
why vimsupport.Confirm with the supplied confirmation message"""
|
|
return call( message, [ 'Ok', 'Cancel' ] )
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def MockArbitraryBuffer( filetype ):
|
|
"""Used via the with statement, set up a single buffer with an arbitrary name
|
|
and no contents. Its filetype is set to the supplied filetype."""
|
|
|
|
# Arbitrary, but valid, single buffer open.
|
|
current_buffer = VimBuffer( os.path.realpath( 'TEST_BUFFER' ),
|
|
window = 1,
|
|
filetype = filetype )
|
|
|
|
with MockVimBuffers( [ current_buffer ], current_buffer ):
|
|
yield
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def MockEventNotification( response_method, native_filetype_completer = True ):
|
|
"""Mock out the EventNotification client request object, replacing the
|
|
Response handler's JsonFromFuture with the supplied |response_method|.
|
|
Additionally mock out YouCompleteMe's FiletypeCompleterExistsForFiletype
|
|
method to return the supplied |native_filetype_completer| parameter, rather
|
|
than querying the server"""
|
|
|
|
# We don't want the event to actually be sent to the server, just have it
|
|
# return success
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync',
|
|
return_value = MagicMock( return_value=True ) ):
|
|
|
|
# We set up a fake a Response (as called by EventNotification.Response)
|
|
# which calls the supplied callback method. Generally this callback just
|
|
# raises an apropriate exception, otherwise it would have to return a mock
|
|
# future object.
|
|
with patch( 'ycm.client.base_request._JsonFromFuture',
|
|
side_effect = response_method ):
|
|
|
|
# Filetype available information comes from the server, so rather than
|
|
# relying on that request, we mock out the check. The caller decides if
|
|
# filetype completion is available
|
|
with patch(
|
|
'ycm.youcompleteme.YouCompleteMe.FiletypeCompleterExistsForFiletype',
|
|
return_value = native_filetype_completer ):
|
|
|
|
yield
|
|
|
|
|
|
@patch( 'ycm.vimsupport.PostVimMessage', new_callable = ExtendedMock )
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_FileReadyToParse_NonDiagnostic_Error_test(
|
|
ycm, post_vim_message ):
|
|
|
|
# This test validates the behaviour of YouCompleteMe.HandleFileParseRequest
|
|
# in combination with YouCompleteMe.OnFileReadyToParse when the completer
|
|
# raises an exception handling FileReadyToParse event notification
|
|
ERROR_TEXT = 'Some completer response text'
|
|
|
|
def ErrorResponse( *args ):
|
|
raise ServerError( ERROR_TEXT )
|
|
|
|
with MockArbitraryBuffer( 'javascript' ):
|
|
with MockEventNotification( ErrorResponse ):
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
|
|
# The first call raises a warning
|
|
post_vim_message.assert_has_exact_calls( [
|
|
call( ERROR_TEXT, truncate = True )
|
|
] )
|
|
|
|
# Subsequent calls don't re-raise the warning
|
|
ycm.HandleFileParseRequest()
|
|
post_vim_message.assert_has_exact_calls( [
|
|
call( ERROR_TEXT, truncate = True )
|
|
] )
|
|
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
# But it does if a subsequent event raises again
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
post_vim_message.assert_has_exact_calls( [
|
|
call( ERROR_TEXT, truncate = True ),
|
|
call( ERROR_TEXT, truncate = True )
|
|
] )
|
|
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_FileReadyToParse_NonDiagnostic_Error_NonNative_test(
|
|
ycm ):
|
|
|
|
test_utils.VIM_MATCHES = []
|
|
test_utils.VIM_SIGNS = []
|
|
|
|
with MockArbitraryBuffer( 'javascript' ):
|
|
with MockEventNotification( None, False ):
|
|
ycm.OnFileReadyToParse()
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_MATCHES,
|
|
contains()
|
|
)
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains()
|
|
)
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_FileReadyToParse_NonDiagnostic_ConfirmExtraConf_test(
|
|
ycm ):
|
|
|
|
# This test validates the behaviour of YouCompleteMe.HandleFileParseRequest
|
|
# in combination with YouCompleteMe.OnFileReadyToParse when the completer
|
|
# raises the (special) UnknownExtraConf exception
|
|
FILE_NAME = 'a_file'
|
|
MESSAGE = ( 'Found ' + FILE_NAME + '. Load? \n\n(Question can be '
|
|
'turned off with options, see YCM docs)' )
|
|
|
|
def UnknownExtraConfResponse( *args ):
|
|
raise UnknownExtraConf( FILE_NAME )
|
|
|
|
with patch( 'ycm.client.base_request.BaseRequest.PostDataToHandler',
|
|
new_callable = ExtendedMock ) as post_data_to_handler:
|
|
with MockArbitraryBuffer( 'javascript' ):
|
|
with MockEventNotification( UnknownExtraConfResponse ):
|
|
|
|
# When the user accepts the extra conf, we load it
|
|
with patch( 'ycm.vimsupport.PresentDialog',
|
|
return_value = 0,
|
|
new_callable = ExtendedMock ) as present_dialog:
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'load_extra_conf_file' )
|
|
] )
|
|
|
|
# Subsequent calls don't re-raise the warning
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE )
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'load_extra_conf_file' )
|
|
] )
|
|
|
|
ok_( ycm.ShouldResendFileParseRequest() )
|
|
|
|
# But it does if a subsequent event raises again
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'load_extra_conf_file' ),
|
|
call( { 'filepath': FILE_NAME }, 'load_extra_conf_file' )
|
|
] )
|
|
|
|
ok_( ycm.ShouldResendFileParseRequest() )
|
|
|
|
post_data_to_handler.reset_mock()
|
|
|
|
# When the user rejects the extra conf, we reject it
|
|
with patch( 'ycm.vimsupport.PresentDialog',
|
|
return_value = 1,
|
|
new_callable = ExtendedMock ) as present_dialog:
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'ignore_extra_conf_file' )
|
|
] )
|
|
|
|
# Subsequent calls don't re-raise the warning
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE )
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'ignore_extra_conf_file' )
|
|
] )
|
|
|
|
ok_( ycm.ShouldResendFileParseRequest() )
|
|
|
|
# But it does if a subsequent event raises again
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
|
|
present_dialog.assert_has_exact_calls( [
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
PresentDialog_Confirm_Call( MESSAGE ),
|
|
] )
|
|
post_data_to_handler.assert_has_exact_calls( [
|
|
call( { 'filepath': FILE_NAME }, 'ignore_extra_conf_file' ),
|
|
call( { 'filepath': FILE_NAME }, 'ignore_extra_conf_file' )
|
|
] )
|
|
|
|
ok_( ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_FileReadyToParse_Diagnostic_Error_Native_test( ycm ):
|
|
test_utils.VIM_SIGNS = []
|
|
|
|
_Check_FileReadyToParse_Diagnostic_Error( ycm )
|
|
_Check_FileReadyToParse_Diagnostic_Warning( ycm )
|
|
_Check_FileReadyToParse_Diagnostic_Clean( ycm )
|
|
|
|
|
|
def _Check_FileReadyToParse_Diagnostic_Error( ycm ):
|
|
# Tests Vim sign placement and error/warning count python API
|
|
# when one error is returned.
|
|
def DiagnosticResponse( *args ):
|
|
start = Location( 1, 2, 'TEST_BUFFER' )
|
|
end = Location( 1, 4, 'TEST_BUFFER' )
|
|
extent = Range( start, end )
|
|
diagnostic = Diagnostic( [], start, extent, 'expected ;', 'ERROR' )
|
|
return [ BuildDiagnosticData( diagnostic ) ]
|
|
|
|
with MockArbitraryBuffer( 'cpp' ):
|
|
with MockEventNotification( DiagnosticResponse ):
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains(
|
|
VimSign( SIGN_BUFFER_ID_INITIAL_VALUE, 1, 'YcmError', 1 )
|
|
)
|
|
)
|
|
eq_( ycm.GetErrorCount(), 1 )
|
|
eq_( ycm.GetWarningCount(), 0 )
|
|
|
|
# Consequent calls to HandleFileParseRequest shouldn't mess with
|
|
# existing diagnostics, when there is no new parse request.
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains(
|
|
VimSign( SIGN_BUFFER_ID_INITIAL_VALUE, 1, 'YcmError', 1 )
|
|
)
|
|
)
|
|
eq_( ycm.GetErrorCount(), 1 )
|
|
eq_( ycm.GetWarningCount(), 0 )
|
|
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
# New identical requests should result in the same diagnostics.
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains(
|
|
VimSign( SIGN_BUFFER_ID_INITIAL_VALUE, 1, 'YcmError', 1 )
|
|
)
|
|
)
|
|
eq_( ycm.GetErrorCount(), 1 )
|
|
eq_( ycm.GetWarningCount(), 0 )
|
|
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
def _Check_FileReadyToParse_Diagnostic_Warning( ycm ):
|
|
# Tests Vim sign placement/unplacement and error/warning count python API
|
|
# when one warning is returned.
|
|
# Should be called after _Check_FileReadyToParse_Diagnostic_Error
|
|
def DiagnosticResponse( *args ):
|
|
start = Location( 2, 2, 'TEST_BUFFER' )
|
|
end = Location( 2, 4, 'TEST_BUFFER' )
|
|
extent = Range( start, end )
|
|
diagnostic = Diagnostic( [], start, extent, 'cast', 'WARNING' )
|
|
return [ BuildDiagnosticData( diagnostic ) ]
|
|
|
|
with MockArbitraryBuffer( 'cpp' ):
|
|
with MockEventNotification( DiagnosticResponse ):
|
|
ycm.OnFileReadyToParse()
|
|
ok_( ycm.FileParseRequestReady() )
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains(
|
|
VimSign( SIGN_BUFFER_ID_INITIAL_VALUE + 1, 2, 'YcmWarning', 1 )
|
|
)
|
|
)
|
|
eq_( ycm.GetErrorCount(), 0 )
|
|
eq_( ycm.GetWarningCount(), 1 )
|
|
|
|
# Consequent calls to HandleFileParseRequest shouldn't mess with
|
|
# existing diagnostics, when there is no new parse request.
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
contains(
|
|
VimSign( SIGN_BUFFER_ID_INITIAL_VALUE + 1, 2, 'YcmWarning', 1 )
|
|
)
|
|
)
|
|
eq_( ycm.GetErrorCount(), 0 )
|
|
eq_( ycm.GetWarningCount(), 1 )
|
|
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
def _Check_FileReadyToParse_Diagnostic_Clean( ycm ):
|
|
# Tests Vim sign unplacement and error/warning count python API
|
|
# when there are no errors/warnings left.
|
|
# Should be called after _Check_FileReadyToParse_Diagnostic_Warning
|
|
with MockArbitraryBuffer( 'cpp' ):
|
|
with MockEventNotification( MagicMock( return_value = [] ) ):
|
|
ycm.OnFileReadyToParse()
|
|
ycm.HandleFileParseRequest()
|
|
assert_that(
|
|
test_utils.VIM_SIGNS,
|
|
empty()
|
|
)
|
|
eq_( ycm.GetErrorCount(), 0 )
|
|
eq_( ycm.GetWarningCount(), 0 )
|
|
ok_( not ycm.ShouldResendFileParseRequest() )
|
|
|
|
|
|
@patch( 'ycm.youcompleteme.YouCompleteMe._AddUltiSnipsDataIfNeeded' )
|
|
@YouCompleteMeInstance( { 'collect_identifiers_from_tags_files': 1 } )
|
|
def EventNotification_FileReadyToParse_TagFiles_UnicodeWorkingDirectory_test(
|
|
ycm, *args ):
|
|
unicode_dir = PathToTestFile( 'uni¢𐍈d€' )
|
|
current_buffer_file = PathToTestFile( 'uni¢𐍈d€', 'current_buffer' )
|
|
current_buffer = VimBuffer( name = current_buffer_file,
|
|
contents = [ 'current_buffer_contents' ],
|
|
filetype = 'some_filetype' )
|
|
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
|
|
with CurrentWorkingDirectory( unicode_dir ):
|
|
with MockVimBuffers( [ current_buffer ], current_buffer, ( 1, 5 ) ):
|
|
ycm.OnFileReadyToParse()
|
|
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entries( {
|
|
'filepath': current_buffer_file,
|
|
'line_num': 1,
|
|
'column_num': 6,
|
|
'file_data': has_entries( {
|
|
current_buffer_file: has_entries( {
|
|
'contents': 'current_buffer_contents\n',
|
|
'filetypes': [ 'some_filetype' ]
|
|
} )
|
|
} ),
|
|
'event_name': 'FileReadyToParse',
|
|
'tag_files': has_item( PathToTestFile( 'uni¢𐍈d€', 'tags' ) )
|
|
} ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
|
|
@patch( 'ycm.youcompleteme.YouCompleteMe._AddUltiSnipsDataIfNeeded' )
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_BufferVisit_BuildRequestForCurrentAndUnsavedBuffers_test(
|
|
ycm, *args ):
|
|
|
|
current_buffer_file = os.path.realpath( 'current_buffer' )
|
|
current_buffer = VimBuffer( name = current_buffer_file,
|
|
number = 1,
|
|
contents = [ 'current_buffer_contents' ],
|
|
filetype = 'some_filetype',
|
|
modified = False )
|
|
modified_buffer_file = os.path.realpath( 'modified_buffer' )
|
|
modified_buffer = VimBuffer( name = modified_buffer_file,
|
|
number = 2,
|
|
contents = [ 'modified_buffer_contents' ],
|
|
filetype = 'some_filetype',
|
|
modified = True )
|
|
|
|
unmodified_buffer_file = os.path.realpath( 'unmodified_buffer' )
|
|
unmodified_buffer = VimBuffer( name = unmodified_buffer_file,
|
|
number = 3,
|
|
contents = [ 'unmodified_buffer_contents' ],
|
|
filetype = 'some_filetype',
|
|
modified = False )
|
|
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
|
|
with MockVimBuffers( [ current_buffer, modified_buffer, unmodified_buffer ],
|
|
current_buffer,
|
|
( 1, 5 ) ):
|
|
ycm.OnBufferVisit()
|
|
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entries( {
|
|
'filepath': current_buffer_file,
|
|
'line_num': 1,
|
|
'column_num': 6,
|
|
'file_data': has_entries( {
|
|
current_buffer_file: has_entries( {
|
|
'contents': 'current_buffer_contents\n',
|
|
'filetypes': [ 'some_filetype' ]
|
|
} ),
|
|
modified_buffer_file: has_entries( {
|
|
'contents': 'modified_buffer_contents\n',
|
|
'filetypes': [ 'some_filetype' ]
|
|
} )
|
|
} ),
|
|
'event_name': 'BufferVisit'
|
|
} ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
|
|
@YouCompleteMeInstance()
|
|
def EventNotification_BufferUnload_BuildRequestForDeletedAndUnsavedBuffers_test(
|
|
ycm ):
|
|
current_buffer_file = os.path.realpath( 'current_βuffer' )
|
|
current_buffer = VimBuffer( name = current_buffer_file,
|
|
number = 1,
|
|
contents = [ 'current_buffer_contents' ],
|
|
filetype = 'some_filetype',
|
|
modified = True )
|
|
|
|
deleted_buffer_file = os.path.realpath( 'deleted_βuffer' )
|
|
deleted_buffer = VimBuffer( name = deleted_buffer_file,
|
|
number = 2,
|
|
contents = [ 'deleted_buffer_contents' ],
|
|
filetype = 'some_filetype',
|
|
modified = False )
|
|
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
|
|
with MockVimBuffers( [ current_buffer, deleted_buffer ], current_buffer ):
|
|
ycm.OnBufferUnload( deleted_buffer.number )
|
|
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entries( {
|
|
'filepath': deleted_buffer_file,
|
|
'line_num': 1,
|
|
'column_num': 1,
|
|
'file_data': has_entries( {
|
|
current_buffer_file: has_entries( {
|
|
'contents': 'current_buffer_contents\n',
|
|
'filetypes': [ 'some_filetype' ]
|
|
} ),
|
|
deleted_buffer_file: has_entries( {
|
|
'contents': 'deleted_buffer_contents\n',
|
|
'filetypes': [ 'some_filetype' ]
|
|
} )
|
|
} ),
|
|
'event_name': 'BufferUnload'
|
|
} ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
|
|
@patch( 'ycm.vimsupport.CaptureVimCommand', return_value = """
|
|
fooGroup xxx foo bar
|
|
links to Statement""" )
|
|
@YouCompleteMeInstance( { 'seed_identifiers_with_syntax': 1 } )
|
|
def EventNotification_FileReadyToParse_SyntaxKeywords_SeedWithCache_test(
|
|
ycm, *args ):
|
|
|
|
current_buffer = VimBuffer( name = 'current_buffer',
|
|
filetype = 'some_filetype' )
|
|
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
|
|
with MockVimBuffers( [ current_buffer ], current_buffer ):
|
|
ycm.OnFileReadyToParse()
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
# Do not send again syntax keywords in subsequent requests.
|
|
ycm.OnFileReadyToParse()
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
is_not( has_key( 'syntax_keywords' ) ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
|
|
@patch( 'ycm.vimsupport.CaptureVimCommand', return_value = """
|
|
fooGroup xxx foo bar
|
|
links to Statement""" )
|
|
@YouCompleteMeInstance( { 'seed_identifiers_with_syntax': 1 } )
|
|
def EventNotification_FileReadyToParse_SyntaxKeywords_ClearCacheIfRestart_test(
|
|
ycm, *args ):
|
|
|
|
current_buffer = VimBuffer( name = 'current_buffer',
|
|
filetype = 'some_filetype' )
|
|
|
|
with patch( 'ycm.client.event_notification.EventNotification.'
|
|
'PostDataToHandlerAsync' ) as post_data_to_handler_async:
|
|
with MockVimBuffers( [ current_buffer ], current_buffer ):
|
|
ycm.OnFileReadyToParse()
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
|
|
'event_notification'
|
|
)
|
|
)
|
|
|
|
# Send again the syntax keywords after restarting the server.
|
|
ycm.RestartServer()
|
|
WaitUntilReady()
|
|
ycm.OnFileReadyToParse()
|
|
assert_that(
|
|
# Positional arguments passed to PostDataToHandlerAsync.
|
|
post_data_to_handler_async.call_args[ 0 ],
|
|
contains(
|
|
has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
|
|
'event_notification'
|
|
)
|
|
)
|