come testare le funzioni interne nel plugin jquery?

Question

in un plugin jQuery che ho creato funzioni di aiuto, come questo

(function($) { 

    var someHelperFunction = function(s, d) { 
    return s*d; 
    } 
    var someOtherHelperFunction = function(s) { 
    return s*2; 
    } 

// here goes the normal plugin code 

})(jQuery); 

ora voglio chiamare someHelperFunction dall'esterno, per essere in grado di unità di test che, è che in qualche modo possibile?

Answer 1

gli assistenti hanno un ambito all'interno del plug-in, che è una funzione anonima, e non è possibile accedere alle variabili dichiarate al suo interno.
Se si desidera testarlo, rilasciare la parola chiave var davanti alle funzioni. Questo dichiarerà le funzioni come globali (le assegnerà all'oggetto finestra), dando loro la possibilità di essere visibili dall'ambito della finestra (chiamando someHelperFunction o window.someHelperFunction).
così, per la prova:

(function($) { 
    someHelperFunction = function(s, d) { 
     return s*d; 
    } 
    someOtherHelperFunction = function(s) { 
     return s*2; 
    } 
    // here goes the normal plugin code 
})(jQuery); 

dopo che il test è finito, aggiungere nuovamente la parola chiave var.

Aggiornamento
penso che un approccio migliore sarebbe quello di raggruppare i funzioni testabili in un oggetto - e costruire un'API. Poi, sullo stesso principio, si potrebbe fare che api visibile nella portata globale o no:

(function($, global) { 
    someHelperFunction = function(s, d) { 
     return s*d; 
    } 
    someOtherHelperFunction = function(s) { 
     return s*2; 
    } 

    var api = { 
     someHelperFunction: someHelperFunction, 
     someOtherHelperFunction: someOtherHelperFunction 
    }; 

    // decide whether you want to expose your api or not 
    if(makeGlobal) { 
     global.api = api; 
    } 
})(jQuery, this); 

Answer 2

Per this related question, direi solo testare l'interfaccia esterna.

Ma se è necessario testare questi metodi separatamente, è necessario testare "copie" di essi al di fuori del contesto della loro distribuzione come metodi interni. In altre parole, crea un oggetto in cui non sono inaccessibili al codice client e quindi esegui il cobble di quelle versioni insieme allo script esterno in un pre-processo. Sembra un sacco di lavoro, ma hey, questo è il punto di nascondere i metodi, giusto? (Per renderli irraggiungibile.)

Answer 3

un'occhiata a qunit, una prova di unità JavaScript lib

Answer 4

Se le funzioni interne necessitano di test che è un buon indicatore che dovrebbero forse essere in un modulo separato da qualche parte e iniettato come dipendenze e utilizzate all'interno dell'implementazione dell'interfaccia pubblica degli oggetti. Questo è il modo più "testabile" per farlo.

var myActualImplementationTestTheHellOutOfMe = function(s, d) { 

    return s*d; 

} 

(function($, helper) { 

    var someHelperFunction = function(s, d) { 
    return helper(s, d); 
    } 
    var someOtherHelperFunction = function(s) { 
    return s*2; 
    } 

// here goes the normal plugin code 

})(jQuery, myActualImplementationTestTheHellOutOfMe); 

Answer 5

Si consiglia inoltre di considerare i doctest JavaScript. Ci sono due implementazioni di cui sono a conoscenza: Ian Bicking's doctest.js e il mio doctest.