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


139

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

อัตราส่วนนี้จะไม่สามารถจัดการได้เมื่อเราเพิ่มการครอบคลุมโค้ดของเราหรือไม่?

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

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

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


145
มันขึ้นอยู่กับ. คุณกำลังเขียนเกมของโอเอกซ์หรือคุณกำลังเขียนรหัสเพื่อจัดการเครื่องปฏิกรณ์นิวเคลียร์หรือไม่?
ไบรอัน Oakley

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

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

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

12
เอกสารการทดสอบ SQLite คือความสนุกอ่าน: sqlite.org/testing.html อ้างอิง: "ไลบรารี SQLite ประกอบด้วยประมาณ 122.9 KSLOC ของรหัส C โดยการเปรียบเทียบโครงการมี 745 เท่าของรหัสทดสอบและสคริปต์ทดสอบ - 91596.1 KSLOC"
user60561

คำตอบ:


180

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

การบำรุงรักษาการทดสอบจำนวนมากมักไม่เป็นปัญหา หลายทีมมีการรวมระบบอัตโนมัติและการทดสอบระบบที่ครอบคลุมการทดสอบหน่วย 100%

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


11
ขอบคุณสำหรับคำตอบ. มันช่วยวางคำถามของฉันในมุมมองและแก้ไขปัญหาจริง - ทัศนคติของฉัน! +1
2954463

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

18
การทดสอบที่ไม่เคยล้มเหลวในรอบ 10 ปีนั้นไม่ได้รับประกันว่าจะไม่จำเป็น แต่ก็อาจล้มเหลวในปีที่ 11
Pharap

24
ในทางปฏิบัติคุณสามารถใช้แนวทางตรงกันข้าม เขียนแบบทดสอบที่คุณคิดว่าครอบคลุมกรณีทั่วไป แต่ทุกครั้งที่คุณพบความล้มเหลวเขียนการทดสอบเพื่อให้ครอบคลุมพื้นที่นั้น
stannius

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

66

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

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


16
ควรได้รับการยกระดับขึ้นเพื่อชี้ให้เห็นถึงเงื่อนไขล่วงหน้าเงื่อนไขภายหลังและค่าคงที่ที่ควรได้รับการปฏิบัติเป็นหน่วยทดสอบ วิธีการใช้งานทุกครั้งนั้นเป็นการทดสอบหน่วยเมื่อรหัสการดีบักนั้นทำงาน
Persixty

นี่คือคำตอบที่ดีและสอดคล้องอย่างสมบูรณ์กับประสบการณ์ของฉัน
Tony Ennis

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

3
นี่เป็นคำตอบที่ดีกว่าคำตอบที่ยอมรับ! "ในบางกรณีความพยายามในการพัฒนาส่วนใหญ่ประกอบด้วยการอัปเดตการทดสอบคุณภาพต่ำ" - ฉันเคยมีประสบการณ์นี้มาแล้วและมันก็แย่มาก มากกว่าไม่มีการทดสอบเลยในบางประเด็น
Benjamin Hodgson

36

ตอบคำถามของคุณ

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

แน่นอนว่า ... ตัวอย่างเช่นคุณอาจมีการทดสอบหลายแบบซึ่งดูเหมือนจะแตกต่างกันตั้งแต่แรกเห็น แต่ทดสอบในสิ่งเดียวกันจริง ๆ (ขึ้นอยู่กับตรรกะในบรรทัดเดียวกันของรหัสแอปพลิเคชัน "น่าสนใจ" ภายใต้การทดสอบ)

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

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

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

อัตราส่วนนี้จะไม่สามารถจัดการได้เมื่อเราเพิ่มการครอบคลุมโค้ดของเราหรือไม่?

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

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

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

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

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

เขาแนะนำการทดสอบ 4-5 กรณีการใช้งานที่มักใช้กับชั้นเรียนที่มีปัญหามากกว่าการทดสอบแต่ละฟังก์ชั่นอย่างละเอียดถี่ถ้วน

แน่นอนว่าเพียงแค่มุ่งเน้นไปที่ 80% ของรหัสสำคัญที่สำคัญช่วยลดการโหลดเช่นกัน ... ฉันขอขอบคุณที่คุณคิดว่าเจ้านายของคุณเป็นอย่างสูง แต่นี่ไม่ได้เป็นตัวเลือกที่ดีที่สุด

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

ฉันไม่ทราบว่า "การทดสอบหน่วยครอบคลุม" คืออะไร ฉันถือว่าคุณหมายถึง "การครอบคลุมโค้ด" นั่นคือหลังจากรันชุดทดสอบแล้วโค้ดทุกบรรทัด (= 100%) ได้รับการดำเนินการอย่างน้อยหนึ่งครั้ง

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

การทดสอบบูรณาการ

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

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

สิ่งเหล่านี้ไปพร้อมกับการพัฒนาพฤติกรรมขับเคลื่อนหรือการพัฒนาคุณลักษณะขับเคลื่อน สิ่งเหล่านั้นไม่ทำงานกับการทดสอบหน่วย (เข้มงวด) ตามคำจำกัดความ

เพื่อให้สั้น (ish) การทดสอบบูรณาการ / คุณสมบัติการออกกำลังกายทั้งกองใบสมัคร ในแอปพลิเคชันบนเว็บมันจะทำหน้าที่เหมือนเบราว์เซอร์ที่คลิกผ่านแอปพลิเคชัน (และไม่แน่นอนว่าไม่จำเป็นต้องเป็นแบบง่ายๆมีกรอบที่ทรงพลังมากในการทำเช่นนั้น - ลองดูhttp: // แตงกวา ioเป็นตัวอย่าง)

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

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

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


1
การทดสอบการผสานรวมนั้นยอดเยี่ยม แต่ไม่สามารถทดแทนการทดสอบหน่วยได้ มีปัญหาหลายอย่างกับพวกเขา: ก) พวกเขาใช้คำนิยามใช้เวลานานในการรัน (มันหมายถึงการทดสอบที่เพิ่มขึ้นนั้นไร้ประโยชน์มาก), b) พวกเขาทำให้ยากที่จะระบุปัญหาจริง ๆ อย่างไม่น่าเชื่อ สิ่งที่ทำให้เกิดการเปลี่ยนแปลงนั้น?) และ c) พวกเขาครอบคลุมเส้นทางรหัสเดียวกันซ้ำ ๆ
Voo

1
a) เป็นปัญหาเพราะมันทำการทดสอบบน gated check-ins ที่ยุ่งยากและทำให้มีโอกาสน้อยกว่าที่โปรแกรมเมอร์จะทำการทดสอบซ้ำ ๆ ในขณะที่กำลังพัฒนาซึ่งควบคู่ไปกับ b) ลดประสิทธิภาพและความสามารถในการวินิจฉัยข้อบกพร่องได้อย่างรวดเร็ว c) หมายความว่าการเปลี่ยนแปลงสิ่งเล็กน้อยสามารถทำให้การทดสอบการรวมระบบของคุณล้มเหลวได้หลายสิบหรือหลายร้อย (ซึ่งอยู่ที่นั่น) ซึ่งหมายความว่าคุณจะใช้เวลาในการแก้ไขนาน ๆ นอกจากนี้ยังหมายความว่าการทดสอบการรวมส่วนใหญ่ทดสอบเส้นทางที่มีความสุขเท่านั้นเนื่องจากการเขียนการทดสอบเหล่านี้มีเป้าหมายที่ยุ่งยากหรือเป็นไปไม่ได้
Voo

1
@Voo ทุกสิ่งที่คุณเขียนเป็นความจริงและเท่าที่ผมสามารถบอกฉันกล่าวแล้วปัญหาทั้งหมดที่คุณระบุไว้ในคำตอบ ...
AnoE

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

24

ใช่เป็นไปได้ที่จะมีการทดสอบหน่วยมากเกินไป หากคุณมีความครอบคลุม 100% พร้อมการทดสอบหน่วยและไม่มีการทดสอบการรวมตัวอย่างเช่นคุณมีปัญหาชัดเจน

บางสถานการณ์:

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

    ความสมดุลที่ดีระหว่างการทดสอบหน่วยและการทดสอบการรวมช่วยลดปัญหานี้โดยไม่สูญเสียความคุ้มครองที่สำคัญ

  2. คุณสามารถให้ความคุ้มครองที่สมเหตุสมผลสำหรับทุกการกระทำที่มี 20% ของการทดสอบที่คุณมีเหลือ 80% สำหรับการรวมหรืออย่างน้อยแยกผ่านการทดสอบ; ผลกระทบเชิงลบที่สำคัญที่คุณเห็นในสถานการณ์นี้คือการเปลี่ยนแปลงที่ช้าตามที่คุณต้องรอเป็นเวลานานเพื่อให้การทดสอบดำเนินการ

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

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


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

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

ฉันชอบคำอธิบายของคุณ @johncip แน่นอนว่าเป็นตัวอย่างที่บ่อยครั้งของการที่คนดีในห้องเรียนน่ากลัวเพียงใดโดยการเพิ่มพารามิเตอร์ที่จำเป็นที่ไม่จำเป็นให้กับคอนสตรัคเตอร์ ...
บรูโน่ Guardia

19

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

  • การทดสอบจะต้องมีการเขียน;
  • การทดสอบใช้เวลา (โดยทั่วไปจะมีจำนวนน้อยมาก) ในการรัน
  • การทดสอบจะต้องได้รับการบำรุงรักษาด้วยรหัส - การทดสอบจะต้องเปลี่ยนแปลงเมื่อ API ที่ทดสอบกำลังเปลี่ยนแปลง
  • คุณอาจต้องเปลี่ยนการออกแบบเพื่อเขียนการทดสอบ (แม้ว่าการเปลี่ยนแปลงเหล่านี้มักจะดีกว่า)

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

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


12

ใช่มีหลายอย่างเช่นการทดสอบหน่วยมากเกินไป

ในขณะที่การทดสอบนั้นดีทุก ๆ การทดสอบคือ:

  • ภาระการบำรุงรักษาที่อาจเกิดขึ้นซึ่งผนวกเข้ากับ API อย่างแน่นหนา

  • เวลาที่สามารถใช้กับสิ่งอื่น

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

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

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

Pragmatics สำหรับรหัสส่วนใหญ่ระบุ:

  1. ตรวจสอบให้แน่ใจว่าคุณมีจุดเข้าใช้งานที่ครอบคลุม 100% (ทุกสิ่งได้รับการทดสอบอย่างใด) และตั้งเป้าที่จะให้ความคุ้มครองโค้ด 100% ของเส้นทาง 'ไม่ใช่ข้อผิดพลาด'

  2. ทดสอบค่าหรือขนาดต่ำสุด / สูงสุดที่เกี่ยวข้อง

  3. ทดสอบทุกสิ่งที่คุณคิดว่าเป็นกรณีพิเศษที่ตลกโดยเฉพาะค่า "แปลก"

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

สำหรับอัลกอริทึมที่ซับซ้อนยิ่งขึ้นให้พิจารณาด้วย:

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

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

ฉันว่าผู้นำทางเทคโนโลยีของคุณกำลังเสนอการทดสอบ 'ตูดเปลือยขั้นต่ำ' ฉันขอเสนอ 'การทดสอบคุณภาพสูงสุดที่คุ้มค่า' และมีคลื่นความถี่ในระหว่างนั้น

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

บทเรียนสำคัญคือการเพิ่มการทดสอบเมื่อพบข้อบกพร่อง ซึ่งทำให้ฉันบทเรียนที่ดีที่สุดของฉันเกี่ยวกับการพัฒนาการทดสอบหน่วย:

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

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

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

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


4
ฉันจะไม่บอกว่าความคุ้มครอง 100% เป็นประโยชน์ ความคุ้มครอง 100% เป็นมาตรฐานที่สูงมาก
ไบรอัน Oakley

น่าเสียดายที่แม้แต่วิธีการแบบสุ่มก็สามารถพลาดข้อผิดพลาดได้ ไม่มีสิ่งทดแทนสำหรับการพิสูจน์แม้ว่าจะเป็นทางการ
Frank Hileman

@BryanOakley Point ถ่ายแล้ว นั่นเป็นการคุยโว แต่การเข้าใกล้มันสำคัญกว่าการให้เครดิต "ฉันทดสอบเส้นทางง่ายๆมันก็ดี" จะทำให้เกิดปัญหาในภายหลัง
Persixty

@ FrankHileman คำถามไม่ได้ "คือการทดสอบหน่วยที่ดีสำหรับการออกแบบซอฟต์แวร์อย่างรอบคอบตรรกะการตรวจสอบแบบคงที่และขั้นตอนวิธีการพิสูจน์" แล้วคำตอบคือ 'ไม่' ทั้งสองวิธีจะไม่ผลิตซอฟต์แวร์คุณภาพสูงด้วยตนเอง
Persixty

3

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

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

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

การทดสอบที่มีค่าที่สุดต่อไปคือการทดสอบขีด จำกัด หรือจุดขอบเขต ตัวอย่างเช่นฟังก์ชั่นที่ยอมรับ (ใช้ 1 เดือน) ของปีควรทดสอบด้วย 0, 1, 12 และ 13 ดังนั้นคุณจึงรู้ว่าการเปลี่ยนที่ไม่ถูกต้องนั้นอยู่ในตำแหน่งที่ถูกต้อง มันผ่านการทดสอบมากเกินไปที่จะใช้ 2..11 สำหรับการทดสอบเหล่านี้

คุณอยู่ในตำแหน่งที่ยากลำบากในการที่คุณต้องเขียนการทดสอบสำหรับรหัสที่มีอยู่ ง่ายต่อการระบุขอบกรณีที่คุณกำลังเขียน (หรือกำลังจะเขียน) โค้ด


3

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

ความเข้าใจนี้ผิด

การทดสอบหน่วยตรวจสอบพฤติกรรมของหน่วยภายใต้การทดสอบ

ในความหมายนั้นหน่วยไม่จำเป็นต้องเป็น "วิธีการในชั้นเรียน" ฉันชอบความหมายของยูนิตโดย Roy Osherove ในThe Art of Unit Testing :

หน่วยคือรหัสการผลิตทั้งหมดที่มีเหตุผลเดียวกันในการเปลี่ยนแปลง

จากนี้การทดสอบหน่วยควรตรวจสอบทุกพฤติกรรมที่ต้องการของรหัสของคุณ ในกรณีที่ "ปรารถนา" ถูกนำมาจากข้อกำหนดมากหรือน้อย


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

เขาพูดถูก แต่แตกต่างจากที่เขาคิด

จากคำถามของคุณฉันเข้าใจว่าคุณเป็น "ผู้ทดสอบเฉพาะ" ในโครงการนั้น

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

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

เพื่อเน้นการเปรียบเทียบรถดัมพ์อีกครั้ง: มีการทดสอบกับรถยนต์ที่ปลายสายการประกอบจำนวนเท่าไร? ข้อหนึ่ง: มันจะต้องขับรถไปที่ลานจอดรถด้วยตัวเอง ...

จุดนี่คือ:

เราจำเป็นต้องตระหนักถึงความแตกต่างระหว่าง "การทดสอบหน่วย" และ "ทดสอบอัตโนมัติโดยใช้กรอบการทดสอบหน่วย"


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

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

คุณไม่จำเป็นต้องมีรหัสครอบคลุม 100%

แต่คุณต้องการความคุ้มครองพฤติกรรม 100% (ใช่การครอบคลุมโค้ดและการครอบคลุมพฤติกรรมมีความสัมพันธ์กัน แต่อย่างใดไม่เหมือนกันเพื่อประโยชน์ของมัน)

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


ข้อสรุป

มีการทดสอบน้อยกว่าไม่ทดสอบ ไม่ต้องสงสัยเลย!

แต่ไม่มีสิ่งเช่นการทดสอบหน่วยมากเกินไป

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


2

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

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


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

2
นั่นไม่ใช่ปัญหาของการทดสอบ แต่กับองค์กร
jwenting

2
@CodeMonkey การพึ่งพาไม่ได้ทำลาย พวกเขากำลังได้รับการปรับปรุงในรูปแบบที่จำเป็นต้องมีการเปลี่ยนแปลงผลิตภัณฑ์ ใช่การทดสอบนั้นมีค่า แต่ไม่มากพอ ๆ กับการทดสอบอื่น ๆ การทดสอบอัตโนมัติมีค่ามากที่สุดเมื่อการทดสอบแบบแมนนวลนั้นยาก
mrog

2
@jwenting ใช่มันเป็นปัญหาขององค์กรไม่ใช่ปัญหารหัส แต่นั่นไม่ได้เปลี่ยนความจริงที่ว่ามีการทดสอบมากเกินไป การทดสอบที่ล้มเหลวที่ไม่สามารถตรวจสอบได้นั้นไม่มีประโยชน์ไม่ว่าจะเกิดจากสาเหตุใด
mrog

"SDET" คืออะไร
Peter Mortensen

1

การมีรหัสทดสอบหลายบรรทัดมากกว่ารหัสผลิตภัณฑ์นั้นไม่จำเป็นต้องเป็นปัญหาสมมติว่าคุณกำลังปรับรหัสการทดสอบใหม่เพื่อกำจัดการคัดลอก

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

ใบเสนอราคาที่ยอดเยี่ยมในกระดาษ"ทำไมการทดสอบหน่วยส่วนใหญ่เป็นของเสีย"คือการทดสอบหน่วยควรจะมี "ความเป็นวงกว้าง, เป็นทางการ, เป็นอิสระจากความถูกต้องของ Oracle และ ... มูลค่าทางธุรกิจที่สามารถอธิบายได้"


0

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

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

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

ดังนั้นการมีการทดสอบมากมายที่ทำให้พวกเขาทั้งหมดใช้เวลาไม่กี่นาทีหรือมีการทดสอบที่ซับซ้อนมากเกินไปอาจเป็นปัญหาได้

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.