คำถามติดแท็ก tdd

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

410 unit-testing  tdd  builds 

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

147 tdd 

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

139 unit-testing  tdd 

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

138 unit-testing  tdd 

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

131 unit-testing  tdd 

ฉันทำงานกับโปรแกรมตัวเลข / คณิตศาสตร์บ่อยครั้งมากซึ่งผลลัพธ์ที่แน่นอนของฟังก์ชั่นนั้นยากที่จะทำนายล่วงหน้า ในการพยายามใช้ 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 

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

110 testing  agile  tdd 

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

104 tdd  defensive-programming 

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

103 design  unit-testing  testing  tdd 

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

99 object-oriented  testing  tdd 

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

94 tdd 

วันนี้การพัฒนาที่ขับเคลื่อนด้วยการทดสอบ (TDD)มีขนาดใหญ่ ฉันมักจะเห็นว่าแนะนำเป็นวิธีแก้ปัญหาที่หลากหลายในโปรแกรมเมอร์ SE และสถานที่อื่น ๆ ฉันสงสัยว่าทำไมมันถึงได้ผล จากมุมมองทางวิศวกรรมมันทำให้ฉันไขปริศนาด้วยเหตุผลสองประการ: วิธีการ "เขียนการทดสอบ + การปรับปรุงซ้ำจนผ่าน" มีลักษณะต่อต้านวิศวกรรมอย่างไม่น่าเชื่อ หากวิศวกรโยธาใช้วิธีการก่อสร้างสะพานหรือนักออกแบบรถยนต์สำหรับรถยนต์ของพวกเขาพวกเขาจะปรับเปลี่ยนสะพานหรือรถยนต์ในราคาที่สูงมากและผลที่ได้จะเป็นปัญหาที่ปะปนกับสถาปัตยกรรมที่ไม่คิด . แนวทาง "refactor จนถึงผ่าน" มักถูกนำมาใช้เป็นคำสั่งให้ลืมการออกแบบสถาปัตยกรรมและทำสิ่งที่จำเป็นเพื่อให้สอดคล้องกับการทดสอบ; กล่าวอีกนัยหนึ่งการทดสอบแทนผู้ใช้กำหนดข้อกำหนด ในสถานการณ์เช่นนี้เราจะรับประกัน "ความสามารถ" ที่ดีในผลลัพธ์ได้อย่างไรเช่นผลลัพธ์สุดท้ายที่ไม่เพียง แต่ถูกต้อง แต่ยังขยายได้แข็งแกร่งใช้งานง่ายเชื่อถือได้ปลอดภัยปลอดภัย ฯลฯ นี่คือสิ่งที่สถาปัตยกรรมมักจะทำ การทดสอบไม่สามารถรับประกันได้ว่าระบบทำงานได้; มันสามารถแสดงให้เห็นว่ามันไม่ได้ กล่าวอีกนัยหนึ่งการทดสอบอาจแสดงให้คุณเห็นว่าระบบมีข้อบกพร่องหากการทดสอบล้มเหลว แต่ระบบที่ผ่านการทดสอบทั้งหมดนั้นไม่ปลอดภัยกว่าระบบที่ล้มเหลว การครอบคลุมการทดสอบคุณภาพการทดสอบและปัจจัยอื่น ๆ มีความสำคัญที่นี่ ความรู้สึกปลอดภัยที่ผิด ๆ ที่ผลลัพธ์ "สีเขียวทั้งหมด" ก่อให้เกิดกับคนจำนวนมากได้รับการรายงานในอุตสาหกรรมโยธาและการบินและอวกาศว่าเป็นอันตรายอย่างยิ่งเพราะมันอาจถูก interepreted เป็น "ระบบไม่ดี" เมื่อมันหมายถึง "ระบบดี เป็นกลยุทธ์การทดสอบของเรา " บ่อยครั้งที่กลยุทธ์การทดสอบไม่ได้รับการตรวจสอบ หรือใครเป็นคนทดสอบการทดสอบ? โดยสรุปฉันกังวลเกี่ยวกับบิต "ที่ขับเคลื่อน" …

92 testing  tdd 

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

91 tdd  refactoring  encapsulation 

ฉันเคยได้ยินเกี่ยวกับสไตล์ลอนดอนเทียบกับสไตล์ชิคาโก (บางครั้งเรียกว่าสไตล์ดีทรอยต์) ของการทดสอบการพัฒนาขับเคลื่อน (TDD) การประชุมเชิงปฏิบัติการของกลุ่มผู้ใช้ Utah Extreme Programming: สไตล์การโต้ตอบ TDD เรียกอีกอย่างว่าสไตล์ mockistหรือสไตล์ลอนดอนหลังจากคลับ Extreme Tuesday ของกรุงลอนดอนซึ่งเป็นที่นิยม มันมักจะแตกต่างกับดีทรอยต์สไตล์หรือคลาสสิก TDD ซึ่งเป็นรัฐมากขึ้น การประชุมเชิงปฏิบัติการ Jason Gorman : การประชุมเชิงปฏิบัติการครอบคลุมทั้งโรงเรียนชิคาโกของ TDD (รัฐตามการทดสอบพฤติกรรมและรูปสามเหลี่ยม) และโรงเรียนในกรุงลอนดอนซึ่งมุ่งเน้นเพิ่มเติมเกี่ยวกับการทดสอบการทำงานร่วมกันเยาะเย้ยและ TDD แบบ end-to-end โดยเน้นเฉพาะในการออกแบบความรับผิดชอบขับเคลื่อนและบอกว่าอย่าถามวิธีการOOเมื่อเร็ว ๆ นี้ได้รับความนิยมอีกครั้งโดย Steve Freeman's และ Nat Pryce's Software ที่มุ่งเน้นการเติบโตเชิงวัตถุที่แนะนำโดยการทดสอบหนังสือ โพสต์Classic TDD หรือ "London School"? โดย Jason Gorman มีประโยชน์ แต่ตัวอย่างของเขาทำให้ฉันสับสนเพราะเขาใช้สองตัวอย่างที่แตกต่างกันแทนที่จะเป็นตัวอย่างหนึ่งที่มีทั้งสองวิธี ความแตกต่างคืออะไร? …

88 tdd  concepts 

พิจารณาฟังก์ชั่นเช่นนี้: function savePeople(dataStore, people) { people.forEach(person => dataStore.savePerson(person)); } มันอาจจะใช้แบบนี้: myDataStore = new Store('some connection string', 'password'); myPeople = ['Joe', 'Maggie', 'John']; savePeople(myDataStore, myPeople); ให้เราสมมติว่าStoreมีการทดสอบหน่วยของตนเองหรือได้รับการจัดหาจากผู้ขาย ในกรณีใด ๆ Storeเราไว้วางใจ และให้เราต่อไปคิดว่าจัดการข้อผิดพลาด - เช่นข้อผิดพลาดการเชื่อมต่อฐานข้อมูล - savePeopleไม่ได้เป็นความรับผิดชอบของ ที่จริงให้เราสมมติว่าตัวร้านนั้นเป็นฐานข้อมูลเวทมนต์ที่ไม่สามารถผิดพลาดได้ แต่อย่างใด ด้วยสมมติฐานเหล่านี้คำถามคือ: ควรsavePeople()ทดสอบหน่วยหรือจำนวนการทดสอบดังกล่าวเพื่อทดสอบการสร้างforEachภาษาในตัว? แน่นอนเราสามารถผ่านการเยาะเย้ยdataStoreและยืนยันที่dataStore.savePerson()เรียกว่าครั้งเดียวสำหรับแต่ละคน แน่นอนคุณสามารถโต้แย้งว่าการทดสอบดังกล่าวมีความปลอดภัยต่อการเปลี่ยนแปลงการใช้งานเช่นหากเราตัดสินใจแทนที่forEachด้วยการforวนซ้ำดั้งเดิมหรือวิธีการทำซ้ำอื่น ๆ ดังนั้นการทดสอบไม่ได้อย่างสิ้นเชิงจิ๊บจ๊อย และยังดูเหมือนว่าใกล้มาก ... นี่เป็นอีกตัวอย่างที่อาจมีผลมากกว่า พิจารณาฟังก์ชั่นที่ไม่ทำอะไรเลยนอกจากประสานงานวัตถุหรือฟังก์ชั่นอื่น ๆ ตัวอย่างเช่น: function bakeCookies(dough, pan, …

87 unit-testing  testing  tdd