Massively reduce the amount of code needed for linter tests

autoload/ale/assert.vim

@@ -1,3 +1,9 @@
+let s:chain_results = []
+
+function! ale#assert#WithChainResults(...) abort
+    let s:chain_results = a:000
+endfunction
+
 function! s:GetLinter() abort
     let l:linters = ale#linter#GetLintersLoaded()
     let l:filetype_linters = get(values(l:linters), 0, [])
@@ -21,15 +27,31 @@ function! ale#assert#Linter(expected_executable, expected_command) abort
     let l:executable = ale#linter#GetExecutable(l:buffer, l:linter)
 
     if has_key(l:linter, 'command_chain')
-        let l:command = []
+        let l:callbacks = map(copy(l:linter.command_chain), 'v:val.callback')
 
-        for l:chain_item in l:linter.command_chain
-            if empty(l:command)
-                call add(l:command, call(l:chain_item.callback, [l:buffer]))
+        " If the expected command is a string, just check the last one.
+        if type(a:expected_command) is type('')
+            if len(l:callbacks) is 1
+                let l:command = call(l:callbacks[0], [l:buffer])
             else
-                call add(l:command, call(l:chain_item.callback, [l:buffer, []]))
+                let l:input = get(s:chain_results, len(l:callbacks) - 2, [])
+                let l:command = call(l:callbacks[-1], [l:buffer, l:input])
             endif
-        endfor
+        else
+            let l:command = []
+            let l:chain_index = 0
+
+            for l:Callback in l:callbacks
+                if l:chain_index is 0
+                    call add(l:command, call(l:Callback, [l:buffer]))
+                else
+                    let l:input = get(s:chain_results, l:chain_index - 1, [])
+                    call add(l:command, call(l:Callback, [l:buffer, l:input]))
+                endif
+
+                let l:chain_index += 1
+            endfor
+        endif
     else
         let l:command = ale#linter#GetCommand(l:buffer, l:linter)
         " Replace %e with the escaped executable, so tests keep passing after
@@ -42,9 +64,96 @@ function! ale#assert#Linter(expected_executable, expected_command) abort
     \   [l:executable, l:command]
 endfunction
 
-command! -nargs=+ AssertLinter :call ale#assert#Linter(<args>)
+function! ale#assert#LinterNotExecuted() abort
+    let l:buffer = bufnr('')
+    let l:linter = s:GetLinter()
+    let l:executable = ale#linter#GetExecutable(l:buffer, l:linter)
+
+    Assert empty(l:executable), "The linter will be executed when it shouldn't be"
+endfunction
+
+function! ale#assert#LSPOptions(expected_options) abort
+    let l:buffer = bufnr('')
+    let l:linter = s:GetLinter()
+    let l:initialization_options = ale#lsp_linter#GetOptions(l:buffer, l:linter)
+
+    AssertEqual a:expected_options, l:initialization_options
+endfunction
+
+function! ale#assert#LSPLanguage(expected_language) abort
+    let l:buffer = bufnr('')
+    let l:linter = s:GetLinter()
+    let l:language = ale#util#GetFunction(l:linter.language_callback)(l:buffer)
+
+    AssertEqual a:expected_language, l:language
+endfunction
+
+function! ale#assert#LSPProject(expected_root) abort
+    let l:buffer = bufnr('')
+    let l:linter = s:GetLinter()
+    let l:root = ale#util#GetFunction(l:linter.project_root_callback)(l:buffer)
+
+    AssertEqual a:expected_root, l:root
+endfunction
 
 " A dummy function for making sure this module is loaded.
-function! ale#assert#Init() abort
+function! ale#assert#SetUpLinterTest(filetype, name) abort
+    " Set up a marker so ALE doesn't create real random temporary filenames.
+    let g:ale_create_dummy_temporary_file = 1
+
+    " Remove current linters.
     call ale#linter#Reset()
+    call ale#linter#PreventLoading(a:filetype)
+
+    let l:prefix = 'ale_' . a:filetype . '_' . a:name
+    let b:filter_expr = 'v:val[: len(l:prefix) - 1] is# l:prefix'
+
+    Save g:ale_c_build_dir
+    unlet! g:ale_c_build_dir
+
+    " Save and clear linter variables.
+    " We'll load the runtime file to reset them to defaults.
+    for l:key in filter(keys(g:), b:filter_expr)
+        execute 'Save g:' . l:key
+        unlet g:[l:key]
+    endfor
+
+    unlet! b:ale_c_build_dir
+
+    for l:key in filter(keys(b:), b:filter_expr)
+        unlet b:[l:key]
+    endfor
+
+    execute 'runtime ale_linters/' . a:filetype . '/' . a:name . '.vim'
+
+    call ale#test#SetDirectory('/testplugin/test/command_callback')
+
+    command! -nargs=+ WithChainResults :call ale#assert#WithChainResults(<args>)
+    command! -nargs=+ AssertLinter :call ale#assert#Linter(<args>)
+    command! -nargs=0 AssertLinterNotExecuted :call ale#assert#LinterNotExecuted()
+    command! -nargs=+ AssertLSPOptions :call ale#assert#LSPOptions(<args>)
+    command! -nargs=+ AssertLSPLanguage :call ale#assert#LSPLanguage(<args>)
+    command! -nargs=+ AssertLSPProject :call ale#assert#LSPProject(<args>)
+endfunction
+
+function! ale#assert#TearDownLinterTest() abort
+    unlet! g:ale_create_dummy_temporary_file
+    let s:chain_results = []
+
+    delcommand WithChainResults
+    delcommand AssertLinter
+    delcommand AssertLinterNotExecuted
+    delcommand AssertLSPOptions
+    delcommand AssertLSPLanguage
+    delcommand AssertLSPProject
+
+    call ale#test#RestoreDirectory()
+
+    Restore
+
+    call ale#linter#Reset()
+
+    if exists('*ale#semver#ResetVersionCache')
+        call ale#semver#ResetVersionCache()
+    endif
 endfunction