per testare i plugin vim

Question

Sto cercando alcuni strumenti per testare gli script di Vim. Gli script Vim

• DO unità/test funzionali o
• classi per qualche altra libreria (ad esempio moduli di Python unittest) che lo rende conveniente
  • lanciare vim con parametri che causano a fare alcuni test sul suo ambiente e
  • determinano dall'output indipendentemente dal fatto che sia passato o meno un determinato test.

Sono a conoscenza di un paio di script Vim che fare test di unità, ma sono una sorta di vagamente documentato e può o non può effettivamente essere utile:

vim-unit:

• pretende "per fornire script Vim con un semplice quadro unit test e gli strumenti"
• prima e unica versione (v0.1) è stato rilasciato nel 2004
• la documentazione non indica se funziona in modo affidabile o meno, a parte il fatto che è "tariffa [sic] da finito".

unit-test.vim:

• Questo sembra anche piuttosto sperimentale, e non può essere particolarmente affidabile.
• potrebbero essere stati abbandonati o back-accantonato: ultima commit era in 2009-11 (> 6 mesi fa)
• No etichettato revisioni sono state create (cioè non comunicati)

modo che le informazioni da parte di persone che hanno stanno usando uno di questi due moduli esistenti e/o collegamenti ad altre opzioni, più chiaramente utilizzabili, sono molto graditi.

Answer 1

Ho usato vim-unit prima. Per lo meno significa che non devi scrivere le tue funzioni AssertEquals e AssertTrue. Ha anche una bella funzione che ti permette di eseguire la funzione corrente, se inizia con "Test", posizionando il cursore all'interno del corpo della funzione e digitando :call VUAutoRun().

La documentazione è un po 'incerta e incompleta, ma se hai esperienza con altre librerie di test di XUnit non ti sarà familiare.

Nessuno degli script menzionati ha il modo di verificare le funzionalità specifiche di vim: non è possibile modificare i buffer e quindi verificare le aspettative sul risultato, quindi sarà necessario scrivere il proprio vimScript in modo verificabile. Ad esempio, passare le stringhe in funzioni anziché estrarle dai buffer con getline() all'interno della funzione stessa, restituire le stringhe invece di utilizzare setline(), quel genere di cose.

Answer 2

C'è un altro (puro VimL) UT plugin che sto mantenendo.

È documentato, viene fornito con diversi esempi ed è anche utilizzato dai miei altri plugin.

Ha lo scopo di testare solo i risultati delle funzioni e visualizzare i guasti nella finestra di aggiornamento rapido. Anche i callstacks di eccezione sono decodificati. AFAIK, è l'unico plug-in finora (o almeno il primo) che ha lo scopo di riempire la finestra del quickfix. Da allora, ho aggiunto script di supporto per produrre risultati di test con rspec (+ Vimrunner)

Si noti che, per verificare come un buffer viene modificato con mapping/snippet/..., si consiglia di utilizzare altri plugin . Ad esempio, provo i miei snippet C++ (da lh-cpp) su travis con VimRunner + RSpec.

Per quanto riguarda la sintassi, sembra che questo:

" Old way, to test boolean expressions 
Assert 1 > 2 
Assert 1 > 0 
Assert s:foo > s:Bar(g:var + 28)/strlen("foobar") 

AssertTxt! (s:foo > s:Bar(g:var+28), 
     \, s:foo." isn't bigger than s:Bar(".g:var."+28)") 

" New, recommended way to test relations 
AssertEquals('a', 'a') 
AssertDiffers('a', 'b') 
let dict = {} 
AssertIs(dict, dict) 
AssertMatch('abc', 'a') 
AssertRelation(1, '<', 2) 
AssertThrows 0 + [0] 

Answer 3

Ho avuto successo utilizzando Andrew Radev's Vimrunner in combinazione con RSpec ad entrambi i test di Vim plug-in e li ha installato su un server di integrazione continua.

In breve, Vimrunner utilizza la funzionalità client-server di Vim per attivare un server Vim e quindi inviare comandi remoti in modo da poter esaminare (e verificare) il risultato. È una gemma di Ruby quindi avrai bisogno di almeno una certa dimestichezza con Ruby, ma se ti metti il ​​tempo allora avrai tutta la potenza di RSpec per scrivere i tuoi test.

Ad esempio, un file chiamato spec/runspec.vim_spec.rb:

require "vimrunner" 
require "fileutils" 

describe "runspec.vim" do 
    before(:suite) do 
    VIM = Vimrunner.start_gui_vim 
    VIM.add_plugin(File.expand_path('../..', __FILE__), 'plugin/runspec.vim') 
    end 

    after(:all) do 
    VIM.kill 
    end 

    it "returns the current path if it ends in _test.rb" do 
    VIM.echo('runspec#SpecPath("foo_test.rb")').should == "foo_test.rb" 
    VIM.echo('runspec#SpecPath("bar/foo_test.rb")').should == "bar/foo_test.rb" 
    end 

    context "with a spec directory" do 
    before do 
     FileUtils.mkdir("spec") 
    end 

    after do 
     FileUtils.remove_entry_secure("spec") 
    end 

    it "finds a spec with the same name" do 
     FileUtils.touch("spec/foo_spec.rb") 
     VIM.echo('runspec#SpecPath("foo.rb")').should == "spec/foo_spec.rb" 
    end 
    end 
end 

ho scritto su di esso a lungo in "Testing Vim Plugins on Travis CI with RSpec and Vimrunner" se volete maggiori dettagli.

Answer 4

vader.vim è facile e sorprendente. Dispone di senza dipendenze esterne (non richiede ruby ​​/ rake), è un puro plug-in di vimscript. Ecco un test completamente specificato:

Given (description of test): 
    foo bar baz 

Do (move around, insert some text): 
    2Wiab\<Enter>c 

Expect: 
    foo bar ab 
    cbaz 

Se avete il file prova aperta, è possibile eseguirlo in questo modo:

:Vader % 

Oppure si può puntare al percorso del file:

:Vader ./test.vader 

Answer 5

Altri candidati:

VimBot - Simile a VimRunner in quanto scritto in Ruby e ti consente di controllare remotamente un'istanza di vim. È stato progettato per essere utilizzato con l'unità di testing framework RSpec.

VimDriver - Come VimBot eccezione fatta in Python al posto di Ruby (che era iniziato come una porta diretta da VimBot) in modo da poter usare framework di test unità di Python se siete più familiarità con questo.

Answer 6

Per il test funzionale, è disponibile uno strumento denominato vroom. Ha alcune limitazioni e può richiedere alcuni secondi per passare attraverso test approfonditi per un progetto di buone dimensioni, ma ha un bel formato di test/documentazione con supporto per l'evidenziazione della sintassi di vim.

Viene utilizzato per testare il plug-in codefmt e alcuni progetti simili. Puoi controllare il vroom/dir lì per gli esempi.

Answer 7

C'è vim-vspec. I tuoi test sono scritti in vimscript e puoi scriverli usando uno stile BDD (descrivi, aspetta, ...)

runtime! plugin/sandwich/function.vim 
describe 'Adding Quotes' 
    it 'should insert "" in an empty buffer' 
    put! = '' 
    call SmartQuotes("'") 

    Expect getline(1) == "''" 
    Expect col('.') == 2 
    end 
end 

Il GitHub ha collegamenti a un video e un articolo per iniziare:

• A tutorial to use vim-vspec by Vimcasts.org [il video]
• Introduce unit testing to Vim plugin development with vim-vspec [l'articolo]