คำถามติดแท็ก unit-testing

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

410 unit-testing  tdd  builds 

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

397 unit-testing 

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

211 unit-testing  testing 

ฉันกำลังทำงานกับโปรเจ็กต์ java ฉันยังใหม่กับการทดสอบหน่วย เป็นวิธีที่ดีที่สุดในการทดสอบหน่วยวิธีส่วนตัวในชั้นเรียน java อะไร

184 java  unit-testing 

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

139 unit-testing  tdd 

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

138 unit-testing  tdd 

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

132 unit-testing  productivity  solo-development 

ในโครงการปัจจุบันของฉัน (เกมใน C ++) ฉันตัดสินใจว่าฉันจะใช้ Test Driven Development 100% ในระหว่างการพัฒนา ในแง่ของคุณภาพของรหัสนี่ยอดเยี่ยมมาก รหัสของฉันไม่เคยได้รับการออกแบบมาอย่างดีหรือปราศจากข้อผิดพลาด ฉันไม่ได้ประจบประแจงเมื่อดูรหัสที่ฉันเขียนเมื่อปีที่แล้วที่จุดเริ่มต้นของโครงการและฉันได้รับความรู้สึกที่ดีขึ้นมากเกี่ยวกับวิธีการจัดโครงสร้างสิ่งต่าง ๆ ไม่เพียง แต่จะทดสอบได้ง่ายขึ้นเท่านั้น . อย่างไรก็ตาม ... เป็นเวลาหนึ่งปีแล้วที่ฉันเริ่มโครงการ จริงอยู่ที่ฉันสามารถทำงานได้ในเวลาว่าง แต่ TDD ยังคงทำให้ฉันช้าลงอย่างมากเมื่อเทียบกับสิ่งที่ฉันเคยทำ ฉันอ่านว่าความเร็วในการพัฒนาช้าลงจะดีขึ้นเมื่อเวลาผ่านไปและฉันคิดว่าจะทำการทดสอบได้ง่ายกว่าที่ฉันเคยทำ แต่ฉันอยู่ที่นี่มาหนึ่งปีแล้วและฉันก็ยังทำงานด้วยความเร็วของหอยทาก ทุกครั้งที่ฉันคิดถึงขั้นตอนต่อไปที่ต้องทำงานฉันต้องหยุดทุกครั้งและคิดว่าฉันจะเขียนแบบทดสอบอย่างไรเพื่อให้ฉันสามารถเขียนรหัสจริงได้ บางครั้งฉันจะติดอยู่หลายชั่วโมงรู้ว่าฉันต้องการเขียนโค้ดอะไร แต่ไม่รู้ว่าจะพังมันให้ละเอียดพอที่จะครอบคลุมการทดสอบได้อย่างไร บางครั้งฉันจะคิดอย่างรวดเร็วถึงการทดสอบโหลและใช้เวลาหนึ่งชั่วโมงในการเขียนการทดสอบเพื่อครอบคลุมโค้ดจริง ๆ ชิ้นเล็ก ๆ ที่อาจใช้เวลาสองสามนาทีเพื่อเขียน หรือหลังจากเสร็จสิ้นการทดสอบครั้งที่ 50 เพื่อให้ครอบคลุมเอนทิตีเฉพาะในเกมและทุกแง่มุมของการสร้างและการใช้งานฉันมองไปที่รายการสิ่งที่ต้องทำและดูเอนทิตีถัดไปเพื่อเขียนโค้ดและประจบประแจงด้วยความกลัวเมื่อนึกถึงการเขียน อีก 50 แบบทดสอบที่คล้ายกันเพื่อนำไปใช้งาน มันถึงจุดที่เมื่อมองถึงความคืบหน้าของปีที่แล้วฉันกำลังพิจารณาที่จะละทิ้ง TDD เพราะเห็นว่า "การทำให้โครงการเสร็จสิ้นลง" อย่างไรก็ตามการยอมแพ้คุณภาพของรหัสที่มาพร้อมกับมันไม่ใช่สิ่งที่ฉันรอคอย ฉันกลัวว่าถ้าฉันหยุดเขียนการทดสอบฉันก็จะออกจากนิสัยในการทำให้โค้ดเป็นโมดูลและทดสอบได้ ฉันอาจจะทำสิ่งผิดปกติเพื่อยังช้าอยู่หรือ? มีทางเลือกอื่น ๆ ที่เร่งความเร็วในการผลิตโดยไม่สูญเสียผลประโยชน์ทั้งหมดหรือไม่? …

131 unit-testing  tdd 

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

127 testing  unit-testing  random 

ฉันทำงานกับโปรแกรมตัวเลข / คณิตศาสตร์บ่อยครั้งมากซึ่งผลลัพธ์ที่แน่นอนของฟังก์ชั่นนั้นยากที่จะทำนายล่วงหน้า ในการพยายามใช้ TDD กับรหัสประเภทนี้ฉันมักจะพบว่าการเขียนรหัสภายใต้การทดสอบง่ายกว่าการเขียนการทดสอบหน่วยสำหรับรหัสนั้นอย่างมีนัยสำคัญเพราะวิธีเดียวที่ฉันรู้ในการค้นหาผลลัพธ์ที่คาดหวังคือการใช้อัลกอริทึมเอง หัวกระดาษหรือโดยคอมพิวเตอร์) สิ่งนี้รู้สึกผิดเพราะฉันใช้รหัสภายใต้การทดสอบเพื่อตรวจสอบการทดสอบหน่วยของฉันอย่างมีประสิทธิภาพแทนที่จะเป็นวิธีอื่น มีเทคนิคที่รู้จักกันสำหรับการเขียนการทดสอบหน่วยและการใช้ TDD เมื่อผลลัพธ์ของรหัสภายใต้การทดสอบนั้นยากที่จะทำนายหรือไม่? ตัวอย่างโค้ด (จริง) ที่ยากต่อการคาดการณ์ผลลัพธ์: ฟังก์ชั่นweightedTasksOnTimeที่ได้รับจำนวนเงินของงานที่ทำต่อวันworkPerDayในช่วง (0, 24], เวลาปัจจุบันinitialTime> 0 และรายชื่อของงานtaskArrayแต่ละที่มีเวลาที่จะเสร็จสมบูรณ์คุณสมบัติtime> 0 วันที่ครบกำหนดdueและความคุ้มค่าความสำคัญimportance; ผลตอบแทน ค่าปกติอยู่ในช่วง [0, 1] เป็นตัวแทนของความสำคัญของงานที่สามารถจะแล้วเสร็จก่อนของพวกเขาdueวันถ้าแต่ละงานถ้าเสร็จสมบูรณ์ในการสั่งซื้อที่กำหนดโดยเริ่มต้นที่taskArrayinitialTime ขั้นตอนวิธีการที่จะใช้ฟังก์ชั่นนี้ค่อนข้างตรงไปตรงมา: taskArrayย้ำกว่างานใน สำหรับแต่ละงานเพิ่มเพื่อtime initialTimeหากเวลาใหม่ < dueเพิ่มimportanceไปยังแอคคูมูเลเตอร์ ปรับเวลาด้วย inverse workPerDay ก่อนที่จะส่งคืนตัวสะสมหารด้วยผลรวมของความสำคัญของงานเพื่อทำให้ปกติ function weightedTasksOnTime(workPerDay, initialTime, taskArray) { let simulatedTime = initialTime let accumulator = 0; …

124 unit-testing  tdd 

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

122 unit-testing  testing  test-coverage 

บางคนยืนยันว่าการทดสอบการรวมเป็นสิ่งเลวและผิดทุกอย่างต้องผ่านการทดสอบหน่วยซึ่งหมายความว่าคุณต้องจำลองการอ้างอิง ตัวเลือกที่ด้วยเหตุผลต่าง ๆ ฉันไม่ชอบเสมอ ฉันพบว่าในบางกรณีการทดสอบหน่วยก็ไม่ได้พิสูจน์อะไรเลย ลองมาปรับใช้การใช้พื้นที่เก็บข้อมูล (เล็กน้อย, ไร้เดียงสา) ต่อไปนี้ (ใน PHP) เป็นตัวอย่าง: class ProductRepository { private $db; public function __construct(ConnectionInterface $db) { $this->db = $db; } public function findByKeyword($keyword) { // this might have a query builder, keyword processing, etc. - this is // a totally naive example just to …

120 unit-testing  testing  integration-tests  repository-pattern 

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

103 design  unit-testing  testing  tdd 

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

103 testing  unit-testing  dependency-injection  mocking 

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

98 unit-testing  testing  continuous-integration  integration-tests