Développement F # et tests unitaires?

Je viens de commencer avec F #, qui est mon premier langage fonctionnel. Je travaille quasi exclusivement avec C # et j'apprécie beaucoup la façon dont F # m'amène à repenser ma façon d'écrire du code. Un aspect que je trouve un peu désorientant est le changement dans le processus d'écriture du code. J'utilise TDD depuis des années en C # maintenant, et j'apprécie vraiment d'avoir des tests unitaires pour savoir où j'en suis.

Jusqu'à présent, mon processus avec F # a été d'écrire certaines fonctions, de jouer avec elles avec la console interactive jusqu'à ce que je sois "raisonnablement" sûr qu'elles fonctionnent, et de les modifier et les combiner. Cela fonctionne bien sur des problèmes à petite échelle comme le projet Euler, mais je ne peux pas imaginer construire quelque chose de grand de cette façon.

Comment les gens abordent-ils les tests unitaires et construisent une suite de tests pour un programme F #? Existe-t-il un équivalent au TDD? Tous les conseils ou pensées sont appréciés.

Les développeurs pilotés par les tests doivent se sentir comme chez eux dans des langages fonctionnels comme F #: les petites fonctions qui donnent des résultats répétables de manière déterministe se prêtent parfaitement aux tests unitaires. Il existe également des fonctionnalités dans le langage F # qui facilitent l'écriture des tests. Prenez, par exemple, les expressions d'objets . Vous pouvez très facilement écrire des faux pour les fonctions qui prennent comme entrée un type d'interface.

Si quoi que ce soit, F # est un langage orienté objet de première classe et vous pouvez utiliser les mêmes outils et astuces que vous utilisez lorsque vous faites TDD en C #. Il existe également des outils de test écrits ou spécifiquement pour F #:

• NaturalSpec
• FsCheck
• FsTest
• FsUnit

Matthew Podwysocki a écrit une grande série sur les tests unitaires dans les langages fonctionnels. L'oncle Bob a également écrit un article stimulant ici .

J'utilise NUnit, et cela ne me semble pas aussi difficile à lire ni à écrire:

open NUnit.Framework

[<TestFixture>]
type myFixture() = class

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

end

Comme mon code est un mélange de F # et d'autres langages .Net, j'aime le fait que j'écris les tests unitaires de la même manière et avec une syntaxe similaire en F # et C #.

Jetez un œil à FsCheck , un outil de test automatique pour F #, est essentiellement un portage de QuickCheck de Haskell. Il vous permet de fournir une spécification du programme, sous la forme de propriétés que les fonctions ou méthodes doivent satisfaire, et FsCheck teste que les propriétés tiennent dans un grand nombre de cas générés aléatoirement.

Page FsCheck CodePlex

Page Auteur FsCheck

Comme le suggère dglaubman, vous pouvez utiliser NUnit. xUnit.net fournit également un support pour cela et fonctionne bien avec TestDriven.net . Le code ressemble aux tests NUnit mais sans la nécessité d'encapsuler le test dans un type conteneur.

#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) 

Je pense que c'est une question très intéressante sur laquelle je me suis beaucoup posé moi-même. Mes pensées jusqu'à présent ne sont que des pensées, alors prenez-les pour ce qu'elles sont.

Je pense que le filet de sécurité d'une suite de tests automatisés est un atout trop précieux pour être abandonné, aussi séduisante que puisse être cette console interactive, je prévois donc de continuer à écrire des tests unitaires comme je l'ai toujours fait.

L'une des principales forces de .NET réside dans les capacités multilingues. Je sais que je vais bientôt écrire du code de production F #, mais mon plan est d'écrire des tests unitaires en C # pour faciliter mon chemin dans ce qui est pour moi un nouveau langage. De cette façon, je peux également tester que ce que j'écris en F # sera compatible avec C # (et d'autres langages .NET).

Avec cette approche, je comprends qu'il existe certaines fonctionnalités de F # que je ne peux utiliser qu'en interne dans mon code F #, mais que je ne peux pas exposer dans le cadre de mon API publique, mais j'accepterai cela, tout comme j'accepte aujourd'hui qu'il y a certaines choses C # me permet d'exprimer (comme uint) qui ne sont pas conformes à CLS, et je m'abstiens donc de les utiliser.

Vous pouvez jeter un œil à FSUnit - même si je ne l'ai pas encore utilisé, cela vaut peut-être la peine d'essayer. Certainement mieux que d'utiliser par exemple NUnit (natif) en F #.

Bien que je sois un peu en retard à la fête, j'aimerais souhaiter la bienvenue à Mathias en F # (mieux vaut tard que jamais;)) et carillon que vous aimerez peut-être ma bibliothèque de tests unitaires, Expecto

Expecto a quelques fonctionnalités qui pourraient vous plaire:

• Syntaxe F # partout, teste comme valeurs; écrire un simple F # pour générer des tests
• Utilisez le module Expect intégré ou une bibliothèque externe comme Unquote pour les assertions
• Tests parallèles par défaut
• Testez votre code Hopac ou votre code Async; Expecto est asynchrone partout
• Journalisation et métriques enfichables via Logary Facade; écrivez facilement des adaptateurs pour les systèmes de construction ou utilisez le mécanisme de synchronisation pour créer un tableau de bord InfluxDB + Grafana des temps d'exécution de vos tests
• Prise en charge intégrée de BenchmarkDotNet
• Prise en charge intégrée de FsCheck; facilite la construction de tests avec des données générées / aléatoires ou la construction de modèles invariants de l'espace d'états de votre objet / acteur

-

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/