Kapan saya harus menulis tes integrasi?

Menurut aturan tes unit TDD ditulis sebelum kode produksi, tetapi bagaimana dengan tes Integrasi yang melakukan interaksi antara benda kabel beton (bukan tiruan)?

Haruskah mereka ditulis sebelum unit test atau setelah kode produksi hanya untuk menguji "perkabelan"?

Perhatikan bahwa saya tidak berbicara tentang Penerimaan atau tes fungsional tetapi tes integrasi tingkat bawah.

Buku Rspec , di antara sumber daya BDD lainnya, menyarankan siklus seperti ini:

Intinya, prosesnya adalah:

While behaviour required
    Write an integration test for a specific behaviour
    While integration test failing
        Write a unit test to fulfil partial behavior
        While unit test failing
            Write code to make unit test pass
        Commit
        While refactoring can be done
            Refactor
            While unit test failing
                Write code to make unit test pass
            Commit
    Push

Penafian: Tidak ada keraguan dalam pikiran saya bahwa ini mengarah pada kode dan produk terbaik, tetapi itu bisa memakan waktu. Ada segala macam kesulitan di sekitar data dan determinisme, ketika harus mengatakan bahwa tes integrasi harus selalu lulus. Ini tidak sesuai dalam semua situasi; terkadang Anda hanya perlu mengeluarkan barang dari pintu.

Yang mengatakan, memiliki proses yang ideal dalam pikiran itu bagus. Ini memberi Anda titik untuk berkompromi.

Proyek nyata menunjukkan kepada saya bahwa tidak mungkin untuk menulis tes unit dan kemudian integrasi dan bahkan arah yang berlawanan salah :-) Jadi, saya biasanya menulis tes unit bersama dengan yang integrasi.

Mengapa? Biarkan saya menulis bagaimana saya melihat kedua jenis tes:

1. Tes unit - Selain Wikipedia dan semua informasi yang diketahui, tes unit membantu Anda mempersempit desain Anda , meningkatkan model, relasi. Alurnya sederhana: begitu Anda mulai mengetik proyek baru / komponen baru, sebagian besar waktu Anda membuat semacam PoC . Ketika Anda selesai, Anda selalu memiliki metode panjang, kelas panjang, metode dan kelas yang tidak koheren, dll.

   Tes unit membantu Anda untuk menghapus masalah ini seperti ketika Anda melakukan pengujian unit nyata menggunakan mock (tanpa ketergantungan pada komponen lain) kelas yang dijelaskan di atas tidak dapat diuji. Tanda dasar dari kode yang tidak dapat diuji adalah sebagian besar mengejek tes karena Anda dipaksa untuk mengejek banyak dependensi (atau situasi)

2. Tes integrasi - tes yang benar dan bekerja mengatakan kepada Anda bahwa komponen baru Anda (atau komponen) bekerja bersama atau dengan komponen lain - ini adalah definisi biasa. Saya menemukan bahwa sebagian besar tes integrasi membantu Anda menentukan aliran cara menggunakan komponen Anda dari sisi konsumen .

   Ini sangat penting karena kadang-kadang dikatakan kepada Anda bahwa API Anda tidak masuk akal dari luar.

Nah, apa yang terjadi setelah saya menulis tes unit dan tes integrasi nanti?

Saya mendapatkan kelas yang bagus, desain yang jelas, konstruktor yang baik, metode yang pendek dan koheren, IOC siap dll. Setelah saya memberikan kelas / API saya kepada beberapa konsumen, misalnya pengembang dari integrasi atau tim GUI, ia tidak dapat menggunakan API saya karena tampaknya tidak logis , aneh. Dia hanya bingung. Jadi saya memperbaiki API menurut sudut pandangnya tetapi juga diperlukan untuk menulis ulang banyak tes karena saya didorong untuk mengubah metode dan kadang-kadang bahkan aliran cara menggunakan API.

Nah, apa yang terjadi setelah saya menulis tes integrasi dan tes unit nanti?

Saya mendapatkan aliran yang tepat, kegunaan yang baik. Apa yang saya juga miliki adalah kelas besar, kode non-koheren, tidak ada logging, metode panjang. Kode spageti

Apa saran saya?

Saya telah belajar aliran berikut:

1. Kembangkan kerangka dasar kode Anda
2. Tulis tes integrasi yang mengatakan apakah masuk akal dari sudut pandang konsumen. Kasus penggunaan dasar sudah cukup untuk saat ini. Tes jelas tidak berhasil.
3. Tulis kode bersama dengan tes unit untuk setiap kelas.
4. Tulis sisanya / tidak ada tes integrasi. Akan lebih baik untuk mengimplementasikan tes ini dalam # 3 bagaimana Anda meningkatkan kode Anda.

Perhatikan bahwa saya telah membuat presentasi kecil tentang pengujian unit / integrasi, lihat slide # 21 di mana kerangka dijelaskan.

Unit Test digunakan untuk menguji perangkat lunak sekecil mungkin yang dapat diuji dalam suatu aplikasi dan untuk menguji fungsionalitasnya. Setiap unit diuji secara terpisah sebelum menggabungkannya menjadi beberapa bagian atau komponen aplikasi yang lebih besar.

Di situlah Tes Integrasi datang:
Mereka menguji bagian-bagian yang baru dibuat ini yang terdiri dari unit yang diuji sebelumnya selama pemasangan bagian-bagian ini bersama-sama. Kasus terbaik adalah menulis tes pada titik ini saat menulis aplikasi itu sendiri.

Saya cenderung melihat tes integrasi sangat mirip dengan tes unit. Dalam hal itu saya memperlakukan subset kode sebagai kotak hitam. Jadi tes integrasi hanyalah sebuah kotak yang lebih besar.

Saya lebih suka menuliskannya sebelum kode produksi. Ini memiliki keuntungan membantu saya mengingat bagian mana yang belum saya pasang atau saya mengubah sedikit detail dalam interaksi objek.

Selain dari tes penerimaan, saya cenderung hanya menulis tes integrasi pada batas-batas aplikasi, untuk memverifikasi bahwa itu terintegrasi dengan baik dengan sistem atau komponen pihak ketiga.

Idenya adalah untuk membuat objek adaptor yang menerjemahkan dari bagaimana pihak ketiga berbicara dengan apa yang dibutuhkan aplikasi Anda, dan menguji penerjemah ini terhadap sistem eksternal yang sebenarnya. Apakah Anda melakukan tes pertama atau tes terakhir adalah saya pikir kurang penting daripada dengan tes unit biasa karena

• Wawasan desain yang diberikan oleh TDD tidak terlalu penting di sini karena desain sudah cukup dikenal sebelumnya dan biasanya tidak ada yang rumit, Anda hanya memetakan sesuatu dari satu sistem ke sistem lainnya.

• Bergantung pada modul / sistem yang ingin Anda tangani, itu mungkin memerlukan banyak eksplorasi, pengaturan konfigurasi, persiapan sampel data, yang membutuhkan waktu dan tidak cocok dengan sangat baik dalam loop umpan balik TDD pendek.

Namun, jika Anda benar-benar merasa lebih nyaman membangun adaptor Anda secara bertahap dalam langkah-langkah aman kecil, saya pasti akan merekomendasikan untuk melakukan tes terlebih dahulu, tidak ada salahnya.

Anda dapat menemukan contoh pendekatan ini di sini: http://davesquared.net/2011/04/dont-mock-types-you-dont-own.html (paragraf 6) http://blog.8thlight.com/eric- smith / 2011/10/27 / thats-not-yours.html

Jadi saya akan menerima jawaban pertama tetapi sudah dihapus.
Untuk meringkasnya
Dalam iterasi yang diberikan:

1. Tulis unit-test
2. Tulis kode produksi
3. Tulis tes Integrasi untuk menguji interaksi

Ingat pengujian integrasi sementara 1 dan 2 untuk menjamin testabilitas di tingkat integrasi.

Tes integrasi tidak harus ditulis ujung ke ujung pada langkah 3, tetapi sebagian dapat ditulis antara langkah 1 dan 2.

Tes unit menguji blok kode terpisah dalam proyek Anda.
Tes integrasi menguji bagaimana kode Anda berinteraksi dengan kode lain: dengan kata lain, mereka menguji antarmuka kode Anda.

Tulis pengujian unit saat mengembangkan kode di belakang antarmuka.
Tulis tes integrasi saat mengembangkan antarmuka atau kode apa pun yang mengimplementasikan antarmuka.

Ini berarti bahwa Anda kadang-kadang akan menulis tes integrasi sangat terlambat dalam suatu proyek, karena sebagian besar pekerjaan berada di belakang antarmuka: misalnya, kompiler, layanan web tertentu yang mengimplementasikan beberapa lapisan logika atau .. sesuatu yang melibatkan banyak logika internal.

Namun, jika Anda menerapkan serangkaian layanan REST atau refactoring model data dan menambahkan dukungan untuk transaksi XA, maka Anda akan segera mulai mengembangkan tes integrasi, karena sebagian besar pekerjaan Anda berpusat di sekitar antarmuka, apakah itu API REST atau bagaimana program menggunakan model data.