81c73da3b9
A new function is added here which will later be modified for public use in linter and fixer callbacks. All linting and fixing now goes through this new function, to prove that it works in all cases.
804 lines
19 KiB
Plaintext
804 lines
19 KiB
Plaintext
Before:
|
|
Save g:ale_fixers
|
|
Save &shell
|
|
Save g:ale_enabled
|
|
Save g:ale_fix_on_save
|
|
Save g:ale_lint_on_save
|
|
Save g:ale_echo_cursor
|
|
|
|
silent! cd /testplugin/test/fix
|
|
|
|
let g:ale_enabled = 0
|
|
let g:ale_echo_cursor = 0
|
|
let g:ale_run_synchronously = 1
|
|
unlet! g:ale_run_synchronously_callbacks
|
|
let g:ale_set_lists_synchronously = 1
|
|
let g:ale_fix_buffer_data = {}
|
|
let g:ale_fixers = {
|
|
\ 'testft': [],
|
|
\}
|
|
|
|
let g:pre_success = 0
|
|
let g:post_success = 0
|
|
augroup VaderTest
|
|
autocmd!
|
|
autocmd User ALEFixPre let g:pre_success = 1
|
|
autocmd User ALEFixPost let g:post_success = 1
|
|
augroup END
|
|
|
|
if !has('win32')
|
|
let &shell = '/bin/bash'
|
|
endif
|
|
|
|
call ale#test#SetDirectory('/testplugin/test')
|
|
call ale#test#SetFilename('test.txt')
|
|
call ale#linter#PreventLoading('testft')
|
|
|
|
function AddCarets(buffer, done, lines) abort
|
|
" map() is applied to the original lines here.
|
|
" This way, we can ensure that defensive copies are made.
|
|
return map(a:lines, '''^'' . v:val')
|
|
endfunction
|
|
|
|
function AddDollars(buffer, done, lines) abort
|
|
return map(a:lines, '''$'' . v:val')
|
|
endfunction
|
|
|
|
function DoNothing(buffer, done, lines) abort
|
|
return 0
|
|
endfunction
|
|
|
|
function CatLine(buffer, done, lines) abort
|
|
return {'command': 'cat - <(echo d)'}
|
|
endfunction
|
|
|
|
function CatLineOneArg(buffer) abort
|
|
return {'command': 'cat - <(echo d)'}
|
|
endfunction
|
|
|
|
function ReplaceWithTempFile(buffer, done, lines) abort
|
|
return {'command': 'echo x > %t', 'read_temporary_file': 1}
|
|
endfunction
|
|
|
|
function CatWithTempFile(buffer, done, lines) abort
|
|
return {'command': 'cat %t <(echo d)'}
|
|
endfunction
|
|
|
|
function RemoveLastLine(buffer, done, lines) abort
|
|
return ['a', 'b']
|
|
endfunction
|
|
|
|
function RemoveLastLineOneArg(buffer) abort
|
|
return ['a', 'b']
|
|
endfunction
|
|
|
|
function! TestCallback(buffer, output)
|
|
return [{'lnum': 1, 'col': 1, 'text': 'xxx'}]
|
|
endfunction
|
|
|
|
function! FirstChainCallback(buffer)
|
|
return {'command': 'echo echoline', 'chain_with': 'SecondChainCallback'}
|
|
endfunction
|
|
|
|
function! FirstChainCallbackSkipped(buffer)
|
|
let l:ChainWith = 'SecondChainCallback'
|
|
|
|
" Test with lambdas where support is available.
|
|
if has('lambda')
|
|
let l:ChainWith = {buffer, output -> SecondChainCallback(buffer, output)}
|
|
endif
|
|
|
|
return {'command': '', 'chain_with': l:ChainWith}
|
|
endfunction
|
|
|
|
function! FirstChainCallbackSecondSkipped(buffer)
|
|
return {'command': 'echo skipit', 'chain_with': 'SecondChainCallback'}
|
|
endfunction
|
|
|
|
function! SecondChainCallback(buffer, output)
|
|
let l:previous_line = empty(a:output)
|
|
\ ? 'emptydefault'
|
|
\ : join(split(a:output[0]))
|
|
|
|
if l:previous_line is# 'skipit'
|
|
return {'command': '', 'chain_with': 'ThirdChainCallback'}
|
|
endif
|
|
|
|
return {
|
|
\ 'command': 'echo ' . l:previous_line,
|
|
\ 'chain_with': 'ThirdChainCallback',
|
|
\}
|
|
endfunction
|
|
|
|
function! ThirdChainCallback(buffer, output, input)
|
|
let l:previous_line = empty(a:output)
|
|
\ ? 'thirddefault'
|
|
\ : join(split(a:output[0]))
|
|
|
|
return a:input + [l:previous_line]
|
|
endfunction
|
|
|
|
function! ChainWhereLastIsSkipped(buffer)
|
|
return {'command': 'echo echoline', 'chain_with': 'ChainEndSkipped'}
|
|
endfunction
|
|
|
|
function! ChainEndSkipped(buffer, output)
|
|
return {'command': ''}
|
|
endfunction
|
|
|
|
" echo will output a single blank line, and we should ingore it.
|
|
function! IgnoredEmptyOutput(buffer, done, output)
|
|
return {'command': has('win32') ? 'echo(' : 'echo'}
|
|
endfunction
|
|
|
|
function! EchoLineNoPipe(buffer, done, output)
|
|
return {'command': 'echo new line', 'read_buffer': 0}
|
|
endfunction
|
|
|
|
function! SetUpLinters()
|
|
call ale#linter#Define('testft', {
|
|
\ 'name': 'testlinter',
|
|
\ 'callback': 'TestCallback',
|
|
\ 'executable': 'true',
|
|
\ 'command': 'true',
|
|
\})
|
|
endfunction
|
|
|
|
function GetLastMessage()
|
|
redir => l:output
|
|
silent mess
|
|
redir END
|
|
|
|
let l:lines = split(l:output, "\n")
|
|
|
|
return empty(l:lines) ? '' : l:lines[-1]
|
|
endfunction
|
|
|
|
function! FixWithJSONPostProcessing(buffer) abort
|
|
let l:ProcessWith = 'JSONPostProcessor'
|
|
|
|
" Test with lambdas where support is available.
|
|
if has('lambda')
|
|
let l:ProcessWith = {buffer, output -> JSONPostProcessor(buffer, output)}
|
|
endif
|
|
|
|
" Escaping needs to be handled specially for CMD on Windows.
|
|
let l:json_string = has('win32')
|
|
\ ? '{"output":["x","y","z"]}'
|
|
\ : ale#Escape('{"output": ["x", "y", "z"]}')
|
|
|
|
return {
|
|
\ 'command': 'echo ' . l:json_string,
|
|
\ 'read_buffer': 0,
|
|
\ 'process_with': l:ProcessWith,
|
|
\}
|
|
endfunction
|
|
|
|
function! JSONPostProcessor(buffer, output) abort
|
|
return json_decode(a:output[0]).output
|
|
endfunction
|
|
|
|
After:
|
|
Restore
|
|
unlet! g:ale_run_synchronously
|
|
unlet! g:ale_set_lists_synchronously
|
|
unlet! g:ale_run_synchronously_callbacks
|
|
unlet! g:ale_emulate_job_failure
|
|
unlet! b:ale_fixers
|
|
unlet! b:ale_fix_on_save
|
|
unlet! b:ale_quitting
|
|
delfunction AddCarets
|
|
delfunction AddDollars
|
|
delfunction DoNothing
|
|
delfunction CatLine
|
|
delfunction CatLineOneArg
|
|
delfunction ReplaceWithTempFile
|
|
delfunction CatWithTempFile
|
|
delfunction RemoveLastLine
|
|
delfunction RemoveLastLineOneArg
|
|
delfunction TestCallback
|
|
delfunction FirstChainCallback
|
|
delfunction FirstChainCallbackSkipped
|
|
delfunction FirstChainCallbackSecondSkipped
|
|
delfunction SecondChainCallback
|
|
delfunction ThirdChainCallback
|
|
delfunction ChainWhereLastIsSkipped
|
|
delfunction ChainEndSkipped
|
|
delfunction SetUpLinters
|
|
delfunction GetLastMessage
|
|
delfunction IgnoredEmptyOutput
|
|
delfunction EchoLineNoPipe
|
|
delfunction FixWithJSONPostProcessing
|
|
delfunction JSONPostProcessor
|
|
|
|
augroup VaderTest
|
|
autocmd!
|
|
augroup END
|
|
|
|
augroup! VaderTest
|
|
|
|
call ale#test#RestoreDirectory()
|
|
|
|
call ale#fix#registry#ResetToDefaults()
|
|
call ale#linter#Reset()
|
|
|
|
setlocal buftype=nofile
|
|
|
|
if filereadable('fix_test_file')
|
|
call delete('fix_test_file')
|
|
endif
|
|
|
|
call setloclist(0, [])
|
|
|
|
let g:ale_fix_buffer_data = {}
|
|
|
|
" Clear the messages between tests.
|
|
echomsg ''
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should complain when there are no functions to call):
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
AssertEqual 'No fixers have been defined. Try :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALEFix should apply simple functions):
|
|
let g:ale_fixers.testft = ['AddCarets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The first function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should apply simple functions in a chain):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Both functions should be used):
|
|
$^a
|
|
$^b
|
|
$^c
|
|
|
|
Execute(ALEFix should allow 0 to be returned to skip functions):
|
|
let g:ale_fixers.testft = ['DoNothing', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only the second function should be applied):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(The * fixers shouldn't be used if an empty list is set for fixers):
|
|
let g:ale_fixers.testft = []
|
|
let g:ale_fixers['*'] = ['AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Nothing should be changed):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(* fixers should be used if no filetype is matched):
|
|
let g:ale_fixers = {'*': ['AddDollars']}
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The file should be changed):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should allow commands to be run):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should use fixers passed in commandline when provided):
|
|
let g:ale_fixers.testft = ['RemoveLastLine']
|
|
ALEFix AddCarets AddDollars
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only fixers passed via command line should be run):
|
|
$^a
|
|
$^b
|
|
$^c
|
|
|
|
Execute(ALEFix should allow temporary files to be read):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['x'])
|
|
2,3d
|
|
else
|
|
let g:ale_fixers.testft = ['ReplaceWithTempFile']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The line we wrote to the temporary file should be used here):
|
|
x
|
|
|
|
Execute(ALEFix should not read the temporary file when the option is not set):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatWithTempFile']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should allow jobs and simple functions to be combined):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['$x'])
|
|
2,3d
|
|
else
|
|
let g:ale_fixers.testft = ['ReplaceWithTempFile', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The lines from the temporary file should be modified):
|
|
$x
|
|
|
|
Execute(ALEFix should send lines modified by functions to jobs):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['$a', '$b', '$c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['AddDollars', 'CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The lines should first be modified by the function, then the job):
|
|
$a
|
|
$b
|
|
$c
|
|
d
|
|
|
|
Execute(ALEFix should skip commands when jobs fail to run):
|
|
let g:ale_emulate_job_failure = 1
|
|
let g:ale_fixers.testft = ['CatLine', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only the second function should be applied):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should handle strings for selecting a single function):
|
|
let g:ale_fixers.testft = 'AddCarets'
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The first function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should use functions from the registry):
|
|
call ale#fix#registry#Add('add_carets', 'AddCarets', [], 'Add some carets')
|
|
let g:ale_fixers.testft = ['add_carets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The registry function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should be able to remove the last line for files):
|
|
let g:ale_fixers.testft = ['RemoveLastLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should accept funcrefs):
|
|
let g:ale_fixers.testft = [function('RemoveLastLine')]
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should accept lambdas):
|
|
if has('nvim')
|
|
" NeoVim 0.1.7 can't interpret lambdas correctly, so just set the lines
|
|
" to make the test pass.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = [{buffer, done, lines -> lines + ['d']}]
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(There should be an extra line):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should user buffer-local fixer settings):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
let b:ale_fixers = {'testft': ['RemoveLastLine']}
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should allow Lists to be used for buffer-local fixer settings):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
let b:ale_fixers = ['RemoveLastLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should fix files on the save event):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
noautocmd silent file fix_test_file
|
|
call writefile(getline(1, '$'), 'fix_test_file')
|
|
|
|
let g:ale_fixers.testft = ['AddDollars']
|
|
|
|
" We have to set the buftype to empty so the file will be written.
|
|
setlocal buftype=
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
" We should save the file.
|
|
AssertEqual ['$a', '$b', '$c'], readfile('fix_test_file')
|
|
Assert !&modified, 'The was marked as ''modified'''
|
|
|
|
if !has('win32')
|
|
" We should have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be modified):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should not fix files on :wq):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
noautocmd silent file fix_test_file
|
|
call writefile(getline(1, '$'), 'fix_test_file')
|
|
|
|
let g:ale_fixers.testft = ['AddDollars']
|
|
|
|
" We have to set the buftype to empty so the file will be written.
|
|
setlocal buftype=
|
|
|
|
call ale#events#QuitEvent(bufnr(''))
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
" We should save the file.
|
|
AssertEqual ['a', 'b', 'c'], readfile('fix_test_file')
|
|
Assert &modified, 'The was not marked as ''modified'''
|
|
|
|
" We should not run the linter.
|
|
AssertEqual [], ale#test#GetLoclistWithoutModule()
|
|
|
|
Expect(The buffer should not be modified):
|
|
a
|
|
b
|
|
c
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should still lint with no linters to be applied):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
noautocmd silent file fix_test_file
|
|
|
|
let g:ale_fixers.testft = []
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable('fix_test_file'), 'The file should not have been saved'
|
|
|
|
if !has('win32')
|
|
" We have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should still lint when nothing was fixed on save):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
noautocmd silent file fix_test_file
|
|
|
|
let g:ale_fixers.testft = ['DoNothing']
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable('fix_test_file'), 'The file should not have been saved'
|
|
|
|
if !has('win32')
|
|
" We should have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ale#fix#InitBufferData() should set up the correct data):
|
|
noautocmd silent file fix_test_file
|
|
|
|
call ale#fix#InitBufferData(bufnr(''), 'save_file')
|
|
|
|
AssertEqual {
|
|
\ bufnr(''): {
|
|
\ 'temporary_directory_list': [],
|
|
\ 'done': 0,
|
|
\ 'lines_before': ['a', 'b', 'c'],
|
|
\ 'should_save': 1,
|
|
\ },
|
|
\}, g:ale_fix_buffer_data
|
|
|
|
Execute(ALEFix simple functions should be able to accept one argument, the buffer):
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(b:ale_fix_on_save = 1 should override g:ale_fix_on_save = 0):
|
|
let g:ale_fix_on_save = 0
|
|
let b:ale_fix_on_save = 1
|
|
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(b:ale_fix_on_save = 0 should override g:ale_fix_on_save = 1):
|
|
let g:ale_fix_on_save = 1
|
|
let b:ale_fix_on_save = 0
|
|
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix functions returning jobs should be able to accept one argument):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALE should print a message telling you something isn't a valid fixer when you type some nonsense):
|
|
let g:ale_fixers.testft = ['CatLine', 'invalidname']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual 'There is no fixer named `invalidname`. Check :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALE should complain about invalid fixers with minuses in the name):
|
|
let g:ale_fixers.testft = ['foo-bar']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual 'There is no fixer named `foo-bar`. Check :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALE should tolerate valid fixers with minuses in the name):
|
|
let g:ale_fixers.testft = ['prettier-standard']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Execute(Test fixing with chained callbacks):
|
|
let g:ale_fixers.testft = ['FirstChainCallback']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
" The buffer shouldn't be piped in for earlier commands in the chain.
|
|
AssertEqual
|
|
\ [
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo echoline')),
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo echoline')),
|
|
\ ],
|
|
\ map(ale#history#Get(bufnr(''))[-2:-1], 'string(v:val.command)')
|
|
|
|
Expect(The echoed line should be added):
|
|
a
|
|
b
|
|
c
|
|
echoline
|
|
|
|
Execute(Test fixing with chained callback where the first command is skipped):
|
|
let g:ale_fixers.testft = ['FirstChainCallbackSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The default line should be added):
|
|
a
|
|
b
|
|
c
|
|
emptydefault
|
|
|
|
Execute(Test fixing with chained callback where the second command is skipped):
|
|
let g:ale_fixers.testft = ['FirstChainCallbackSecondSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The default line should be added):
|
|
a
|
|
b
|
|
c
|
|
thirddefault
|
|
|
|
Execute(Test fixing with chained callback where the final callback is skipped):
|
|
let g:ale_fixers.testft = ['ChainWhereLastIsSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(Empty output should be ignored):
|
|
let g:ale_fixers.testft = ['IgnoredEmptyOutput']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(A temporary file shouldn't be piped into the command when disabled):
|
|
let g:ale_fixers.testft = ['EchoLineNoPipe']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo new line')),
|
|
\ string(ale#history#Get(bufnr(''))[-1].command)
|
|
|
|
" Remove trailing whitespace for Windows.
|
|
if has('win32')
|
|
%s/[[:space:]]*$//g
|
|
endif
|
|
|
|
Expect(The new line should be used):
|
|
new line
|
|
|
|
Execute(Post-processing should work):
|
|
let g:ale_fixers.testft = ['FixWithJSONPostProcessing']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines in the JSON should be used):
|
|
x
|
|
y
|
|
z
|
|
|
|
Execute(ALEFix should apply autocmds):
|
|
let g:ale_fixers.testft = ['AddCarets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual g:pre_success, 1
|
|
AssertEqual g:post_success, 1
|