Strategi percabangan Git terintegrasi dengan proses pengujian / QA

131

Tim pengembangan kami telah menggunakan strategi percabangan GitFlow dan ini sangat luar biasa!

Baru-baru ini kami merekrut beberapa penguji untuk meningkatkan kualitas perangkat lunak kami. Idenya adalah bahwa setiap fitur harus diuji / QA oleh tester.

Di masa lalu, pengembang bekerja pada fitur pada cabang fitur yang terpisah dan menggabungkannya kembali ke developcabang setelah selesai. Pengembang akan menguji sendiri karyanya di featurecabang itu. Sekarang dengan penguji, kami mulai menanyakan pertanyaan ini

Di cabang mana tester menguji fitur baru?

Jelas, ada dua opsi:

  • pada cabang fitur individu
  • di developcabang

Pengujian Di Kembangkan Cabang

Awalnya, kami percaya ini adalah cara yang pasti untuk dilakukan karena:

  • Fitur ini diuji dengan semua fitur lainnya digabungkan ke developcabang sejak pengembangannya dimulai.
  • Konflik apa pun dapat dideteksi lebih awal dari nanti
  • Itu membuat pekerjaan penguji mudah, ia hanya berurusan dengan satu cabang ( develop) setiap saat. Dia tidak perlu bertanya kepada pengembang tentang cabang mana untuk fitur apa (cabang fitur adalah cabang pribadi yang dikelola secara eksklusif dan bebas oleh pengembang yang relevan)

Masalah terbesar dengan ini adalah:

  • The developcabang tercemar dengan bug.

    Ketika penguji menemukan bug atau konflik, ia melaporkannya kembali ke pengembang, yang memperbaiki masalah pada pengembangan cabang (cabang fitur ditinggalkan setelah digabungkan), dan mungkin ada lebih banyak perbaikan yang diperlukan setelahnya. Multiple commitence melakukan atau menggabungkan (jika suatu cabang diciptakan kembali dari developcabang lagi untuk memperbaiki bug) membuat memutar kembali fitur dari developcabang menjadi sangat sulit jika memungkinkan. Ada beberapa fitur yang digabungkan dan diperbaiki di developcabang pada waktu yang berbeda. Ini menciptakan masalah besar ketika kami ingin membuat rilis dengan hanya beberapa fitur di developcabang

Menguji Cabang Fitur

Jadi kami berpikir lagi dan memutuskan untuk menguji fitur pada cabang fitur. Sebelum kami menguji, kami menggabungkan perubahan dari developcabang ke cabang fitur (mengejar ketinggalan dengan developcabang). Ini bagus:

  • Anda masih menguji fitur dengan fitur lain di arus utama
  • Pengembangan lebih lanjut (misalnya perbaikan bug, penyelesaian konflik) tidak akan mencemari developcabang;
  • Anda dapat dengan mudah memutuskan untuk tidak merilis fitur sampai sepenuhnya diuji dan disetujui;

Namun, ada beberapa kekurangannya

  • Penguji harus melakukan penggabungan kode, dan jika ada konflik (sangat mungkin), ia harus meminta bantuan pengembang. Penguji kami berspesialisasi dalam pengujian dan tidak mampu mengkode.
  • suatu fitur dapat diuji tanpa adanya fitur baru lainnya. mis. Fitur A dan B keduanya sedang diuji pada saat yang sama, kedua fitur tersebut tidak mengetahui satu sama lain karena tidak satu pun dari mereka telah digabungkan ke developcabang. Ini berarti Anda harus menguji terhadap developcabang lagi ketika kedua fitur tersebut digabungkan ke cabang berkembang. Dan Anda harus ingat untuk menguji ini di masa depan.
  • Jika Fitur A dan B keduanya diuji dan disetujui, tetapi ketika konflik digabungkan diidentifikasi, kedua pengembang untuk kedua fitur percaya itu bukan kesalahannya sendiri / pekerjaan karena cabang fitur-fiturnya melewati tes. Ada overhead tambahan dalam komunikasi, dan kadang-kadang siapa pun yang menyelesaikan konflik frustrasi.

Di atas adalah kisah kami. Dengan sumber daya terbatas, saya ingin menghindari menguji semuanya di mana-mana. Kami masih mencari cara yang lebih baik untuk mengatasi hal ini. Saya akan senang mendengar bagaimana tim lain menangani situasi seperti ini.

git testing qa git-flow David Lin
sumber
5
Pertanyaan ini sepertinya lebih cocok untuk Programmer , karena tidak berurusan dengan masalah pemrograman, melainkan proses pengembangan. Bisakah seseorang memigrasikannya?
4
pertanyaan yang gembira: Bagaimana seharusnya Git Flow bekerja dengan QA menguji baik sebuah rilis maupun fitur baru?
Joshua Goldberg
2
Model kami persis sama. Saya tertarik mendengar tentang bagaimana tim QA Anda melaporkan masalah pada cabang fitur berbeda dari masalah di lapangan atau masalah selama proses UAT (jika Anda memilikinya). Kami menggunakan Atlassian JIRA dan kami memiliki alur kerja yang berbeda untuk keduanya.
void.pointer
2
Memutuskan hal yang sama sekarang. Plus, karena lingkungan kita adalah aplikasi pegas java, dibutuhkan sekitar 20 menit untuk membangun dan menggunakan untuk menguji lingkungan. Senang seseorang menanyakan keraguan yang sama dengan yang saya miliki.
digao_mb
Kelemahan pertama tidak melekat pada proses pengujian pada cabang fitur. Alat-alat seperti Github Enterprise dan Bitbucket memiliki kemampuan untuk meminta persetujuan untuk permintaan tarik dan orang yang bertanggung jawab untuk QA dapat menyetujui pensinyalan kepada pengembang bahwa mereka bebas untuk bergabung ke dalam pengembangan.
Derek Greer

Jawaban:

102

Cara kami melakukannya adalah sebagai berikut:

Kami menguji pada cabang fitur setelah kami menggabungkan mengembangkan kode cabang terbaru pada mereka. Alasan utamanya adalah bahwa kami tidak ingin "mencemari" kode cabang pengembangan sebelum fitur diterima. Dalam hal fitur tidak akan diterima setelah pengujian tetapi kami ingin merilis fitur lain yang sudah bergabung pada pengembangan yang akan menjadi neraka. Develop adalah cabang dari mana rilis dibuat dan dengan demikian harus lebih baik dalam keadaan yang bisa dirilis. Versi panjangnya adalah kami menguji dalam banyak fase. Lebih analitis:

  1. Pengembang membuat cabang fitur untuk setiap fitur baru.
  2. Cabang fitur (secara otomatis) digunakan di lingkungan TEST kami dengan setiap komit untuk diuji oleh pengembang.
  3. Ketika pengembang selesai dengan penyebaran dan fitur siap untuk diuji, ia menggabungkan cabang pengembangan pada cabang fitur dan menyebarkan cabang fitur yang berisi semua perubahan pengembangan terbaru pada TEST.
  4. Penguji menguji TEST. Ketika selesai, dia "menerima" cerita dan menggabungkan cabang fitur pada pengembangan. Karena pengembang sebelumnya telah menggabungkan cabang pengembangan pada fitur, kami biasanya tidak mengharapkan terlalu banyak konflik. Namun, jika itu masalahnya pengembang dapat membantu. Ini adalah langkah yang rumit, saya pikir cara terbaik untuk menghindarinya adalah dengan menjaga fitur sekecil / sespesifik mungkin. Berbagai fitur pada akhirnya harus digabungkan, dengan satu atau lain cara. Tentu saja ukuran tim berperan dalam kompleksitas langkah ini.
  5. Cabang berkembang juga (secara otomatis) dikerahkan di TEST. Kami memiliki kebijakan bahwa meskipun pembangunan cabang fitur dapat gagal, pengembangan cabang tidak boleh gagal.
  6. Setelah kami mencapai pembekuan fitur, kami membuat rilis dari pengembangan. Ini secara otomatis digunakan pada STAGING. Tes ujung ke ujung yang ekstensif berlangsung di sana sebelum penyebaran produksi. (ok mungkin saya sedikit melebih-lebihkan mereka tidak terlalu luas tapi saya pikir mereka seharusnya). Idealnya penguji beta / kolega yaitu pengguna nyata harus menguji di sana.

Apa pendapat Anda tentang pendekatan ini?

Aspasia
sumber
2
Bagaimana kita memastikan bahwa feature1 dan feature2 yang diuji secara independen juga baik untuk disatukan (seperti yang disebutkan dalam pertanyaan)?
Kumar Deepak
2
kita lakukan secara tidak langsung, dengan menggabungkan satu dan yang lain untuk berkembang. Ini adalah langkah 4 dari proses di atas dan ini berkaitan dengan urutan kronologis. Jadi jika fitur 2 siap untuk digabung tetapi fitur 1 sudah digabungkan, pengembang dan tester fitur 2 harus memastikan bahwa penggabungan mereka akan berfungsi.
Aspasia
1
Saya pikir tetap menurut model percabangan git ini Anda tidak seharusnya menggabungkan dua cabang fitur satu sama lain.
Aspasia
1
Kami telah mengalami masalah di langkah 6, terutama di masa krisis dengan beberapa fitur yang dipindahkan untuk dikembangkan, karena penggabungan non-sepele yang terjadi setelah QA telah menandatangani di cabang fitur, meskipun menggabungkan devlop ke fitur selambat mungkin. Saya berkomentar sedikit lebih rinci di sini: stackoverflow.com/a/25247382/411282
Joshua Goldberg
8
Apakah Anda memiliki Lingkungan TEST lengkap (DB, Server, Klien, dll) untuk setiap cabang fitur? Atau apakah mereka berbagi Lingkungan dan hanya memiliki nama yang berbeda (mis. App-name_feature1- app-name_feature2, dll.)
hinneLinks
41

Sebelum pengujian, kami menggabungkan perubahan dari cabang pengembangan ke cabang fitur

Tidak. Jangan, terutama jika 'kita' adalah penguji QA. Penggabungan akan melibatkan penyelesaian potensi konflik, yang paling baik dilakukan oleh pengembang (mereka tahu kode mereka), dan bukan oleh penguji QA (yang harus melanjutkan untuk menguji secepat mungkin).

Buat pengembang melakukan rebase atas featurecabangnya di atasdevel , dan dorong featurecabang itu (yang telah divalidasi oleh pengembang sebagai kompilasi dan bekerja di atas develnegara cabang terbaru ).
Itu memungkinkan untuk:

Setiap kali tester mendeteksi bug, ia akan melaporkannya kepada pengembang dan menghapus cabang fitur saat ini.
Pengembang dapat:

  • perbaiki bug
  • rebase di atas cabang pengembangan yang baru diambil (sekali lagi, untuk memastikan bahwa kodenya bekerja dalam integrasi dengan fitur yang divalidasi lainnya)
  • dorong featurecabang.

Gagasan umum: pastikan bagian penggabungan / integrasi dilakukan oleh pengembang, serahkan pengujian ke QA.

VONC
sumber
Apakah Anda mengatakan "jangan gunakan gabungan, gunakan rebase saja"? Jika demikian, saya bingung, diberikan FAQ Git tentang perbedaan antara keduanya: git.wiki.kernel.org/index.php/…
Vicki Laidler
1
@VickiLaidler ya, jika cabang fitur ditolak oleh QA, pengembang harus melakukan rebase, bukan penggabungan ( stackoverflow.com/a/804178/6309 )
VonC
1
@VonC Saya setuju sepenuhnya tetapi ada beberapa masalah: 1) Menghapus cabang berdampak pada perkakas lain, seperti Stash Pull Requests (menghapus cabang menutup PR). Lebih suka memaksa mendorong. 2) Jika itu adalah cabang fitur besar di mana selama masa hidupnya dua orang berkolaborasi, penggabungan akan lebih disukai daripada rebasing. Memundurkannya kembali pada akhirnya akan menciptakan mimpi buruk konflik karena komitmen gabungan akan dihapus, dan jika kode bergantung pada perubahan gabungan tersebut, itu tidak mudah untuk diperbaiki
void.pointer
1
Melihat kembali jawaban saya, saya juga akan melakukan rebase dan bukan penggabungan untuk sejarah yang lebih bersih.
Aspasia
1
@Aspasia Poin bagus. Saya telah memasukkan permintaan tarik dalam jawaban untuk lebih banyak visibilitas.
VonC
12

Pendekatan terbaik adalah integrasi berkelanjutan , di mana ide umumnya adalah untuk menggabungkan cabang fitur ke cabang pengembang sesering mungkin. Ini mengurangi overhead dari penggabungan nyeri.

Andalkan tes otomatis sebanyak mungkin, dan buat build secara otomatis dengan unit test oleh Jenkins. Mintalah pengembang melakukan semua pekerjaan dengan menggabungkan perubahan mereka ke cabang utama dan menyediakan unit test untuk semua kode mereka.

Penguji / QA dapat berpartisipasi dalam ulasan kode, memeriksa pengujian unit dan menulis tes integrasi otomatis untuk ditambahkan ke suite regresi ketika fitur-fitur selesai.

Untuk info lebih lanjut, periksa tautan ini .

Johnny Z
sumber
Anda masih dapat melakukan CI dengan cabang + rebasing di Git.
void.pointer
9

Kami menggunakan apa yang kami sebut "emas", "perak", dan "perunggu". Ini bisa disebut prod, staging, dan qa.

Saya datang untuk menyebut ini model melting pot. Ini bekerja dengan baik bagi kami karena kami memiliki kebutuhan besar untuk QA di sisi bisnis hal karena persyaratan mungkin sulit dipahami vs teknis.

Ketika bug atau fitur siap untuk pengujian itu masuk ke "perunggu". Ini memicu jenkins build yang mendorong kode ke lingkungan pre-built. Penguji kami (bukan teknisi super) hanya menekan sebuah tautan dan tidak peduli dengan kontrol sumber. Build ini juga menjalankan tes, dll. Kami bolak-balik pada build ini benar-benar mendorong kode ke lingkungan pengujian \ qa jika pengujian (unit, integrasi, selenium) gagal. Jika Anda menguji pada sistem yang terpisah (kami menyebutnya timbal), Anda dapat mencegah perubahan dari didorong ke lingkungan qa Anda.

Ketakutan awal adalah bahwa kita akan memiliki banyak konflik antara fitur ini. Itu memang terjadi adalah fitur X membuatnya tampak seperti fitur Y sedang rusak, tetapi itu cukup jarang dan benar-benar membantu. Ini membantu mendapatkan petak luas pengujian di luar apa yang tampaknya adalah konteks perubahan. Beruntung kali Anda akan mengetahui bagaimana perubahan Anda memengaruhi pengembangan paralel.

Setelah fitur melewati QA, kita memindahkannya ke "silver" atau staging. Membangun dijalankan dan tes dijalankan lagi. Setiap minggu kami mendorong perubahan ini ke "emas" atau pohon produksi kami dan kemudian menyebarkannya ke sistem produksi kami.

Pengembang memulai perubahan mereka dari pohon emas. Secara teknis Anda bisa mulai dari pementasan karena itu akan segera naik.

Perbaikan darurat dijatuhkan langsung ke pohon emas. Jika perubahan sederhana dan sulit untuk QA, ia bisa langsung menjadi perak yang akan menemukan jalannya ke pohon pengujian.

Setelah rilis kami, kami mendorong perubahan dalam emas (prod) ke perunggu (pengujian) hanya untuk menjaga semuanya sinkron.

Anda mungkin ingin rebase sebelum mendorong ke folder pementasan Anda. Kami telah menemukan bahwa membersihkan pohon pengujian dari waktu ke waktu membuatnya tetap bersih. Ada kalanya fitur ditinggalkan di pohon pengujian terutama jika pengembang pergi.

Untuk fitur multi-pengembang besar kami membuat repo bersama yang terpisah, tetapi menggabungkannya ke pohon pengujian sama ketika kita semua siap. Hal-hal yang dilakukan cenderung memantul dari QA sehingga penting untuk menjaga perubahan Anda terisolasi sehingga Anda dapat menambahkan dan kemudian menggabungkan / squash ke pohon pementasan Anda.

"Memanggang" juga merupakan efek samping yang bagus. Jika Anda memiliki perubahan mendasar, Anda ingin duduk sebentar sementara ada tempat yang bagus untuk itu.

Juga perlu diingat bahwa kami tidak mempertahankan rilis sebelumnya. Versi saat ini selalu merupakan satu-satunya versi. Meski begitu, Anda mungkin bisa memiliki master baking tree di mana penguji atau komunitas Anda dapat melihat bagaimana berbagai kontributor berinteraksi.

Eric Twilegar
sumber
1

Saya tidak akan bergantung pada pengujian manual saja. Saya akan mengotomatiskan pengujian setiap cabang fitur dengan Jenkins. Saya menyiapkan laboratorium VMWare untuk menjalankan tes Jenkins di Linux dan Windows untuk semua browser. Ini benar-benar browser lintas yang luar biasa, solusi pengujian lintas platform. Saya menguji fungsional / integrasi dengan Selenium Webdriver. Tes selenium saya berjalan di bawah Rspec. Dan saya menulisnya secara khusus untuk dimuat oleh jRuby di Windows. Saya menjalankan tes unit tradisional di bawah uji Rspec dan Javascript di bawah Jasmine. Saya menyiapkan pengujian tanpa kepala dengan Phantom JS.

Natus Drew
sumber
1

Di perusahaan kami, kami tidak dapat menggunakan pengembangan lincah dan membutuhkan persetujuan untuk setiap perubahan oleh bisnis, ini menyebabkan banyak masalah.

Pendekatan kami untuk bekerja dengan GIT adalah ini;

Kami telah menerapkan "Git Flow" di perusahaan kami. Kami menggunakan JIRA dan hanya Tiket JIRA yang disetujui yang harus diproduksi. Untuk persetujuan Tes kami memperluasnya dengan menciptakan Cabang Uji yang terpisah.

Langkah-langkah untuk memproses Tiket JIRA adalah:

  1. Buat Cabang baru dari Develop-Branch
  2. Lakukan perubahan Kode pada Cabang Fitur
  3. Tarik dari Feature the Changes to the Test / QA Branch
  4. Setelah persetujuan bisnis kami menarik perubahan dari cabang fitur menjadi pengembangan
  5. Berkembang sering dalam rilis dan akhirnya menguasai cabang

Memisahkan setiap permintaan dalam fitur sendiri memastikan, hanya perubahan yang disetujui untuk produksi.

Proses lengkapnya terlihat seperti ini: masukkan deskripsi gambar di sini

Christian Müller
sumber