การทดสอบหน่วยคุ้มค่ากับความพยายามหรือไม่ [ปิด]


572

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


25
คุณจะถามสิ่งนั้นได้อย่างไร .. การทดสอบยูนิตมันช่างสุดยอดมาก :) อย่างจริงจัง ... ความคิดทั่วไปนั้นเหมือนกัน ... ทำการทดสอบหน่วยหากคุณรู้สึกว่าผลประโยชน์มีค่าเกินกว่าค่าใช้จ่าย ... หากคุณมีเหตุผลที่เชื่ออย่างอื่น .. หาสิ่งอื่นที่ช่วยได้
Gishu

14
(การยืนยันปกติพร้อม debug \ release build + อินเตอร์เฟสที่สะอาดไปยังคลาส + ตัวทดสอบจำลองเฉพาะ)> การทดสอบหน่วย
Viktor Sehr

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

7
@ViktorSehr: การทดสอบหน่วยไม่ได้ขัดกับอินเตอร์เฟสที่สะอาดแล้วอันที่จริงมันเป็นสิ่งที่ตรงกันข้ามเมื่อใช้ TDD ไม่ว่าจะเป็นหรือที่นั่งคนขับ + พวงมาลัย> โรงรถ
Jonas Byström

5
การทดสอบหน่วยเป็นเรื่องเสียเวลาอย่างมากที่ไม่ค่อยได้พบข้อบกพร่อง แต่กินไป 30% ของเวลาและงบประมาณในการแก้ไขข้อผิดพลาดและการพัฒนา
โดมินิค

คำตอบ:


722

ทุกวันในสำนักงานของเรามีการแลกเปลี่ยนซึ่งจะเป็นเช่นนี้

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

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

แต่ไม่สนใจว่านี่คือความพยายามของฉัน!

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

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

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

  4. TDD ช่วยด้วยการเข้ารหัสอาการท้องผูก เมื่อต้องเผชิญกับงานชิ้นใหญ่และน่ากลัวล่วงหน้าการทดสอบจะช่วยให้คุณเคลื่อนไหวได้อย่างรวดเร็ว

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

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

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

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

  9. การทดสอบหน่วยที่ดีสามารถช่วยจัดทำเอกสารและกำหนดสิ่งที่ควรทำ

  10. การทดสอบหน่วยช่วยในการใช้รหัสซ้ำ โยกย้ายทั้งรหัสและการทดสอบของคุณไปยังโครงการใหม่ของคุณ ปรับแต่งรหัสจนกว่าการทดสอบจะทำงานอีกครั้ง

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


คุณนำเสนอลิงค์. xul หรือไม่?
2427

3
คำถามคือเกี่ยวกับการทดสอบหน่วย TDD นั้นแตกต่างจากการทดสอบหน่วย
ZunTzu

421

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

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

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

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

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


15
เรื่องเล็ก ๆ น้อย ๆ ที่น่ากลัว!
Sander Versluys

68
ความคิดของคุณน่าสนใจสำหรับฉันและฉันต้องการสมัครรับจดหมายข่าวของคุณ
Christopher Parker

165
อึฉันผ่านการทดสอบแล้ว แต่ตอนนี้คุณทำให้ฉันรู้สึกว่าฉันต้องไปโรงยิม
วินซ์

16
ฉันไม่ชอบ ฉันล้มเหลวในฐานะที่เกินบรรยายและในฐานะมนุษย์
Greg

13
+1: ผู้จัดการจำนวนมากจะร้องเพลงสรรเสริญการทดสอบหน่วย แต่นั่นไม่ได้หมายความว่าพวกเขาจะติดมันเมื่อมันสำคัญ ... คุณอาจต้องหางานใหม่เพื่อให้การทดสอบหน่วยทำงานจริงสำหรับคุณ - คะแนนที่ดี จริงแท้แน่นอน.
Jim G.

136

วิธีที่ดีที่สุดในการโน้มน้าวใจ ... ค้นหาข้อบกพร่องเขียนหน่วยทดสอบเพื่อแก้ไขข้อบกพร่อง

ข้อผิดพลาดนั้นไม่น่าจะปรากฏขึ้นอีกครั้งและคุณสามารถพิสูจน์ได้ด้วยการทดสอบของคุณ

หากคุณทำสิ่งนี้ได้มากพอคนอื่น ๆ จะรีบไปหาคุณ


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

7
@Rei - รายงานข้อผิดพลาดที่พิสูจน์ได้นั้นยอดเยี่ยม แต่คุณจะทำซ้ำข้อผิดพลาดครั้งเดียวเท่านั้น 2 ปีต่อมาการทดสอบหน่วยของคุณจะยังคงตรวจสอบรหัสนานหลังจากรายงานข้อผิดพลาดถูกปิดและลืม
Orion Edwards

4
มันช่วยแก้ไขข้อผิดพลาดการแก้ไข 1 ... ทดสอบ ... ดี ผู้ใช้พบข้อผิดพลาด 2 ... แก้ไข ... ทดสอบ ... ดี ผู้ใช้พบข้อผิดพลาด 1 อีกครั้ง นวดแล้วล้างซ้ำ สิ่งนี้เกิดขึ้นเนื่องจากการแก้ไขข้อบกพร่องหนึ่งรายการของคุณทำให้เกิดข้อผิดพลาดอื่นและกลับกัน
CaffGeek

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

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

69

thetalkingwalnut ถามว่า:

อะไรคือวิธีที่ดีในการโน้มน้าวผู้พัฒนาที่สงสัยในทีมของการทดสอบหน่วย?

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

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

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

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

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

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

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

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

อย่างไรก็ตามเราจำเป็นต้องเข้าใจผลกระทบของ "การทดสอบหน่วยเพิ่มเติม" ผู้พัฒนาสามารถเขียนโค้ดได้เพียงบรรทัดเดียว ~ N บรรทัดต่อสัปดาห์และคุณจำเป็นต้องทราบว่าเปอร์เซ็นต์ของรหัสนั้นควรเป็นหน่วยทดสอบโค้ดเทียบกับรหัสการผลิต สถานที่ทำงานหละหลวมอาจมีรหัส 10% ของการทดสอบหน่วยและ 90% ของรหัสเป็นรหัสการผลิตทำให้เกิดผลิตภัณฑ์ที่มีคุณสมบัติมากมาย (แม้ว่าจะเป็นรถบั๊กกี้) (คิดว่า MS Word) ในทางกลับกันร้านค้าที่เข้มงวดที่มีการทดสอบยูนิต 90% และรหัสการผลิต 10% จะมีผลิตภัณฑ์ที่แข็งแกร่งซึ่งมีคุณสมบัติน้อยมาก (คิดว่า "vi") คุณอาจไม่เคยได้ยินรายงานเกี่ยวกับการขัดข้องของผลิตภัณฑ์หลัง แต่ที่น่าจะเกี่ยวข้องกับผลิตภัณฑ์ที่ไม่ได้ขายดีเท่าที่เกี่ยวข้องกับคุณภาพของรหัส

ยิ่งไปกว่านั้นบางทีความมั่นใจเพียงอย่างเดียวในการพัฒนาซอฟต์แวร์ก็คือ "การเปลี่ยนแปลงหลีกเลี่ยงไม่ได้" สมมติว่าร้านค้าที่เข้มงวด (90% การทดสอบหน่วย / รหัสการผลิต 10%) สร้างผลิตภัณฑ์ที่มีคุณสมบัติ 2 ประการ (สมมติว่า 5% ของรหัสการผลิต == 1 คุณสมบัติ) หากลูกค้าเข้ามาและเปลี่ยน 1 ของคุณสมบัติการเปลี่ยนแปลงนั้นจะทำให้รหัส 50% ของรหัสหายไป (45% ของการทดสอบหน่วยและ 5% ของรหัสการผลิต) ร้านค้าหละหลวม (ทดสอบ 10% หน่วย / รหัสการผลิต 90%) มีผลิตภัณฑ์ที่มีคุณสมบัติ 18 อย่างซึ่งไม่ได้ผลดีมาก ลูกค้าของพวกเขาปรับปรุงข้อกำหนดสำหรับฟีเจอร์ 4 อย่างสมบูรณ์ แม้ว่าการเปลี่ยนแปลงจะมีขนาดใหญ่ขึ้น 4 เท่า แต่เพียงครึ่งเดียวของฐานรหัสจำนวนมากจะถูกทิ้งในถังขยะ (~ 25% = ~ 4.4% การทดสอบหน่วย + 20% ของรหัสการผลิต)

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


47
หาก Vi มีคุณสมบัติน้อยมากแสดงว่าคุณไม่ได้ใช้งาน ;)
Stefan Mai

1
+20 สำหรับสเตฟานถ้าทำได้ :)
Rob Grant

1
Testivus เกี่ยวกับการครอบคลุมการทดสอบ - googletesting.blogspot.com/2010/07/…
Bert F

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

เขียนกรณีทดสอบสำหรับการป้องกันรหัสง่าย ๆ ทำหน้าที่เป็นกลไกการถดถอย - ลบเพียงอย่างเดียวที่ฉันได้เห็นคือการเพิ่มกรอบสแต็คเพิ่มเติม ...
BGS

38

ฉันเล่นด้วยการทดสอบหน่วยหลายครั้งและฉันก็ยังเชื่อมั่นว่ามันคุ้มค่ากับความพยายามในสถานการณ์ของฉัน

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

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

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


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

4
การทดสอบนั้นเกี่ยวกับความสุข ฉันมีแพ็คเกจ 3900 บรรทัด (PL / SQL) ที่จัดการการผ่านรายการอัตโนมัติไปยังระบบบัญชีแยกประเภททั่วไป ตอนนี้ฉันเกลียดการจัดการกับนักบัญชีโดยส่วนตัวแล้วพวกเขามักจะชอบเรื่องเล็ก ๆ น้อย ๆ เช่นเศษเงินและสิ่งของ Buncha anal-retentive คณิตศาสตร์ geeks ... ฉันไม่รู้ แพ็คเกจทดสอบหน่วยของฉันสำหรับแพ็คเกจการบัญชีมีประมาณ 22,000 บรรทัดและทำงานต่ำกว่า 18000 การทดสอบ สิ่งนี้ทำให้หัวหน้า Honcho ในการบัญชีมีความสุขและตราบใดที่ใบพัดบนหมวกนับจำนวนน้อยของเขาหมุนอย่างมีความสุขฉันมีความสุข ... :-)
Bob Jarvis - Reinstate Monica

31

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


26

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

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

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


25

คุณควรทดสอบให้น้อยที่สุด!

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

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


23

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


21

[ฉันมีจุดที่จะทำให้ฉันไม่สามารถเห็นด้านบน]

"ทุกคนทดสอบหน่วยพวกเขาไม่จำเป็นต้องตระหนักถึงมัน - ความจริง"

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

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

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

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


16

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

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

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

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

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


12

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


11

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

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

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


10

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

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

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

คำแนะนำสุดท้ายอย่างสุดท้ายคือไม่เพียง แต่หน่วยทดสอบโค้ดของคุณ แต่เริ่มทำการทดสอบก่อน (ดูTDDและBDDเพิ่มเติม)


8

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


7

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

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

เตรียมความพร้อมล่วงหน้าความพยายามเพิ่มขึ้นเล็กน้อยและใช้เวลา 10 เท่าในภายหลังเมื่อคุณต้องเริ่มเล่นรอบนอกด้วยคุณสมบัติหลัก / ฟังก์ชันการทำงาน

ฉันซื้อหนังสือเล่มนี้ - มันเป็นพระคัมภีร์ของความรู้การทดสอบ xUnit - อาจเป็นหนึ่งในหนังสืออ้างอิงมากที่สุดบนชั้นวางของฉันและฉันอ่านทุกวัน: ลิงค์ข้อความ


+1: แต่ผู้ชายโอ้มนุษย์โอ้มนุษย์ไม่มีอะไรและฉันหมายความว่าไม่มีอะไรให้อำนาจนักพัฒนาเพื่อทำการเปลี่ยนแปลงได้อย่างมั่นใจมากขึ้นกว่าชุดการทดสอบที่หลากหลาย - จริง ฉันหวังว่าฉันจะคิดออกเร็วกว่านี้
Jim G.

7

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

การสละเวลาเล็กน้อยในการเขียนการทดสอบหน่วยสามารถประหยัดเวลาในการดีบักในอนาคต


+1: การสละเวลาเล็กน้อยในการเขียนการทดสอบหน่วยสามารถประหยัดเวลาในการดีบักในอนาคต - ได้!
จิมจี

7

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

ฉันคิดว่าการทดสอบหน่วยพิสูจน์ได้ว่ามีประโยชน์มากเมื่อเขียน api หรือกรอบที่ต้องใช้เป็นเวลาหลายปีและใช้ / แก้ไข / พัฒนาโดยผู้อื่นที่ไม่ใช่ coders ดั้งเดิม


คุณเพิ่มการทดสอบหน่วยสำหรับรหัสใหม่หรือการแก้ไขที่คุณทำหรือไม่
o

6

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

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

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


6

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


6

ฉันไม่รู้. หลายแห่งไม่ทำการทดสอบหน่วย แต่คุณภาพของรหัสนั้นดี Microsoft ทำการทดสอบหน่วย แต่ Bill Gates ให้หน้าจอสีน้ำเงินในงานนำเสนอของเขา


โปรดทราบว่าเกือบ 15 ปีที่แล้วเมื่อการทดสอบหน่วยไม่เป็นที่นิยมเหมือนในทุกวันนี้
fwielstra

1
และ Internet Explorer ยังไม่สามารถบันทึกเว็บเพจได้จำนวนมาก
Cees Timmerman

5

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

แทนที่จะพูดถึงการทดสอบหน่วยจากมุมมองการตรวจสอบ "test-after" เราควรดูมูลค่าจริงที่พบเมื่อคุณกำหนดให้เขียนข้อมูลจำเพาะ / การทดสอบ / แนวคิดก่อนการนำไปใช้

แนวคิดเรียบง่ายนี้ได้เปลี่ยนวิธีการเขียนซอฟต์แวร์และฉันจะไม่กลับไปใช้วิธี "เก่า"

การทดสอบการพัฒนาครั้งแรกเปลี่ยนชีวิตฉันได้อย่างไร


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

haha เห็นด้วย :) </ reddit หน้าแรกดูเหมือนว่า>
Toran Billups

3

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

หนึ่งในเทคนิคที่ฉันโปรดปรานในการสำรวจเฟรมเวิร์กหรือโค้ดใหม่คือการเขียนบททดสอบสำหรับ 'มัน' เพื่อค้นหาว่าสิ่งต่าง ๆ ทำงานอย่างไร มันเป็นวิธีที่ยอดเยี่ยมในการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งใหม่ ๆ แทนที่จะอ่าน doc แห้ง :)


3

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

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

และตัวใหญ่ ...

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

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

3

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

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

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


3

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

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

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


2

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


2

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


2

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


2

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

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