คุณให้การทดสอบหน่วยของคุณใช้งานได้อย่างไรเมื่อทำการปรับโครงสร้างใหม่

ในอีกคำถามหนึ่งพบว่าหนึ่งในความเจ็บปวดกับ TDD กำลังรักษาชุดการทดสอบให้สอดคล้องกับรหัสฐานระหว่างและหลังการปรับโครงสร้างใหม่

ตอนนี้ฉันเป็นแฟนตัวยงของการฟื้นฟู ฉันจะไม่ยอมแพ้ที่จะทำ TDD แต่ฉันยังประสบปัญหาของการทดสอบที่เขียนในลักษณะที่การปรับเปลี่ยนเล็กน้อยทำให้เกิดความล้มเหลวในการทดสอบมากมาย

คุณจะหลีกเลี่ยงการทำลายการทดสอบเมื่อทำการเปลี่ยนโครงสร้างใหม่ได้อย่างไร

• คุณเขียนแบบทดสอบ 'ดีกว่า' หรือไม่? ถ้าเป็นเช่นนั้นคุณควรมองหาอะไร
• คุณหลีกเลี่ยงการ refactoring บางประเภทหรือไม่
• มีเครื่องมือทดสอบการปรับโครงสร้างใหม่หรือไม่?

แก้ไข:ฉันเขียนคำถามใหม่ที่ถามสิ่งที่ฉันต้องการถาม (แต่เก็บไว้เป็นตัวแปรที่น่าสนใจ)

สิ่งที่คุณกำลังพยายามทำนั้นไม่ได้ทำการปรับโครงสร้างใหม่จริงๆ ด้วย refactoring โดยนิยามคุณไม่เปลี่ยนแปลงสิ่งที่ซอฟแวร์ของคุณไม่คุณเปลี่ยนวิธีการที่มันไม่ได้

เริ่มต้นด้วยการทดสอบสีเขียวทั้งหมด (ผ่านทั้งหมด) จากนั้นทำการแก้ไข "ภายใต้ประทุน" (เช่นย้ายวิธีการจากคลาสที่ได้รับมาที่ฐานแยกวิธีหรือ encapsulate คอมโพสิตด้วยตัวสร้างฯลฯ ) การทดสอบของคุณควรผ่าน

สิ่งที่คุณกำลังอธิบายดูเหมือนจะไม่ได้ทำการปรับโครงสร้าง แต่เป็นการออกแบบใหม่ซึ่งยังเป็นการเพิ่มฟังก์ชันการทำงานของซอฟต์แวร์ของคุณภายใต้การทดสอบ TDD และ refactoring (ตามที่ฉันพยายามกำหนดไว้ที่นี่) ไม่ได้อยู่ในความขัดแย้ง คุณยังสามารถสร้างใหม่ (สีเขียวสีเขียว) และใช้ TDD (สีแดงสีเขียว) เพื่อพัฒนาฟังก์ชั่น "เดลต้า"

ข้อดีอย่างหนึ่งของการมีการทดสอบหน่วยคือคุณสามารถมั่นใจในการปรับโครงสร้างใหม่ได้อย่างมั่นใจ

หากการเปลี่ยนโครงสร้างไม่เปลี่ยนอินเทอร์เฟซสาธารณะคุณจะต้องออกจากการทดสอบหน่วยตามที่เป็นอยู่และให้แน่ใจว่าหลังจากทำการเปลี่ยนสถานะใหม่ทั้งหมดจะผ่านไป

หากการเปลี่ยนโครงสร้างเปลี่ยนอินเทอร์เฟซสาธารณะการทดสอบควรถูกเขียนใหม่ก่อน Refactor จนกว่าการทดสอบใหม่จะผ่าน

ฉันจะไม่หลีกเลี่ยงการเปลี่ยนโครงสร้างใด ๆ เพราะมันทำลายการทดสอบ การเขียนแบบทดสอบหน่วยอาจเป็นความเจ็บปวดในก้น แต่มันคุ้มค่ากับความเจ็บปวดในระยะยาว

ตรงกันข้ามกับคำตอบอื่น ๆ เป็นสิ่งสำคัญที่จะต้องทราบว่าวิธีการทดสอบบางอย่างอาจเปราะบางเมื่อระบบภายใต้การทดสอบ (SUT) ถูก refactored หากการทดสอบเป็น whitebox

ถ้าฉันใช้กรอบการเยาะเย้ยที่ตรวจสอบลำดับของวิธีการที่เรียกว่าบน mocks (เมื่อคำสั่งนั้นไม่เกี่ยวข้องเพราะการโทรนั้นไม่มีผลข้างเคียง) ถ้ารหัสของฉันสะอาดขึ้นด้วยวิธีการเหล่านั้นเรียกใช้ในลำดับที่แตกต่างกันและฉัน refactor แล้วการทดสอบของฉันจะแตก โดยทั่วไป mocks สามารถแนะนำให้ทดสอบความเปราะบาง

หากฉันกำลังตรวจสอบสถานะภายในของ SUT ของฉันโดยการเปิดเผยสมาชิกส่วนตัวหรือป้องกัน (เราสามารถใช้ "เพื่อน" ใน visual Basic หรือขยายระดับการเข้าถึง "ภายใน" และใช้ "internalsvisibleto" ใน c #; ในภาษา OO จำนวนมากรวมถึง c # a " สามารถใช้คลาสเฉพาะการทดสอบได้ ") จากนั้นสถานะภายในของคลาสจะสำคัญ - คุณอาจทำการปรับโครงสร้างคลาสเป็นกล่องดำ แต่การทดสอบกล่องสีขาวจะล้มเหลว สมมติว่ามีการใช้เขตข้อมูลเดียวซ้ำเพื่อหมายถึงสิ่งต่าง ๆ (ไม่ใช่แนวปฏิบัติที่ดี!) เมื่อ SUT เปลี่ยนสถานะ - หากเราแยกมันออกเป็นสองเขตข้อมูลเราอาจจำเป็นต้องเขียนการทดสอบที่ขาดอีกครั้ง

การทดสอบเฉพาะคลาสย่อยยังสามารถใช้ในการทดสอบวิธีการป้องกันซึ่งอาจหมายความว่าผู้ปรับเปลี่ยนจากมุมมองของรหัสการผลิตเป็นการเปลี่ยนแปลงที่เกิดขึ้นจากมุมมองของรหัสการทดสอบ การย้ายสองสามบรรทัดเข้าหรือออกจากวิธีการป้องกันอาจไม่มีผลข้างเคียงจากการผลิต แต่หยุดการทดสอบ

ถ้าฉันใช้ " test hooks " หรือรหัสเฉพาะการทดสอบหรือการรวบรวมตามเงื่อนไขอื่น ๆ มันอาจเป็นเรื่องยากที่จะตรวจสอบให้แน่ใจว่าการทดสอบไม่หยุดทำงานเนื่องจากการพึ่งพาที่เปราะบางต่อตรรกะภายใน

ดังนั้นเพื่อป้องกันไม่ให้การทดสอบเป็นคู่กับรายละเอียดภายในของ SUT อย่างใกล้ชิดมันอาจช่วยในการ:

• ใช้ต้นขั้วมากกว่า mocks หากเป็นไปได้ สำหรับข้อมูลเพิ่มเติมโปรดดูที่บล็อกของฟาบิโอ Periera ในการทดสอบซ้ำและบล็อกของฉันเกี่ยวกับการทดสอบซ้ำ
• หากใช้ mocks ให้หลีกเลี่ยงการตรวจสอบลำดับของวิธีการที่เรียกว่ายกเว้นว่ามีความสำคัญ
• พยายามหลีกเลี่ยงการตรวจสอบสถานะภายในของ SUT ของคุณ - ใช้ API ภายนอกถ้าเป็นไปได้
• พยายามหลีกเลี่ยงตรรกะเฉพาะของการทดสอบในรหัสการผลิต
• พยายามหลีกเลี่ยงการใช้คลาสย่อยเฉพาะสำหรับทดสอบ

จุดทั้งหมดข้างต้นเป็นตัวอย่างของการเชื่อมต่อกล่องขาวที่ใช้ในการทดสอบ ดังนั้นเพื่อหลีกเลี่ยงการทดสอบซ้ำอีกครั้งอย่างสมบูรณ์ให้ใช้การทดสอบกล่องดำของ SUT

คำแถลงการณ์ปฏิเสธความรับผิดชอบ: เพื่อจุดประสงค์ในการพูดคุยเกี่ยวกับการปรับโครงสร้างใหม่ที่นี่ฉันกำลังใช้คำกว้างขึ้นเล็กน้อยเพื่อรวมการเปลี่ยนแปลงการใช้ภายในโดยไม่มีผลกระทบภายนอก นักพิถีพิถันบางคนอาจไม่เห็นด้วยและอ้างถึงหนังสือ Refactoring ของมาร์ตินฟาวเลอร์และเคนท์เบ็คโดยเฉพาะ

ในทางปฏิบัติเรามักจะทำตามขั้นตอนที่ไม่ใหญ่กว่าการปฏิบัติการปรมาณูที่อธิบายไว้เล็กน้อยและโดยเฉพาะอย่างยิ่งการเปลี่ยนแปลงที่ทำให้รหัสการผลิตมีพฤติกรรมเหมือนกันจากภายนอกอาจไม่ปล่อยให้ผ่านการทดสอบ แต่ฉันคิดว่ามันยุติธรรมที่จะรวม "อัลกอริทึมทดแทนสำหรับอัลกอริทึมอื่นที่มีพฤติกรรมที่เหมือนกัน" เป็น refactor และฉันคิดว่าฟาวเลอร์เห็นด้วย มาร์ตินฟาวเลอร์บอกว่าการปรับโครงสร้างอาจทำลายการทดสอบ:

เมื่อคุณเขียนการทดสอบการเยาะเย้ยคุณกำลังทดสอบการโทรออกของ SUT เพื่อให้แน่ใจว่ามันจะพูดคุยกับซัพพลายเออร์อย่างถูกต้อง การทดสอบแบบคลาสสิกเพียงแค่สนใจเกี่ยวกับสถานะสุดท้าย - ไม่ใช่วิธีการที่ได้รับมา การทดสอบการเยาะเย้ยถากถางจึงมีมากขึ้นควบคู่ไปกับการใช้วิธีการ การเปลี่ยนลักษณะของการโทรไปหาผู้ทำงานร่วมกันมักจะทำให้การทดสอบการล้อเลียนแตก

[ ... ]

การเชื่อมต่อกับการนำไปใช้ยังรบกวนการปรับโครงสร้างเนื่องจากการเปลี่ยนแปลงการใช้งานมีแนวโน้มที่จะทำลายการทดสอบมากกว่าการทดสอบแบบดั้งเดิม

ฟาวเลอร์ - Mocks ไม่สมบูรณ์

หากการทดสอบของคุณแตกหักเมื่อคุณทำการปรับโครงสร้างใหม่แสดงว่าคุณไม่ได้ทำการปรับเปลี่ยนตามคำนิยามซึ่งก็คือ "การเปลี่ยนโครงสร้างของโปรแกรมของคุณโดยไม่เปลี่ยนพฤติกรรมของโปรแกรม"

บางครั้งคุณจำเป็นต้องเปลี่ยนพฤติกรรมการทดสอบของคุณ บางทีคุณอาจต้องรวมสองวิธีเข้าด้วยกัน (พูดผูก () และ Listen () ในคลาสซ็อกเก็ต TCP ที่กำลังฟัง) ดังนั้นคุณจึงมีส่วนอื่น ๆ ของรหัสของคุณพยายามและล้มเหลวในการใช้ API ที่มีการเปลี่ยนแปลงในขณะนี้ แต่นั่นไม่ใช่การปรับโครงสร้างใหม่!

ฉันคิดว่าปัญหาเกี่ยวกับคำถามนี้คือคนต่างใช้คำว่า 'การปรับโครงสร้างใหม่' แตกต่างกัน ฉันคิดว่าเป็นการดีที่สุดที่จะกำหนดสิ่งเล็ก ๆ น้อย ๆ ที่คุณอาจหมายถึง:

>  Keep the API the same, but change how the API is implemented internally
>  Change the API

อย่างที่คนอื่นบันทึกไว้แล้วถ้าคุณรักษา API ไว้เหมือนเดิมและการทดสอบการถดถอยทั้งหมดของคุณทำงานบน API สาธารณะคุณไม่ควรมีปัญหาใด ๆ การปรับโครงสร้างไม่ควรทำให้เกิดปัญหาใด ๆ การทดสอบที่ล้มเหลวใด ๆ EITHER หมายถึงรหัสเก่าของคุณมีข้อบกพร่องและการทดสอบของคุณไม่ดีหรือรหัสใหม่ของคุณมีข้อบกพร่อง

แต่มันค่อนข้างชัดเจน ดังนั้นคุณอาจหมายถึงโดยการสร้างใหม่ว่าคุณกำลังเปลี่ยน API

ดังนั้นฉันจะตอบวิธีที่จะเข้าใกล้!

• ก่อนอื่นให้สร้าง API ใหม่นั่นคือสิ่งที่คุณต้องการให้พฤติกรรม API ใหม่ของคุณเป็น หากเกิดขึ้นว่า API ใหม่นี้มีชื่อเหมือนกับ OLDER API ฉันจะผนวกชื่อ _NEW ต่อท้ายชื่อ API ใหม่

  int DoSomethingInterestingAPI ();

กลายเป็น:

int DoSomethingInterestingAPI_NEW( int takes_more_arguments );
int DoSomethingInterestingAPI_OLD();
int DoSomethingInterestingAPI() { DoSomethingInterestingAPI_NEW (whatever_default_mimics_the_old_API);

ตกลง - ในขั้นตอนนี้ - การทดสอบการถดถอยทั้งหมดของคุณผ่านบัตรผ่าน - ใช้ชื่อ DoSomethingInterestingAPI ()

ถัดไปอ่านรหัสของคุณและเปลี่ยนการโทรทั้งหมดเป็น DoSomethingInterestingAPI () เป็นตัวแปรที่เหมาะสมของ DoSomethingInterestingAPI_NEW () ซึ่งรวมถึงการอัปเดต / เขียนใหม่ส่วนใดของการทดสอบการถดถอยของคุณจะต้องเปลี่ยนเพื่อใช้ API ใหม่

ถัดไปทำเครื่องหมาย DoSomethingInterestingAPI_OLD () เป็น [[คัดค้าน ()]] เก็บ API ที่เลิกใช้ไว้นานเท่าที่คุณต้องการ (จนกว่าคุณจะได้รับการอัปเดตรหัสทั้งหมดอย่างปลอดภัยที่อาจต้องพึ่งพา)

ด้วยวิธีนี้ความล้มเหลวใด ๆ ในการทดสอบการถดถอยของคุณก็คือบั๊กในการทดสอบการถดถอยนั้นหรือระบุข้อบกพร่องในรหัสของคุณ - ตรงตามที่คุณต้องการ กระบวนการในขั้นตอนการแก้ไข API นี้โดยการสร้าง API ของ _NEW และ _OLD อย่างชัดเจนช่วยให้คุณมีบิตของรหัสใหม่และเก่าที่อยู่ร่วมกันชั่วขณะหนึ่ง

ฉันถือว่าการทดสอบหน่วยของคุณมีความละเอียดที่ฉันจะเรียกว่า "stupid" :) นั่นคือพวกเขาทดสอบ minutiae สัมบูรณ์ของแต่ละคลาสและฟังก์ชั่น ออกห่างจากเครื่องมือสร้างรหัสและเขียนการทดสอบที่ใช้กับพื้นผิวที่ใหญ่ขึ้นจากนั้นคุณสามารถปรับโครงสร้างภายในได้มากเท่าที่คุณต้องการโดยรู้ว่าอินเตอร์เฟสของโปรแกรมประยุกต์ของคุณไม่เปลี่ยนแปลงและการทดสอบของคุณยังคงทำงาน

หากคุณต้องการมีการทดสอบหน่วยที่ทดสอบแต่ละวิธีและทุกวิธีแล้วคาดว่าจะต้องปรับโครงสร้างพวกเขาในเวลาเดียวกัน

ทำให้ชุดการทดสอบซิงค์กับ codebase ระหว่างและหลังการปรับโครงสร้างใหม่

สิ่งที่ทำให้มันยากคือการแต่งงานกัน การทดสอบใด ๆ ที่มาพร้อมกับระดับของการมีเพศสัมพันธ์กับรายละเอียดการใช้งาน แต่การทดสอบหน่วย (ไม่ว่าจะเป็น TDD หรือไม่) โดยเฉพาะอย่างยิ่งมันไม่ดีเพราะมันเข้าไปยุ่งกับ internals: การทดสอบหน่วยเพิ่มเติมเท่ากับรหัสมากขึ้น ของหน่วย - อย่างน้อยที่สุด

"หน่วย" ตามคำนิยามคือรายละเอียดการใช้งานในระดับต่ำส่วนต่อประสานของหน่วยสามารถและควรเปลี่ยน / แยก / รวมและมิฉะนั้นกลายพันธุ์เป็นระบบวิวัฒนาการ ความอุดมสมบูรณ์ของการทดสอบหน่วยสามารถขัดขวางวิวัฒนาการนี้ได้จริงมากกว่าที่เป็นอยู่

จะหลีกเลี่ยงการทำลายการทดสอบเมื่อทำการเปลี่ยนโครงสร้างใหม่ได้อย่างไร? หลีกเลี่ยงการแต่งงานกัน ในทางปฏิบัติมันหมายถึงหลีกเลี่ยงการทดสอบหน่วยมากที่สุดและต้องการการทดสอบระดับสูงขึ้น / บูรณาการมากขึ้นไม่เชื่อเรื่องพระเจ้าของรายละเอียดการใช้งาน โปรดจำไว้ว่าแม้ว่าจะไม่มี bullet เงินการทดสอบยังคงต้องมีบางสิ่งบางอย่างในระดับหนึ่ง แต่ควรจะเป็นอินเทอร์เฟซที่มีการกำหนดเวอร์ชันอย่างชัดเจนโดยใช้ Semantic Versioning โดยปกติแล้วจะอยู่ในระดับ api / application ที่เผยแพร่ สำหรับทุกหน่วยในโซลูชันของคุณ)

การทดสอบของคุณเชื่อมโยงอย่างแน่นหนากับการนำไปใช้และไม่ใช่ข้อกำหนด

ลองเขียนข้อสอบของคุณด้วยความคิดเห็นแบบนี้:

//given something
...test code...
//and something else
...test code...
//when something happens
...test code...
//then the state should be...
...test code...

วิธีนี้คุณจะไม่สามารถปรับความหมายของการทดสอบได้อีก