ความรู้สึกของการทดสอบหน่วยโดยไม่ต้อง TDD

เรามีโครงการใหม่ (ค่อนข้างใหญ่) เริ่มต้นที่เราวางแผนที่จะพัฒนาโดยใช้ TDD

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

เพิ่มเติม: ฉันคิดว่านี่ไม่ใช่คำถามที่ซ้ำกัน>> คำถามนี้ << - ฉันเข้าใจความแตกต่างระหว่าง UT และ TDD คำถามของฉันไม่เกี่ยวกับความแตกต่างแต่เกี่ยวกับความรู้สึกในการเขียนการทดสอบหน่วยที่ไม่มี TDD

ส่วนใหญ่จะใช้ TDD (1) เพื่อให้แน่ใจว่าครอบคลุม (2) และขับออกแบบที่บำรุงรักษาเข้าใจได้ทดสอบได้ หากคุณไม่ได้ใช้ TDD คุณจะไม่ได้รับการครอบคลุมโค้ดที่รับประกัน แต่นั่นไม่ได้หมายความว่าคุณควรละทิ้งเป้าหมายนั้นและใช้ชีวิตอย่างมีความครอบคลุมด้วยความคุ้มครอง 0%

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

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

อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันใช้ห้องสมุดบุคคลที่สามเพื่อทำงานเฉพาะอย่าง มีปัญหาเกี่ยวกับการใช้ห้องสมุดดังกล่าวดังนั้นฉันจึงตัดสินใจเขียนเวอร์ชันของไลบรารีเดียวกันนี้ด้วยตัวเอง โดยรวมแล้วมันก็เป็นโค้ดประมวลผลประมาณ 5,000 บรรทัดและเวลาของฉันประมาณ 2 เดือน ฉันรู้ว่าบรรทัดของโค้ดเป็นเมตริกที่ไม่ดี แต่สำหรับคำตอบนี้ฉันรู้สึกว่ามันเป็นตัวบ่งชี้ที่ดี

มีโครงสร้างข้อมูลหนึ่งที่ฉันต้องการซึ่งจะทำให้ฉันสามารถติดตามจำนวนบิตโดยพลการได้ เนื่องจากโปรเจ็กต์อยู่ใน Java ฉันเลือก Java BitSetและแก้ไขมันเล็กน้อย (ฉันต้องการความสามารถในการติดตามส่วนนำ0เช่นกันซึ่ง BitSet ของ Java ไม่ได้ทำด้วยเหตุผลบางอย่าง ..... ) หลังจากได้รับความคุ้มครองถึง 93% ฉันเริ่มเขียนแบบทดสอบที่จะเน้นระบบที่ฉันเขียน ฉันต้องการกำหนดมาตรฐานบางประการของฟังก์ชั่นเพื่อให้แน่ใจว่ามันจะเร็วพอสำหรับความต้องการขั้นสุดท้ายของฉัน แปลกใจหนึ่งในฟังก์ชั่นที่ฉันลบล้างจากBitSetอินเตอร์เฟซนั้นช้ามากเมื่อจัดการกับชุดบิตขนาดใหญ่ (หลายร้อยล้านบิตในกรณีนี้) ฟังก์ชั่นการเขียนทับอื่น ๆ อาศัยฟังก์ชั่นนี้ดังนั้นมันจึงเป็นคอขวดขนาดใหญ่

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

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

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

ในกรณีของฉันหากไม่มีการทดสอบหน่วยที่มีอยู่ฉันจะต้องหาวิธีการเพื่อให้มั่นใจว่าอัลกอริทึมทำงานได้ตลอดเวลา ไหนในท้ายที่สุด ... ฟังดูเหมือนการทดสอบหน่วยใช่ไหม?

คุณสามารถแบ่งรหัสคร่าว ๆ ออกเป็น 4 หมวดหมู่:

1. การเปลี่ยนแปลงที่ง่ายและไม่ค่อยมี
2. การเปลี่ยนแปลงที่ง่ายและบ่อยครั้ง
3. ซับซ้อนและไม่ค่อยมีการเปลี่ยนแปลง
4. การเปลี่ยนแปลงที่ซับซ้อนและบ่อยครั้ง

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

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

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

ตอนนี้เกี่ยวกับสาเหตุที่เพื่อนร่วมงานของคุณอาจต่อต้านการทดสอบหน่วยใด ๆ โดยไม่ใช้ TDD: อาจเป็นเพราะยากที่จะเชื่อถือการทดสอบที่เขียนขึ้นหลังจากรหัสการผลิต และถ้าคุณไม่สามารถไว้วางใจการทดสอบแบบอัตโนมัติของพวกเขาที่มีมูลค่าอะไร หลังจากรอบ TDD คุณต้องทำให้การทดสอบล้มเหลว (ด้วยเหตุผลที่ถูกต้อง) ก่อนจึงจะได้รับอนุญาตให้เขียนรหัสการผลิตเพื่อให้ผ่าน (และไม่มาก) กระบวนการนี้เป็นการทดสอบการทดสอบของคุณเป็นหลักดังนั้นคุณจึงสามารถเชื่อถือได้ ไม่ต้องพูดถึงความจริงที่ว่าการเขียนการทดสอบก่อนที่รหัสจริงจะผลักดันให้คุณออกแบบหน่วยและส่วนประกอบของคุณให้สามารถทดสอบได้ง่ายขึ้น (decoupling ระดับสูงใช้ SRP ฯลฯ ) ถึงแม้ว่าของหลักสูตรการทำ TDD จะใช้เวลาวินัย

แต่ถ้าคุณเขียนรหัสการผลิตทั้งหมดก่อนเมื่อคุณเขียนการทดสอบคุณจะคาดหวังให้พวกเขาผ่านการทดสอบครั้งแรก นี่เป็นปัญหาอย่างมากเพราะคุณอาจสร้างการทดสอบที่ครอบคลุม 100% ของรหัสการผลิตของคุณโดยไม่รบกวนพฤติกรรมที่ถูกต้อง (อาจไม่ได้ทำการยืนยันใด ๆ ! ฉันเห็นสิ่งนี้เกิดขึ้น ) เนื่องจากคุณไม่เห็นว่ามันล้มเหลว ก่อนเพื่อตรวจสอบว่ามันล้มเหลวด้วยเหตุผลที่ถูกต้อง ดังนั้นคุณอาจมีผลบวกเท็จ เท็จบวกจะทำลายความไว้วางใจในชุดทดสอบของคุณบังคับให้ผู้คนหันไปใช้การทดสอบด้วยตนเองอีกครั้งดังนั้นคุณจึงมีค่าใช้จ่ายของทั้งสองกระบวนการ (การเขียนการทดสอบ + การทดสอบด้วยตนเอง)

ซึ่งหมายความว่าคุณจะต้องค้นหาวิธีการอื่นทดสอบการทดสอบของคุณเช่น TDD ไม่ ดังนั้นคุณต้องทำการดีบักแสดงความคิดเห็นบางส่วนของรหัสการผลิต ฯลฯ เพื่อให้สามารถเชื่อถือการทดสอบได้ ปัญหาคือกระบวนการของ "การทดสอบการทดสอบของคุณ" ช้าลงมากด้วยวิธีนี้ การเพิ่มเวลานี้ถึงเวลาที่คุณจะใช้การทดสอบ Ad-hoc ด้วยตนเอง (เนื่องจากคุณไม่มีการทดสอบอัตโนมัติในขณะที่คุณกำลังเขียนโค้ดการผลิต) จากประสบการณ์ของฉันผลลัพธ์ในกระบวนการโดยรวมที่ช้ากว่าการฝึกซ้อมมาก TDD "โดยหนังสือ" (Kent Beck - TDD ตามตัวอย่าง) นอกจากนี้ฉันยินดีที่จะเดิมพันที่นี่และบอกว่า "การทดสอบการทดสอบของคุณ" อย่างแท้จริงหลังจากที่พวกเขาเขียนนั้นต้องใช้วินัยมากกว่า TDD

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

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

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

อันที่จริงลุงบ๊อบพูดถึงจุดที่น่าสนใจในวิดีโอ Clean Coders ของเขา เขากล่าวว่าวงจรสีแดง - เขียว - รีแฟคเตอร์สามารถใช้ได้ 2 วิธี

ที่หนึ่งคือวิธี TDD แบบดั้งเดิม เขียนการทดสอบที่ล้มเหลวจากนั้นทำการผ่านการทดสอบและสุดท้าย refactor

วิธีที่สองคือการเขียนรหัสการผลิตที่มีขนาดเล็กมากและตามด้วยการทดสอบหน่วยจากนั้นทำการรีแฟคเตอร์

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

อีกครั้งฉันทำซ้ำ (และสิ่งนี้เน้นโดยลุงบ๊อบ) ความคิดคือการไปในขั้นตอนที่เล็กมากและเพื่อทดสอบชิ้นส่วนของรหัสการผลิตที่เพิ่งเพิ่มเข้ามาทันที