TDD ทำให้การเขียนโปรแกรมเชิงป้องกันซ้ำซ้อนหรือไม่?

วันนี้ฉันมีการสนทนาที่น่าสนใจกับเพื่อนร่วมงาน

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

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

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

นั่นไร้สาระ TDD บังคับให้รหัสผ่านการทดสอบและบังคับให้รหัสทั้งหมดมีการทดสอบรอบ ๆ มันไม่ได้ป้องกันผู้บริโภคของคุณจากการเรียกรหัสไม่ถูกต้องและไม่ได้ป้องกันการเขียนโปรแกรมที่ขาดหายไปอย่างน่าอัศจรรย์

ไม่มีวิธีการใดที่บังคับให้ผู้ใช้ใช้รหัสอย่างถูกต้อง

มีคืออาจจะโดยคุณเพิ่มการตรวจสอบ - การโต้เถียงเล็กน้อยที่จะทำว่าถ้าคุณได้อย่างสมบูรณ์แบบได้ TDD ที่คุณจะได้จับเช็ค> 0 ในกรณีการทดสอบก่อนที่จะมีการดำเนินการนั้นและการแก้ไขนี้ แต่ถ้าคุณทำ TDD, ความต้องการของคุณ (> 0 ในตัวสร้าง) จะเป็นครั้งแรกปรากฏเป็น testcase ที่ล้มเหลว ดังนั้นให้คุณทดสอบหลังจากที่คุณเพิ่มเช็คของคุณ

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

หรือว่าทั้งสองเทคนิคเติมเต็มซึ่งกันและกัน?

TDD จะพัฒนาการทดสอบ การใช้การตรวจสอบความถูกต้องของพารามิเตอร์จะทำให้พวกเขาผ่านไป

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

ในความปลอดภัยของข้อมูลนี้เรียกว่ากลาโหมในเชิงลึก การมีเลเยอร์การป้องกันหลายชั้นทำให้มั่นใจได้ว่าหากล้มเหลว

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

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

ใน TDD คุณไม่ควรเขียนโค้ดโดยไม่ต้องเขียนการทดสอบก่อน - ตามวงจรสีแดง - เขียว - refactor อย่างเคร่งครัด นั่นหมายความว่าหากคุณต้องการเพิ่มการตรวจสอบความถูกต้องอันดับแรกให้เขียนการทดสอบก่อนที่ต้องการการตรวจสอบความถูกต้องนี้ โทรหาวิธีที่เป็นปัญหาด้วยตัวเลขติดลบและมีศูนย์และคาดว่าจะทำให้เกิดข้อยกเว้น

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

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

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

การทดสอบพร้อมให้การสนับสนุนและรับประกันการโปรแกรมป้องกัน

การตั้งโปรแกรมการป้องกันป้องกันความสมบูรณ์ของระบบที่รันไทม์

การทดสอบเป็นเครื่องมือวินิจฉัย (ส่วนใหญ่คงที่) ที่รันไทม์การทดสอบของคุณจะไม่ปรากฏให้เห็น มันเหมือนกับนั่งร้านที่ใช้ทำกำแพงอิฐสูงหรือโดมหิน คุณไม่ได้ทิ้งชิ้นส่วนที่สำคัญออกจากโครงสร้างเพราะคุณมีโครงยกที่ยึดไว้ในระหว่างการก่อสร้าง คุณมีนั่งร้านยกมันขึ้นในระหว่างการก่อสร้างเพื่ออำนวยความสะดวกในการวางชิ้นส่วนที่สำคัญทั้งหมด

แก้ไข: การเปรียบเทียบ

สิ่งที่เกี่ยวกับการเปรียบเทียบความคิดเห็นในรหัส?

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

ดังนั้นสมมติว่าคุณใส่ความรู้พื้นฐานของโค้ดในการทดสอบเช่น MethodA ไม่สามารถใช้ค่า Null และอาร์กิวเมนต์ของ MethodB ต้องเป็น> 0เช่นนั้น จากนั้นรหัสจะเปลี่ยน Null ไม่เป็นไรสำหรับ A ในขณะนี้และ B สามารถรับค่าขนาดเล็กเป็น -10 ขณะนี้การทดสอบที่มีอยู่ผิดปกติ แต่จะผ่านต่อไป

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

การทดสอบจะตรวจสอบพฤติกรรมของระบบ พฤติกรรมที่แท้จริงนั้นเป็นสิ่งที่แท้จริงต่อระบบนั้นเองไม่ใช่เพื่อการทดสอบ

สิ่งที่อาจจะผิดไป?

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

ซึ่งหมายความว่าการเขียนโปรแกรมการป้องกันเป็นจุด

TDD ไดรฟ์เขียนโปรแกรมป้องกันหากการทดสอบที่ครอบคลุม

การทดสอบเพิ่มเติมการขับขี่โปรแกรมการป้องกันที่มากขึ้น

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

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

พูดโดยทั่วไป ...

ตัวอย่างเช่นถ้าอาร์กิวเมนต์ null ของโพรซีเดอร์เฉพาะนั้นไม่ถูกต้องการทดสอบอย่างน้อยหนึ่งครั้งจะผ่านโมฆะและจะต้องมีข้อยกเว้น / ข้อผิดพลาดบางอย่าง

อย่างน้อยหนึ่งการทดสอบอื่น ๆ จะผ่านการโต้แย้งที่ถูกต้องแน่นอน - หรือวนซ้ำผ่านอาร์เรย์ขนาดใหญ่และผ่านการขัดแย้งที่ถูกต้องมากมายและยืนยันว่าสถานะผลลัพธ์นั้นเหมาะสม

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

ซึ่งอาจทำให้เกิดพฤติกรรมที่ไม่คาดคิดในบางส่วนที่แตกต่างกันอย่างสิ้นเชิงของระบบที่เช่นชั้นที่ได้รับการส่งผ่านไปในสถานที่ห่างไกลทางภูมิศาสตร์บางอย่างหลังจากที่ซอฟแวร์ที่มีการจัดส่ง และนั่นคือสิ่งที่เรากำลังพยายามหลีกเลี่ยงใช่ไหม?

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

โดยเฉพาะอย่างยิ่งหากโปรแกรมเมอร์ของระบบอื่นนั้นไม่ได้รับรหัสป้องกัน

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

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

1. การยืนยันเป็นทางเลือกดังนั้นหากคุณไม่ชอบให้เปิดใช้งานระบบโดยปิดการใช้งานการยืนยัน

2. การยืนยันการตรวจสอบสิ่งต่าง ๆ ที่การทดสอบไม่สามารถทำได้ (และไม่ควร) เนื่องจากการทดสอบนั้นควรมีมุมมองกล่องดำในระบบของคุณในขณะที่การยืนยันนั้นมีมุมมองแบบกล่องสีขาว (แน่นอนเพราะพวกเขาอาศัยอยู่ในนั้น)

3. การยืนยันเป็นเครื่องมือเอกสารที่ยอดเยี่ยม ไม่เคยมีใครแสดงความคิดเห็นหรือเคยเป็นอย่างที่คลุมเครือเหมือนโค้ดที่ยืนยันสิ่งเดียวกัน นอกจากนี้เอกสารมีแนวโน้มที่จะล้าสมัยเป็นรหัสวิวัฒนาการและมันก็ไม่ได้บังคับใช้โดยคอมไพเลอร์

4. การยืนยันสามารถตรวจจับข้อผิดพลาดในรหัสการทดสอบ คุณเคยเจอสถานการณ์ที่การทดสอบล้มเหลวและคุณไม่รู้ว่าใครเป็นคนผิด - รหัสการผลิตหรือการทดสอบ?

5. การยืนยันสามารถทำได้มากกว่าการทดสอบ การทดสอบจะตรวจสอบสิ่งที่กำหนดโดยความต้องการด้านการใช้งาน แต่บ่อยครั้งที่รหัสจะต้องมีการตั้งสมมติฐานบางอย่างที่เป็นเทคนิคมากไปกว่านั้น ผู้ที่เขียนเอกสารข้อกำหนดด้านการทำงานไม่ค่อยนึกถึงการหารด้วยศูนย์

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

7. การยืนยันลดความซับซ้อนของโปรแกรม ทุกบรรทัดของโค้ดที่คุณเขียนจะเพิ่มความซับซ้อนของโปรแกรม คำยืนยันและคำสำคัญfinal( readonly) เป็นคำสั่งสร้างเพียงสองคำเท่านั้นที่ฉันรู้ว่านั่นช่วยลดความซับซ้อนของโปรแกรม นั่นเป็นสิ่งที่ประเมินค่ามิได้

8. การยืนยันช่วยให้คอมไพเลอร์เข้าใจโค้ดของคุณได้ดีขึ้น โปรดลองทำที่บ้าน: void foo( Object x ) { assert x != null; if( x == null ) { } }คอมไพเลอร์ของคุณควรออกคำเตือนบอกคุณว่าสภาพx == nullเป็นเท็จเสมอ ที่มีประโยชน์มาก

ด้านบนเป็นบทสรุปของโพสต์จากบล็อกของฉัน, 2014-09-21 "การยืนยันและการทดสอบ"

ฉันเชื่อว่าคำตอบส่วนใหญ่ขาดความแตกต่างที่สำคัญ: ขึ้นอยู่กับว่าจะใช้โค้ดของคุณอย่างไร

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

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

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

ข้อโต้แย้งนี้ทำให้ฉันงุนงงเพราะเมื่อฉันเริ่มฝึก TDD หน่วยของฉันทดสอบแบบฟอร์ม "วัตถุตอบสนอง <วิธีที่แน่นอน> เมื่อ <อินพุตไม่ถูกต้อง>" เพิ่มขึ้น 2 หรือ 3 ครั้ง ฉันสงสัยว่าเพื่อนร่วมงานของคุณสามารถจัดการเพื่อผ่านการทดสอบหน่วยเหล่านั้นได้สำเร็จโดยที่หน้าที่ของเขาไม่ผ่านการตรวจสอบ

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

กล่าวอีกนัยหนึ่งสิ่งที่ TDD ไม่ได้ป้องกันไม่ให้คุณต้องใช้รหัสการตรวจสอบความถูกต้องเท่าที่ช่วยคุณหลีกเลี่ยงการลืมมัน

ฉันคิดว่าฉันตีความคำพูดของเพื่อนร่วมงานของคุณแตกต่างจากคำตอบที่เหลือ

ดูเหมือนว่าฉันจะโต้แย้งว่า:

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

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

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

โปรดทราบว่าหากคุณบันทึกและทดสอบการทำงานของฟังก์ชันของคุณเมื่อมีการส่งผ่านค่า <= 0 ค่าลบจะไม่ถูกต้องอีกต่อไป (อย่างน้อยก็ไม่ถูกต้องมากกว่าอาร์กิวเมนต์ใด ๆ เลยthrowตั้งแต่นั้นเป็นต้นมา มีการบันทึกไว้เพื่อยกเว้นข้อผิดพลาด!) ผู้โทรมีสิทธิ์พึ่งพาพฤติกรรมการป้องกัน ภาษาเอื้ออำนวยก็อาจจะเป็นได้ว่านี่คือในกรณีใด ๆ สถานการณ์ที่ดีที่สุด - ฟังก์ชั่นมีไม่ "ปัจจัยการผลิตที่ไม่ถูกต้อง" แต่สายที่ไม่ได้คาดหวังที่จะกระตุ้นการทำงานลงในการขว้างปายกเว้นควรจะเป็นหน่วยงานที่ผ่านการทดสอบอย่างเพียงพอเพื่อให้แน่ใจว่าพวกเขาสวม' ไม่ส่งผ่านค่าใด ๆ ที่ทำให้เกิด

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

ส่วนต่อประสานสาธารณะสามารถและจะถูกนำไปใช้ในทางที่ผิด

การอ้างสิทธิ์ผู้ร่วมงานของคุณ "การทดสอบหน่วยควรตรวจจับการใช้งานในชั้นเรียนที่ไม่ถูกต้อง" เป็นเท็จอย่างยิ่งสำหรับอินเทอร์เฟซที่ไม่เป็นส่วนตัว หากฟังก์ชั่นสาธารณะสามารถเรียกว่ามีข้อโต้แย้งจำนวนเต็มมันสามารถและจะถูกเรียกด้วยข้อโต้แย้งจำนวนเต็มใด ๆและรหัสควรทำงานอย่างเหมาะสม หากลายเซ็นฟังก์ชั่นสาธารณะยอมรับเช่นประเภท Java Double แล้ว null, NaN, MAX_VALUE, -Inf เป็นค่าที่เป็นไปได้ทั้งหมด การทดสอบหน่วยของคุณไม่สามารถใช้งานคลาสได้อย่างไม่ถูกต้องเนื่องจากการทดสอบเหล่านั้นไม่สามารถทดสอบรหัสที่จะใช้คลาสนี้ได้เนื่องจากรหัสนั้นยังไม่ได้เขียนคุณอาจไม่ได้เขียนและจะอยู่นอกขอบเขตการทดสอบหน่วยของคุณ .

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

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

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

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

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

มีการตรวจสอบรายการในฟังก์ชั่นระดับบนสุดบางส่วนเพื่อป้องกันโค้ดภายในที่อ่อนแอหรือผ่านการทดสอบอย่างไม่ดีจากการรวมพารามิเตอร์ที่ไม่คาดคิด (เช่นถ้ารหัสนั้นผ่านการทดสอบอย่างดีการตรวจสอบนั้นไม่จำเป็นต้องใช้ สภาพอากาศ "พารามิเตอร์ที่ไม่ดี)

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

หากสัญญาของ บริษัท นั้นถูกละเมิดมันจะแปลฟังก์ชั่นการใช้งานในระดับที่ต่ำกว่าในทางที่ผิดบางทีอาจเป็นการโยนข้อยกเว้นหรืออะไรก็ตาม

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

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

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

การทดสอบกำหนดสัญญาของชั้นเรียนของคุณ

ในฐานะที่เป็นข้อพิสูจน์ที่ขาดของการทดสอบกำหนดสัญญาที่มีลักษณะการทำงานที่ไม่ได้กำหนด ดังนั้นเมื่อคุณผ่านnullไปFoo::Frobnicate(Widget widget)และความเสียหายที่เกิดขึ้นในเวลาไม่ได้บอกเล่าคุณยังอยู่ในสัญญาของชั้นเรียนของคุณ

หลังจากนั้นคุณตัดสินใจว่า "เราไม่ต้องการความเป็นไปได้ของพฤติกรรมที่ไม่ได้กำหนด" ซึ่งเป็นตัวเลือกที่สมเหตุสมผล นั่นหมายความว่าคุณต้องมีพฤติกรรมที่คาดหวังสำหรับการส่งผ่านไปยังnullFoo::Frobnicate(Widget widget)

และคุณบันทึกเอกสารการตัดสินใจโดยรวม

[Test]
void Foo_FrobnicatesANullWidget_ThrowsInvalidArgument() 
{
    Given(Foo foo);
    When(foo.Frobnicate(null));
    Then(Expect_Exception(InvalidArgument));
}

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

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

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

การทดสอบของ TDD จะจับความผิดพลาดในระหว่างการพัฒนาของรหัส

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

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

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

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

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

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

ในฐานะวิศวกรที่ฝังตัวฉันชอบที่จะใช้ตัวอย่างของการเขียนฟังก์ชั่นเพื่อเพิ่มสองไบต์ด้วยกันและส่งคืนผลลัพธ์ดังนี้:

uint8_t AddTwoBytes(uint8_t a, uint8_t b, uint8_t *sum); 

ตอนนี้ถ้าคุณเพียงแค่ทำ*(sum) = a + bมันจะได้ผล แต่มีเพียงบางอินพุตเท่านั้น a = 1และb = 2จะทำให้sum = 3; อย่างไรก็ตามเนื่องจากขนาดของผลรวมเป็นไบต์a = 100และb = 200จะทำsum = 44เนื่องจากล้น ใน C คุณจะส่งคืนข้อผิดพลาดในกรณีนี้เพื่อแสดงว่าฟังก์ชันล้มเหลว การโยนข้อยกเว้นเป็นสิ่งเดียวกันในรหัสของคุณ การไม่พิจารณาความล้มเหลวหรือการทดสอบวิธีจัดการกับมันจะไม่ทำงานในระยะยาวเพราะหากเงื่อนไขเหล่านั้นเกิดขึ้นพวกเขาจะไม่ได้รับการจัดการและอาจทำให้เกิดปัญหาจำนวนเท่าใดก็ได้