Come faccio a far funzionare NUnit test F # non esportati da un modulo

Question

Ho scritto un modulo di grandi dimensioni in F # che ha un'interfaccia banale. Il modulo contiene circa 1000 righe di codice, 50 test di unità ed esporta solo una funzione facilmente comprensibile.

La cosa naturale da fare è scrivere un file FSI minuscolo. Questo ha numerosi vantaggi, tra cui la prevenzione dell'inquinamento dello spazio dei nomi, fornendo un posto ovvio per la documentazione, assicurandosi che se qualcuno decidesse di riutilizzare gli interni, essi avranno un incentivo a ripulirli in modo pulito, e senza dubbio molti altri. Sono certo che sto predicando al coro qui, ma sento comunque che valga la pena spiegare perché ritengo sia utile avere il file fsi.

Ora il problema. NUnit non eseguirà più i test unitari, recalcitrantemente affermando di non essere pubblici. Bene, sarebbe perché non sono in alcun modo una parte dell'interfaccia. Non voglio particolarmente aggiungerli all'interfaccia nonostante, visto che significherebbe aggiornarlo ogni volta che aggiungo un altro test, e anche che gonfierà il file fsi di un ordine di grandezza.

Suppongo che una soluzione banale sia spostare il codice da qualche altra parte, importarlo in un piccolo file .fs e inoltrare semplicemente una funzione. Con un po 'di fortuna tutti saranno d'accordo che è semplicemente disgustoso. C'è un modo migliore per favore?

Modifica: molte grazie a tutti coloro che hanno risposto. Ho svalutato entrambe le risposte. Mi sarebbe piaciuto dividere la taglia, tuttavia, dato che non sembra possibile, accetterò (un po 'arbitrariamente) la risposta di Tomas.

Answer 1

Se si aggiunge un file fsi per specificare la visibilità dei moduli e delle funzioni nella propria origine, è necessario includere dichiarazioni di tutte le funzioni che dovrebbero essere accessibili al pubblico. Ciò significa che se NUnit richiede che i test siano funzioni pubbliche, è necessario includerli nel file fsi.

Tuttavia, c'è anche un altro modo per specificare la visibilità in F # - invece di utilizzare il file fsi, è sufficiente aggiungere i modificatori di visibilità appropriati alle dichiarazioni. In questo modo, è possibile nascondere tutti i dettagli di implementazione e l'esportazione solo la funzione principale e test:

namespace MyLibrary 
open NUnit.Framework 

// Implementation details can be in this module 
// (which will not be visible outside of the library) 
module private Internal = 
    let foo n = n * 2 
    let bar n = n + 1 

// A public module can contain the public API (and use internal implementation)  
module public MyModule = 
    open Internal 
    let doWork n = foo (bar n) 

// To make the tests visible to NUnit, these can be placed in a public module 
// (but they can still access all functions from 'Internal') 
module public Tests = 
    open MyModule 

    [<Test>] 
    let ``does work for n = 1``() = 
    Assert.Equals(doWork 1, 4) 

Rispetto utilizzando fsi file, questo ha lo svantaggio che non si dispone di un file separato che ben descrive solo la parti importanti della tua API. Tuttavia, otterrai ciò di cui hai bisogno: nascondi i dettagli di implementazione ed esporti solo una singola funzione e i test.

Answer 2

approccio

Si potrebbe ricorrere all'utilizzo di riflessione per invocare i metodi di prova privati: si sarebbe avere un unico metodo di prova NUnit pubblico che loop su tutti i metodi privati ​​nella dell'assemblea invocando quelli con l'attributo di prova. Il lato negativo di questo approccio è che si può vedere un solo metodo di test in errore alla volta (ma forse si potrebbe esaminare qualcosa di creativo come l'uso di test parametrizzati per risolvere questo problema).

Esempio

Program.fsi

namespace MyNs 

module Program = 
    val visibleMethod: int -> int 

Program.fs

namespace MyNs 

open NUnit.Framework 

module Program = 
    let implMethod1 x y = 
     x + y 

    [<Test>] 
    let testImpleMethod1() = 
     Assert.AreEqual(implMethod1 1 1, 2) 

    let implMethod2 x y z = 
     x + y + z 

    [<Test>] 
    let testImpleMethod2() = 
     Assert.AreEqual(implMethod2 1 1 1, 3) 

    let implMethod3 x y z r = 
     x + y + z + r 

    [<Test>] 
    let testImpleMethod3() = 
     Assert.AreEqual(implMethod3 1 1 1 1, -1) 

    let implMethod4 x y z r s = 
     x + y + z + r + s 

    [<Test>] 
    let testImpleMethod4() = 
     Assert.AreEqual(implMethod4 1 1 1 1 1, 5) 

    let visibleMethod x = 
     implMethod1 x x 
     + implMethod2 x x x 
     + implMethod3 x x x x 

TestProxy.fs (implementazione del nostro "Approach")

module TestProxy 

open NUnit.Framework 

[<Test>] 
let run() = 
    ///we only want static (i.e. let bound functions of a module), 
    ///non-public methods (exclude any public methods, including this method, 
    ///since those will not be skipped by nunit) 
    let bindingFlags = System.Reflection.BindingFlags.Static ||| System.Reflection.BindingFlags.NonPublic 

    ///returns true if the given obj is of type TestAttribute, the attribute used for marking nunit test methods 
    let isTestAttr (attr:obj) = 
     match attr with 
     | :? NUnit.Framework.TestAttribute -> true 
     | _ -> false 

    let assm = System.Reflection.Assembly.GetExecutingAssembly() 
    let tys = assm.GetTypes() 
    let mutable count = 0 
    for ty in tys do 
     let methods = ty.GetMethods(bindingFlags) 
     for mi in methods do 
      let attrs = mi.GetCustomAttributes(false) 
      if attrs |> Array.exists isTestAttr then 
       //using stdout w/ flush instead of printf to ensure messages printed to screen in sequence 
       stdout.Write(sprintf "running test `%s`..." mi.Name) 
       stdout.Flush() 
       mi.Invoke(null,null) |> ignore 
       stdout.WriteLine("passed") 
       count <- count + 1 
    stdout.WriteLine(sprintf "All %i tests passed." count) 

Esempio di output (tramite TestDriven.NET)

Privacy non abbiamo mai arrivare a testImplMethod4 poiché non sulla testImpleMethod3:

running test `testImpleMethod1`...passed 
running test `testImpleMethod2`...passed 
running test `testImpleMethod3`...Test 'TestProxy.run' failed: System.Reflection.TargetInvocationException : Exception has been thrown by the target of an invocation. 
    ----> NUnit.Framework.AssertionException : Expected: 4 
    But was: -1 
    at System.RuntimeMethodHandle._InvokeMethodFast(IRuntimeMethodInfo method, Object target, Object[] arguments, SignatureStruct& sig, MethodAttributes methodAttributes, RuntimeType typeOwner) 
    at System.RuntimeMethodHandle.InvokeMethodFast(IRuntimeMethodInfo method, Object target, Object[] arguments, Signature sig, MethodAttributes methodAttributes, RuntimeType typeOwner) 
    at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture, Boolean skipVisibilityChecks) 
    at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) 
    at System.Reflection.MethodBase.Invoke(Object obj, Object[] parameters) 
    C:\Users\Stephen\Documents\Visual Studio 2010\Projects\FsOverflow\FsOverflow\TestProxy.fs(29,0): at TestProxy.run() 
    --AssertionException 
    C:\Users\Stephen\Documents\Visual Studio 2010\Projects\FsOverflow\FsOverflow\Program.fs(25,0): at MyNs.Program.testImpleMethod3() 

0 passed, 1 failed, 4 skipped (see 'Task List'), took 0.41 seconds (NUnit 2.5.10).