F # pengembangan dan pengujian unit?

Saya baru saja mulai dengan F #, yang merupakan bahasa fungsional pertama saya. Saya telah bekerja secara quasi-eksklusif dengan C #, dan menikmati banyak bagaimana F # membuat saya memikirkan kembali bagaimana saya menulis kode. Satu aspek yang menurut saya agak membingungkan adalah perubahan dalam proses penulisan kode. Saya telah menggunakan TDD selama bertahun-tahun di C # sekarang, dan sangat menghargai tes unit untuk mengetahui di mana saya berada.

Sejauh ini, proses saya dengan F # adalah menulis beberapa fungsi, bermain dengan mereka dengan konsol interaktif sampai saya "cukup" yakin mereka bekerja, dan men-tweak & menggabungkan. Ini berfungsi dengan baik pada masalah skala kecil seperti Proyek Euler, tetapi saya tidak dapat membayangkan membangun sesuatu yang besar seperti itu.

Bagaimana orang mendekati pengujian unit dan membangun rangkaian pengujian untuk program F #? Apakah ada yang setara dengan TDD? Setiap petunjuk atau pemikiran dihargai.

Pengembang yang digerakkan oleh pengujian seharusnya merasa betah dalam bahasa fungsional seperti F #: fungsi kecil yang memberikan hasil yang dapat diulang secara deterministik cocok untuk pengujian unit. Ada juga kemampuan dalam bahasa F # yang memfasilitasi tes menulis. Ambil, misalnya, Ekspresi Objek . Anda dapat dengan mudah menulis palsu untuk fungsi yang menerima inputnya sebagai tipe antarmuka.

Jika ada, F # adalah bahasa berorientasi objek kelas satu dan Anda dapat menggunakan alat dan trik yang sama yang Anda gunakan saat melakukan TDD di C #. Ada juga beberapa alat pengujian yang ditulis atau khusus untuk F #:

• NaturalSpec
• FsCheck
• FsTest
• FsUnit

Matthew Podwysocki menulis seri hebat tentang pengujian unit dalam bahasa fungsional. Paman Bob juga menulis artikel yang memancing pemikiran di sini .

Saya menggunakan NUnit, dan menurut saya tidak terlalu sulit untuk dibaca atau sulit ditulis:

open NUnit.Framework

[<TestFixture>]
type myFixture() = class

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

end

Karena kode saya adalah campuran dari F # dan bahasa .Net lainnya, saya suka fakta bahwa saya menulis pengujian unit pada dasarnya dengan cara yang sama dan dengan sintaks yang serupa di F # dan C #.

Lihat FsCheck , alat pengujian otomatis untuk F #, pada dasarnya adalah port dari QuickCheck Haskell. Ini memungkinkan Anda untuk memberikan spesifikasi program, dalam bentuk properti yang harus dipenuhi oleh fungsi atau metode, dan FsCheck menguji properti tersebut dalam sejumlah besar kasus yang dibuat secara acak.

FsCheck Halaman CodePlex

FsCheck Halaman Penulis

Seperti yang disarankan dglaubman, Anda dapat menggunakan NUnit. xUnit.net juga menyediakan dukungan untuk ini dan bekerja dengan baik dengan TestDriven.net . Kode tersebut terlihat mirip dengan pengujian NUnit tetapi tanpa persyaratan untuk menggabungkan pengujian dalam tipe yang memuatnya.

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

Saya pikir ini adalah pertanyaan yang sangat menarik yang banyak saya tanyakan sendiri. Pikiran saya sejauh ini hanyalah pikiran, jadi ambillah apa adanya.

Saya pikir jaring pengaman dari rangkaian pengujian otomatis adalah aset yang terlalu berharga untuk dilepaskan, betapapun menariknya konsol interaktif itu, jadi saya berencana untuk terus menulis pengujian unit seperti yang selalu saya lakukan.

Salah satu kekuatan utama .NET adalah kemampuan lintas bahasa. Saya tahu saya akan segera menulis kode produksi F #, tetapi rencana saya adalah menulis pengujian unit dalam C # untuk memudahkan jalan saya ke dalam bahasa baru bagi saya. Dengan cara ini, saya juga bisa menguji bahwa apa yang saya tulis di F # akan kompatibel dengan C # (dan bahasa .NET lainnya).

Dengan pendekatan ini, saya memahami bahwa ada fitur tertentu dari F # yang hanya dapat saya gunakan secara internal dalam kode F # saya, tetapi tidak diekspos sebagai bagian dari API publik saya, tetapi saya akan menerimanya, seperti yang saya terima hari ini bahwa ada hal-hal tertentu C # memungkinkan saya untuk mengekspresikan (suka uint) yang tidak sesuai dengan CLS, jadi saya menahan diri untuk tidak menggunakannya.

Anda dapat melihat FSUnit - meskipun saya belum menggunakannya, mungkin patut dicoba. Tentunya lebih baik daripada menggunakan misalnya (asli) NUnit di F #.

Meskipun agak terlambat ke pesta, saya ingin menyambut Mathias ke F # (lebih baik terlambat daripada tidak sama sekali;)) dan berpadu bahwa Anda mungkin menyukai pustaka pengujian unit saya, Expecto

Expecto memiliki beberapa fitur yang mungkin Anda sukai:

• F # sintaks seluruh, tes sebagai nilai; tulis F # untuk menghasilkan tes
• Gunakan modul Expect bawaan, atau lib eksternal seperti Unquote untuk pernyataan
• Tes paralel secara default
• Uji kode Hopac atau kode Async Anda; Expecto asinkron seluruhnya
• Pencatatan dan metrik yang dapat dicolok melalui Logary Facade; tulis adaptor dengan mudah untuk sistem build, atau gunakan mekanisme pengaturan waktu untuk membuat dasbor InfluxDB + Grafana dari waktu eksekusi pengujian Anda
• Dukungan bawaan untuk BenchmarkDotNet
• Bangun dukungan untuk FsCheck; memudahkan untuk membuat pengujian dengan data yang dihasilkan / acak atau membuat model-invarian dari ruang status objek / aktor Anda

-

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/