Bagaimana Anda mengukur pengujian integrasi Anda?

Saya sedang menyelidiki teknik dan strategi untuk meningkatkan jumlah tes integrasi kami yang meningkat pada produk kami saat ini, sehingga mereka dapat (secara manusiawi) tetap menjadi bagian dari pengembangan kami, dan proses CI.

Pada sekitar 200+ tes integrasi, kami telah mencapai tanda 1 jam untuk menyelesaikan uji coba penuh (pada mesin desktop dev), dan ini secara negatif mempengaruhi kemampuan pengembang untuk mentolerir menjalankan seluruh rangkaian sebagai bagian dari proses push rutin. Yang memengaruhi motivasi untuk menjadi disiplin dalam menciptakan mereka dengan baik. Kami melakukan uji integrasi hanya skenario kunci depan ke belakang, dan kami menggunakan lingkungan yang mencerminkan produksi, yang dibangun dari awal setiap uji coba.

Karena waktu yang diperlukan untuk menjalankan, itu membuat loop umpan balik yang mengerikan dan banyak siklus terbuang menunggu mesin untuk menyelesaikan uji coba, tidak peduli seberapa fokus uji coba tersebut. Nevermind dampak negatif yang lebih mahal pada aliran dan kemajuan, kewarasan dan keberlanjutan.

Kami berharap memiliki tes integrasi 10 kali lipat lebih banyak sebelum produk ini mulai melambat (tidak tahu benar, tapi rasanya kami belum memulai dari segi fitur). Kita harus berharap untuk berada di beberapa ratus atau beberapa ribu tes integrasi, saya rasa di beberapa titik.

Agar lebih jelas, untuk mencegah hal ini menjadi diskusi tentang pengujian unit versus pengujian integrasi, (yang seharusnya tidak pernah diperdagangkan). Kami sedang melakukan kedua pengujian unit dengan pengujian TDD DAN integrasi di produk ini. Bahkan, kami melakukan pengujian integrasi pada berbagai lapisan dalam arsitektur layanan yang kami miliki, di mana masuk akal bagi kami, karena kami perlu memverifikasi di mana kami memperkenalkan pemecahan perubahan ketika mengubah pola dalam arsitektur kami ke area lain dari sistem. 

Sedikit tentang tumpukan teknologi kami. Kami sedang menguji pada lingkungan emulasi (CPU dan memori) untuk menjalankan pengujian kami dari ujung ke ujung. Yang terdiri dari layanan web Azure REST yang menampilkan backend noSql (ATS). Kami mensimulasikan lingkungan produksi kami dengan menjalankan di Azure desktop Emulator + IISExpress. Kami terbatas pada satu emulator dan satu repositori backend lokal per mesin dev.

Kami juga memiliki CI berbasis cloud, yang menjalankan tes yang sama di lingkungan yang ditiru yang sama, dan uji coba berjalan dua kali lebih lama (2 jam +) di cloud dengan penyedia CI kami saat ini. Kami telah mencapai batas penyedia cloud CI SLA dalam hal kinerja perangkat keras, dan melampaui batas waktu uji coba. Agar adil bagi mereka, spesifikasi mereka tidak buruk, tetapi separuh lebih baik daripada mesin desktop muram inhouse jelas.

Kami menggunakan strategi pengujian untuk membangun kembali penyimpanan data kami untuk setiap kelompok logis pengujian, dan melakukan preloading dengan data uji. Sementara memastikan integritas data secara komprehensif, ini menambahkan dampak 5-15% pada setiap pengujian. Jadi kami pikir ada sedikit yang bisa diperoleh mengoptimalkan strategi pengujian pada saat ini dalam pengembangan produk. 

Panjang dan pendeknya adalah bahwa: sementara kita dapat mengoptimalkan throughput setiap tes (meskipun masing-masing sebanyak 30% -50%), kita masih tidak akan skala secara efektif dalam waktu dekat dengan beberapa ratus tes. 1 jam sekarang bahkan masih jauh melebihi toleransi manusia, kita membutuhkan urutan peningkatan besar-besaran dalam proses keseluruhan untuk membuatnya berkelanjutan.

Jadi, saya sedang menyelidiki teknik dan strategi apa yang dapat kami terapkan untuk secara drastis mengurangi waktu pengujian.

• Menulis lebih sedikit tes bukanlah suatu pilihan. Tolong jangan berdebat yang ada di utas ini.
• Menggunakan perangkat keras yang lebih cepat jelas merupakan suatu pilihan, meskipun sangat mahal.
• Menjalankan kelompok pengujian / skenario pada perangkat keras terpisah secara paralel juga merupakan opsi yang lebih disukai.
• Membuat pengelompokan pengujian di sekitar fitur dan skenario yang sedang dikembangkan adalah masuk akal, tetapi pada akhirnya tidak dapat diandalkan dalam membuktikan cakupan penuh atau keyakinan bahwa sistem tidak terpengaruh oleh perubahan. 
• Berjalan di lingkungan pementasan berskala awan alih-alih berjalan di emulator desktop secara teknis dimungkinkan, meskipun kami mulai menambahkan waktu penempatan untuk menguji proses (~ masing-masing 20 menit di awal pengujian untuk menyebarkan barang-barang).
• Membagi komponen-komponen sistem menjadi potongan-potongan log independen masuk akal sampai tingkat tertentu tetapi kami berharap jarak tempuh yang terbatas pada hal itu, karena interaksi antara komponen-komponen diharapkan meningkat seiring waktu. (Yaitu perubahan yang cenderung mempengaruhi orang lain dalam cara yang tidak terduga - seperti yang sering terjadi ketika suatu sistem dikembangkan secara bertahap)

Saya ingin melihat strategi (dan alat) apa yang digunakan orang lain di ruang ini.

(Saya harus percaya orang lain mungkin melihat kesulitan seperti ini menggunakan perangkat teknologi tertentu.))

[Pembaruan: 12/16/2016: Kami akhirnya berinvestasi lebih banyak dalam pengujian paralel CI, untuk diskusi tentang hasilnya: http://www.mindkin.co.nz/blog/2015/12/16/16-jobs]

Saya bekerja di tempat yang membutuhkan waktu 5 jam (melintasi 30 mesin) untuk menjalankan tes integrasi. Saya refactored basis kode dan melakukan tes unit sebagai gantinya untuk hal-hal baru. Tes unit membutuhkan waktu 30 detik (melintasi 1 mesin). Oh, dan bug juga turun. Dan waktu pengembangan sejak kami tahu persis apa yang rusak dengan tes granular.

Singkat cerita, Anda tidak perlu. Tes integrasi penuh tumbuh secara eksponensial saat basis kode Anda tumbuh (lebih banyak kode berarti lebih banyak tes dan lebih banyak kode berarti semua tes membutuhkan waktu lebih lama untuk dijalankan karena ada lebih banyak "integrasi" untuk dikerjakan). Saya berpendapat bahwa apa pun dalam rentang "jam" kehilangan sebagian besar manfaat integrasi berkelanjutan karena loop umpan balik tidak ada. Bahkan urutan peningkatan yang besar tidak cukup untuk membuat Anda baik - dan itu tidak mendekati Anda.

Jadi saya akan merekomendasikan memotong tes integrasi ke tes asap yang paling luas dan paling vital. Mereka kemudian dapat dijalankan setiap malam atau beberapa interval yang kurang dari berkelanjutan, mengurangi banyak kebutuhan Anda untuk kinerja. Tes unit, yang hanya tumbuh secara linier saat Anda menambahkan lebih banyak kode (tes meningkat, runtime per-tes tidak) adalah cara untuk meningkatkan skala.

Tes integrasi akan selalu berjalan lama karena harus meniru pengguna nyata. Untuk alasan ini Anda tidak harus menjalankan semuanya secara serempak!

Mengingat bahwa Anda sudah menjalankan hal-hal di cloud, bagi saya sepertinya Anda berada di posisi utama untuk mengukur tes Anda di beberapa mesin.

Dalam kasus ekstrem, putar satu lingkungan baru per pengujian dan jalankan semuanya pada saat yang sama. Tes integrasi Anda hanya akan memakan waktu selama tes berjalan terpanjang.

Menebang / mengoptimalkan tes sepertinya ide terbaik bagi saya, tetapi jika itu bukan pilihan, saya punya alternatif untuk mengusulkan (tetapi membutuhkan membangun beberapa alat berpemilik sederhana).

Saya menghadapi masalah yang sama tetapi tidak dalam tes integrasi kami (yang berjalan dalam hitungan menit). Sebaliknya itu hanya di build kami: basis kode C skala besar, akan membutuhkan waktu berjam-jam untuk membangun.

Apa yang saya lihat sangat boros adalah kenyataan bahwa kami sedang membangun kembali keseluruhan hal dari awal (sekitar 20.000 sumber file / unit kompilasi) bahkan jika hanya beberapa file sumber berubah, dan dengan demikian menghabiskan berjam-jam untuk perubahan yang hanya harus mengambil detik atau menit paling buruk.

Jadi kami mencoba menghubungkan secara bertahap pada server build kami, tetapi itu tidak dapat diandalkan. Kadang-kadang akan memberikan negatif palsu dan gagal untuk membangun beberapa komitmen, hanya untuk kemudian berhasil membangun kembali sepenuhnya. Lebih buruk lagi, kadang-kadang akan memberikan positif palsu dan melaporkan keberhasilan membangun, hanya untuk pengembang untuk menggabungkan bangunan yang rusak ke cabang utama. Jadi kami kembali membangun kembali semuanya setiap kali pengembang mendorong perubahan dari cabang pribadinya.

Saya sangat membenci ini. Saya akan berjalan ke ruang konferensi dengan setengah pengembang bermain video game dan hanya karena ada sedikit yang harus dilakukan sambil menunggu build. Saya mencoba untuk mendapatkan keunggulan produktivitas dengan melakukan banyak tugas dan memulai cabang baru setelah saya berkomitmen sehingga saya bisa mengerjakan kode sambil menunggu build, tetapi ketika tes atau build gagal, menjadi terlalu menyakitkan untuk mengantre perubahan melewati titik itu dan mencoba untuk memperbaiki semuanya dan menjahit semuanya kembali.

Proyek Samping Sambil Menunggu, Integrasi Nanti

Jadi yang saya lakukan adalah membuat kerangka kerangka aplikasi - jenis UI dasar yang sama dan bagian-bagian yang relevan dari SDK untuk saya kembangkan sebagai proyek terpisah secara keseluruhan. Kemudian saya akan menulis kode independen terhadap itu sambil menunggu build, di luar proyek utama. Setidaknya itu memberi saya beberapa pengkodean untuk dilakukan sehingga saya bisa tetap produktif, dan kemudian saya akan mulai mengintegrasikan pekerjaan yang dilakukan sepenuhnya di luar produk ke proyek di samping potongan kode. Itu salah satu strategi untuk pengembang Anda jika mereka mendapati diri mereka menunggu banyak.

Parsing File Sumber Secara Manual untuk Mencari Tahu Apa yang Dibangun Kembali / Jalankan Kembali

Namun saya benci bagaimana kita menghabiskan begitu banyak waktu untuk membangun kembali semuanya sepanjang waktu. Jadi saya mengambilnya sendiri selama beberapa akhir pekan untuk menulis beberapa kode yang benar-benar akan memindai file untuk perubahan dan hanya membangun kembali proyek-proyek yang relevan - masih merupakan pembangunan kembali penuh, tidak ada tautan tambahan, tetapi hanya proyek yang perlu dibangun kembali ( yang file dependennya, diurai secara rekursif, diubah). Itu benar-benar dapat diandalkan dan setelah menunjukkan dan mengujinya secara mendalam, kami dapat menggunakan solusi itu. Itu memotong rata-rata waktu pembangunan dari berjam-jam menjadi beberapa menit karena kami hanya membangun kembali proyek-proyek yang diperlukan (meskipun perubahan SDK pusat masih bisa memakan waktu satu jam, tetapi kami melakukan itu jauh lebih jarang daripada perubahan yang dilokalkan).

Strategi yang sama harus diterapkan pada tes integrasi. Hanya parsing file sumber secara rekursif untuk mencari tahu file apa yang bergantung pada tes integrasi (mis:import di Jawa,#includedi C atau C ++) di sisi server, dan file-file disertakan / diimpor dari file-file itu dan seterusnya, membangun grafik file dependensi / impor penuh untuk sistem. Tidak seperti build parsing yang membentuk DAG, grafik harus tidak diarahkan karena tertarik pada file apa pun yang berubah yang berisi kode yang dapat dieksekusi secara tidak langsung *. Jalankan kembali tes integrasi jika ada file dalam grafik untuk tes integrasi yang menarik telah berubah. Bahkan untuk jutaan baris kode, mudah melakukan penguraian ini dalam waktu kurang dari satu menit. Jika Anda memiliki file selain kode sumber yang dapat memengaruhi tes integrasi, seperti file konten, mungkin Anda dapat menulis metadata ke dalam komentar di kode sumber yang mengindikasikan dependensi dalam tes integrasi, sehingga jika file eksternal itu berubah, tes juga jalankan kembali.

_{* Sebagai contoh, jika test.c menyertakan foo.h yang juga disertakan oleh foo.c, maka perubahan untuk test.c, foo.h, atau foo.c harus menandai tes terintegrasi sebagai membutuhkan perjalanan baru.}

Ini bisa memakan waktu satu atau dua hari penuh untuk memprogram dan menguji, terutama di lingkungan formal, tapi saya pikir harus bekerja bahkan untuk tes integrasi dan layak jika Anda tidak memiliki pilihan lain selain menunggu dalam rentang jam untuk membangun untuk menyelesaikan (baik karena bangunan atau pengujian atau proses pengemasan atau apa pun). Itu dapat menerjemahkan ke begitu banyak jam kerja yang hilang hanya dalam hitungan bulan yang akan mengerdilkan waktu yang dibutuhkan untuk membangun solusi berpemilik seperti ini, serta membunuh energi tim dan meningkatkan tekanan yang disebabkan oleh konflik dalam penggabungan yang lebih besar yang dilakukan lebih sedikit sering sebagai akibat dari semua waktu terbuang menunggu. Hanya buruk bagi tim secara keseluruhan ketika mereka menghabiskan sebagian besar waktu mereka menunggu sesuatu.semuanya harus dibangun kembali / dijalankan kembali / dikemas ulang pada setiap perubahan kecil.

Sepertinya Anda memiliki terlalu banyak tes integrasi. Ingat Piramida Uji . Tes integrasi termasuk di tengah.

Sebagai contoh mengambil repositori dengan metode set(key,object), get(key). Repositori ini digunakan secara luas di seluruh basis kode Anda. Semua metode yang bergantung pada repositori ini akan diuji dengan repositori palsu. Sekarang Anda hanya perlu dua tes integrasi, satu untuk set dan satu untuk get.

Beberapa dari tes integrasi tersebut mungkin dapat dikonversi menjadi unit test. Misalnya, pengujian ujung ke ujung dalam pandangan saya hanya akan menguji bahwa situs tersebut dikonfigurasikan dengan benar dengan string koneksi yang benar dan domain yang benar.

Tes integrasi harus menguji apakah ORM, repositori, dan abstraksi antrian sudah benar. Sebagai aturan praktis, tidak ada kode domain yang diperlukan untuk pengujian integrasi - hanya abstraksi.

Hampir segala sesuatu yang lain dapat diuji unit dengan stubbed / mocked / faked / in-mem-implementasi untuk dependensi.

Dalam pengalaman saya di lingkungan Agile atau DevOps di mana pipa pengiriman kontinu adalah umum, pengujian integrasi harus dilakukan ketika setiap modul selesai atau disesuaikan. Misalnya, di banyak lingkungan saluran pengiriman kontinu, tidak jarang memiliki banyak penerapan kode per pengembang per hari. Menjalankan serangkaian uji integrasi cepat pada akhir setiap fase pengembangan sebelum penerapan harus menjadi praktik standar dalam jenis lingkungan ini. Untuk informasi tambahan, eBuku yang bagus untuk dimasukkan dalam bacaan Anda tentang subjek ini adalah Panduan Praktis untuk Menguji dalam DevOps , yang ditulis oleh Katrina Clokie.

Untuk menguji secara efisien dengan cara ini, komponen baru harus diuji terhadap modul lengkap yang ada di lingkungan pengujian khusus atau terhadap Rintisan bertopik dan Driver. Tergantung pada kebutuhan Anda, umumnya merupakan ide yang baik untuk menyimpan perpustakaan Rintisan dan Driver untuk setiap modul aplikasi dalam folder atau pustaka untuk memungkinkan penggunaan pengujian Integrasi berulang yang cepat. Menjaga Rintisan dan Driver terorganisir seperti ini membuatnya mudah untuk melakukan perubahan berulang, menjaganya agar tetap diperbarui dan berkinerja optimal untuk memenuhi kebutuhan pengujian Anda yang sedang berlangsung.

Pilihan lain untuk dipertimbangkan adalah solusi yang awalnya dikembangkan sekitar tahun 2002, yang disebut Layanan Virtualisasi. Ini menciptakan lingkungan virtual, mensimulasikan interaksi modul dengan sumber daya yang ada untuk tujuan pengujian di DevOps perusahaan yang kompleks atau lingkungan Agile.

Artikel ini dapat bermanfaat untuk memahami lebih lanjut tentang cara melakukan pengujian integrasi di perusahaan

Sudahkah Anda mengukur setiap tes untuk melihat di mana waktu diambil? Dan kemudian, mengukur kinerja basis kode jika ada bit yang sangat lambat. Apakah masalah keseluruhan salah satu dari tes atau penyebaran, atau keduanya?

Biasanya Anda ingin mengurangi dampak tes integrasi sehingga menjalankannya pada perubahan yang relatif kecil diminimalkan. Kemudian Anda dapat meninggalkan tes penuh untuk menjalankan 'QA' yang Anda lakukan ketika cabang dipromosikan ke tingkat berikutnya. Jadi, Anda memiliki tes unit untuk cabang dev, menjalankan tes integrasi yang diperkecil saat digabungkan, dan menjalankan tes integrasi penuh saat digabungkan ke cabang kandidat rilis.

Jadi ini berarti Anda tidak perlu membangun kembali dan mengemas ulang dan memindahkan kembali semua komitmen. Anda dapat mengatur pengaturan Anda, di lingkungan dev, untuk melakukan penyebaran semurah mungkin dengan percaya bahwa itu akan baik-baik saja. Alih-alih memutar seluruh VM, dan menggunakan seluruh produk, biarkan VM dengan versi lama di tempat dan salin binari baru di tempat, misalnya (YMMV tergantung apa yang harus Anda lakukan).

Pendekatan optimis keseluruhan ini masih memerlukan uji penuh, tetapi itu dapat dilakukan pada tahap selanjutnya ketika waktu yang dibutuhkan kurang mendesak. (mis. Anda dapat menjalankan tes penuh sekali pada malam hari, jika ada masalah dev dapat menyelesaikannya di pagi hari). Ini juga memiliki keuntungan menyegarkan produk pada rig integrasi untuk pengujian hari berikutnya - mungkin sudah ketinggalan zaman karena devs mengubah hal-hal, tetapi hanya dalam 1 hari.

Kami memiliki masalah serupa menjalankan alat analisis statis berbasis keamanan. Berjalan penuh akan memakan waktu lama, jadi kami pindah menjalankannya dari komitmen pengembang ke komitmen integrasi (yaitu kami memiliki sistem di mana dev mengatakan mereka selesai, itu digabung ke cabang 'level 2' di mana lebih banyak pengujian dilakukan, termasuk perf Ketika selesai, ia digabung ke cabang QA untuk ditempatkan. Idenya adalah untuk menghapus run reguler yang akan terjadi terus menerus untuk menjalankan yang dibuat setiap malam - devs akan mendapatkan hasil di pagi hari dan mereka tidak akan mempengaruhi perkembangan mereka. fokus sampai nanti dalam siklus dev mereka).

Pada titik tertentu, satu set lengkap tes integrasi mungkin memakan waktu berjam-jam untuk diselesaikan, bahkan pada perangkat keras yang mahal. Salah satu opsi adalah tidak menjalankan sebagian besar tes pada setiap komit, dan sebaliknya menjalankannya setiap malam, atau dalam mode batch kontinu (sekali per beberapa komit).

Ini, bagaimanapun, menciptakan masalah baru - pengembang tidak menerima umpan balik langsung, dan bangunan yang rusak mungkin tidak diperhatikan. Untuk memperbaikinya, penting bagi mereka untuk mengetahui bahwa ada sesuatu yang rusak setiap saat. Membuat alat pemberitahuan seperti Catlight atau notifier baki TeamCity bisa sangat berguna.

Tetapi akan ada masalah lain lagi. Bahkan ketika pengembang melihat bahwa bangunannya rusak, ia mungkin tidak terburu-buru untuk memeriksanya. Lagipula, orang lain mungkin sudah memeriksanya, kan?

Oleh karena itu, kedua alat tersebut memiliki fitur "membangun penyelidikan". Ini akan memberi tahu apakah ada orang dari tim pengembangan yang benar-benar memeriksa dan memperbaiki bangunan yang rusak. Pengembang dapat secara sukarela memeriksa bangunan, dan, sampai itu terjadi, semua orang di tim akan terganggu oleh ikon merah di dekat jam.

Kedengarannya seperti basis kode Anda tumbuh besar, dan beberapa manajemen kode akan membantu. Kami menggunakan Java, jadi minta maaf sebelumnya jika saya menganggap ini.

• Sebuah proyek besar perlu dipecah menjadi proyek-proyek individu yang lebih kecil yang dikompilasi ke perpustakaan. Alat Java seperti nexus membuatnya mudah.
• Setiap perpustakaan harus mengimplementasikan antarmuka. Bantuan ini mematikan perpustakaan dalam tes tingkat yang lebih tinggi. Ini sangat berguna jika perpustakaan mengakses database atau data eksternal (mis. Mainframe). Dalam kasus seperti itu, memasukkan data mainframe atau basis data ke kondisi berulang mungkin akan lambat, dan mungkin tidak mungkin.
• Tes integrasi untuk setiap pustaka bisa komprehensif, tetapi hanya perlu dijalankan ketika sumber pustaka baru dilakukan.
• Tes integrasi tingkat tinggi seharusnya hanya memanggil perpustakaan dan menganggapnya sempurna.

Toko Java tempat saya bekerja menggunakan pendekatan ini, dan kami jarang menunggu tes integrasi dijalankan.

Pendekatan lain yang mungkin untuk tetap dalam tes integrasi pipa CI (atau segala jenis verifikasi, termasuk build) dengan waktu eksekusi yang lama atau membutuhkan sumber daya yang terbatas dan / atau mahal adalah beralih dari sistem CI tradisional berdasarkan verifikasi pasca-komitmen (yang merupakan rentan terhadap kemacetan ) ke satu berdasarkan verifikasi pra-komitmen .

Alih-alih secara langsung melakukan perubahan mereka ke pengembang cabang, kirimkan ke sistem verifikasi otomatis terpusat yang melakukan verifikasi dan:

• jika berhasil secara otomatis melakukan perubahan ke cabang
• jika tidak berhasil itu memberitahu pengirim masing-masing untuk mengevaluasi kembali perubahan mereka

Pendekatan semacam itu memungkinkan menggabungkan dan menguji bersama beberapa perubahan yang dikirimkan, berpotensi meningkatkan kecepatan verifikasi CI yang efektif berkali-kali.

Salah satu contohnya adalah sistem gating berbasis Gerrit / Zuul yang digunakan oleh OpenStack .

Satu lagi adalah ApartCI ( penafian - saya penciptanya dan pendiri perusahaan yang menawarkannya).