F # desarrollo y pruebas unitarias?

Acabo de comenzar con F #, que es mi primer lenguaje funcional. He estado trabajando casi exclusivamente con C # y disfruto mucho de cómo F # me lleva a repensar cómo escribo el código. Un aspecto que encuentro un poco desorientador es el cambio en el proceso de escritura de código. He estado usando TDD durante años en C # y realmente aprecio tener pruebas unitarias para saber dónde estoy.

Hasta ahora, mi proceso con F # ha sido escribir algunas funciones, jugar con ellas con la consola interactiva hasta que esté "razonablemente" seguro de que funcionan, y ajustar y combinar. Esto funciona bien en problemas a pequeña escala como el Proyecto Euler, pero no puedo imaginarme construir algo grande de esa manera.

¿Cómo abordan las personas las pruebas unitarias y la creación de un conjunto de pruebas para un programa de F #? ¿Existe un equivalente a TDD? Se agradece cualquier sugerencia o pensamiento.

Los desarrolladores impulsados ​​por pruebas deben sentirse como en casa en lenguajes funcionales como F #: las pequeñas funciones que dan resultados determinísticamente repetibles se prestan perfectamente a las pruebas unitarias. También hay capacidades en el lenguaje F # que facilitan las pruebas de escritura. Tomemos, por ejemplo, Expresiones de objetos . Puede escribir muy fácilmente falsificaciones para funciones que toman como entrada un tipo de interfaz.

En todo caso, F # es un lenguaje orientado a objetos de primera clase y puede usar las mismas herramientas y trucos que usa cuando hace TDD en C #. También hay algunas herramientas de prueba escritas en o específicamente para F #:

• NaturalSpec
• FsCheck
• FsTest
• FsUnit

Matthew Podwysocki escribió una gran serie sobre pruebas unitarias en lenguajes funcionales. Tío Bob también escribió un pensamiento que provoca el artículo aquí .

Yo uso NUnit, y no me parece tan difícil de leer ni tan oneroso de escribir:

open NUnit.Framework

[<TestFixture>]
type myFixture() = class

    [<Test>]
    member self.myTest() =
       //test code

end

Dado que mi código es una mezcla de F # y otros lenguajes .Net, me gusta el hecho de que escribo las pruebas unitarias básicamente de la misma manera y con una sintaxis similar tanto en F # como en C #.

Eche un vistazo a FsCheck , una herramienta de prueba automática para F #, es básicamente un puerto de QuickCheck de Haskell. Le permite proporcionar una especificación del programa, en forma de propiedades que las funciones o métodos deben satisfacer, y FsCheck prueba que las propiedades cumplen en un gran número de casos generados aleatoriamente.

Página CodePlex de FsCheck

Página de autor de FsCheck

Como sugiere dglaubman, puede usar NUnit. xUnit.net también proporciona soporte para esto y funciona bien con TestDriven.net . El código se ve similar a las pruebas NUnit pero sin el requisito de envolver la prueba en un tipo contenedor.

#light

// Supply a module name here not a combination of module and namespace, otherwise
// F# cannot resolve individual tests nfrom the UI.
module NBody.DomainModel.FSharp.Tests

open System
open Xunit

open Internal

[<Fact>]
let CreateOctantBoundaryReordersMinMax() =
    let Max = VectorFloat(1.0, 1.0, 1.0)
    let Min = VectorFloat(-1.0, -1.0, -1.0)

    let result = OctantBoundary.create Min Max

    Assert.Equal(Min, result.Min)     
    Assert.Equal(Max, result.Max) 

Creo que esta es una pregunta muy interesante sobre la que yo mismo me he preguntado mucho. Mis pensamientos hasta ahora son solo pensamientos, así que tómalos por lo que son.

Creo que la red de seguridad de un conjunto de pruebas automatizadas es un activo demasiado valioso para dejarlo ir, por muy atractiva que pueda ser esa consola interactiva, así que planeo continuar escribiendo pruebas unitarias como siempre lo he hecho.

Una de las principales fortalezas de .NET son las capacidades de varios idiomas. Sé que pronto escribiré código de producción de F #, pero mi plan es escribir pruebas unitarias en C # para facilitar mi camino hacia lo que es para mí un nuevo lenguaje. De esta manera, también puedo probar que lo que escribo en F # será compatible con C # (y otros lenguajes .NET).

Con este enfoque, entiendo que hay ciertas características de F # que solo puedo usar internamente en mi código F #, pero no exponerlas como parte de mi API pública, pero lo aceptaré, tal como acepto hoy que hay ciertas cosas C # me permite expresar (me gusta uint) que no cumplen con CLS, por lo que me abstengo de usarlos.

Podrías echar un vistazo a FSUnit , aunque todavía no lo he usado, puede que valga la pena intentarlo. Ciertamente mejor que usar, por ejemplo, NUnit (nativo) en F #.

A pesar de llegar un poco tarde a la fiesta, me gustaría darle la bienvenida a Mathias a F # (más vale tarde que nunca;)) y decirle que quizás te guste mi biblioteca de pruebas unitarias, Expecto

Expecto tiene algunas características que pueden gustarle:

• Sintaxis de F # en todas partes, pruebas como valores; escribe F # simple para generar pruebas
• Utilice el módulo Expect incorporado o una biblioteca externa como Unquote para las afirmaciones
• Pruebas paralelas por defecto
• Pruebe su código Hopac o su código Async; Expecto es asincrónico en todo
• Registro y métricas conectables a través de Logary Facade; escriba fácilmente adaptadores para sistemas de compilación, o utilice el mecanismo de tiempo para crear un panel de InfluxDB + Grafana de los tiempos de ejecución de sus pruebas
• Soporte integrado para BenchmarkDotNet
• Incorporar soporte para FsCheck; facilita la construcción de pruebas con datos generados / aleatorios o la construcción de modelos invariantes del espacio de estado de su objeto / actor

-

open Expecto

let tests =
  test "A simple test" {
    let subject = "Hello World"
    Expect.equal subject "Hello World" "The strings should equal"
  }

[<EntryPoint>]
let main args =
  runTestsWithArgs defaultConfig args tests

https://github.com/haf/expecto/