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

สมมติว่ามีโปรแกรมที่ค่อนข้างใหญ่ (พูด 900k SLOC ใน C #) ทุกความเห็น / บันทึกไว้อย่างละเอียดจัดระเบียบดีและทำงานได้ดี ฐานรหัสทั้งหมดเขียนขึ้นโดยนักพัฒนาอาวุโสคนเดียวซึ่งไม่ได้อยู่กับ บริษัท อีกต่อไป รหัสทั้งหมดนั้นสามารถทำการทดสอบได้เหมือนเดิมและ IoC นั้นถูกใช้ไปตลอด - ยกเว้นด้วยเหตุผลแปลก ๆ บางอย่างที่พวกเขาไม่ได้เขียนการทดสอบหน่วยใด ๆ ตอนนี้ บริษัท ของคุณต้องการแยกรหัสและต้องการเพิ่มการทดสอบหน่วยเพื่อตรวจสอบเมื่อมีการเปลี่ยนแปลงการทำงานหลักของระบบ การเพิ่มการทดสอบเป็นความคิดที่ดีหรือไม่ ถ้าเป็นเช่นนั้นเราจะเริ่มจากสิ่งนี้ได้อย่างไร แก้ไข ตกลงดังนั้นฉันไม่ได้คาดหวังคำตอบที่สร้างข้อโต้แย้งที่ดีสำหรับข้อสรุปที่ตรงกันข้าม ปัญหาอาจจะออกจากมือของฉันอยู่ดี ฉันได้อ่าน "คำถามที่ซ้ำกัน" เช่นกันและฉันทามติทั่วไปคือ "การทดสอบการเขียนเป็นสิ่งที่ดี" ... ใช่ แต่ไม่เป็นประโยชน์ในกรณีนี้โดยเฉพาะ ฉันไม่คิดว่าฉันอยู่คนเดียวที่นี่ในการพิจารณาการทดสอบการเขียนสำหรับระบบเดิม ฉันจะทำตัวชี้วัดว่าใช้เวลาเท่าไรและมีกี่ครั้งที่การทดสอบใหม่ตรวจพบปัญหา (และกี่ครั้งที่พวกเขาไม่ทำ) ฉันจะกลับมาและอัปเดตปีนี้จากผลลัพธ์ของฉัน สรุปผลการศึกษา ดังนั้นจึงปรากฎว่าเป็นไปไม่ได้ที่จะเพิ่มการทดสอบหน่วยในโค้ดที่มีอยู่ด้วยลักษณะของออร์โธดอกซ์ เมื่อโค้ดทำงานคุณจะไม่สามารถทำการทดสอบของคุณได้แสงสีแดง / สีเขียว - เขียวก็มักจะไม่ชัดเจนว่าพฤติกรรมใดที่มีความสำคัญในการทดสอบไม่ชัดเจนว่าจะเริ่มต้นที่ใด ที่จริงแล้วการถามคำถามนี้พลาดประเด็นสำคัญในการเขียนแบบทดสอบในตอนแรก ในกรณีส่วนใหญ่ฉันพบว่ามันง่ายกว่าจริง ๆ …

68 unit-testing  tdd  maintenance 

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

64 unit-testing  tdd  difference 

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

62 testing  unit-testing  tdd  bdd  integration-tests 

เราพยายามออกแบบระบบของเราให้สามารถทดสอบได้และส่วนใหญ่พัฒนาโดยใช้ TDD ขณะนี้เรากำลังพยายามแก้ไขปัญหาต่อไปนี้: ในสถานที่ต่าง ๆ เราจำเป็นต้องใช้วิธีการช่วยเหลือแบบคงที่เช่น ImageIO และ URLEncoder (ทั้ง Java API มาตรฐาน) และห้องสมุดอื่น ๆ อีกมากมายที่ประกอบด้วยวิธีคงที่ส่วนใหญ่ (เช่นไลบรารี Apache Commons) แต่มันยากมากที่จะทดสอบวิธีการเหล่านั้นที่ใช้คลาสตัวช่วยแบบคงที่ ฉันมีความคิดหลายอย่างสำหรับการแก้ปัญหานี้: ใช้เฟรมเวิร์กจำลองที่สามารถจำลองคลาสแบบคงที่ (เช่น PowerMock) นี่อาจเป็นทางออกที่ง่ายที่สุด แต่ก็รู้สึกอยากยอมแพ้ สร้างคลาส wrapper ทันทีที่มีรอบยูทิลิตี้คงที่เหล่านั้นเพื่อให้พวกเขาสามารถฉีดเข้าไปในชั้นเรียนที่ใช้พวกเขา ดูเหมือนว่าจะเป็นคำตอบที่ค่อนข้างสะอาด แต่ฉันกลัวว่าเราจะจบลงด้วยการสร้างคลาส wrapper เหล่านั้น แยกการเรียกคลาสผู้ช่วยแบบคงที่เหล่านี้ลงในฟังก์ชันที่สามารถแทนที่ได้และทดสอบคลาสย่อยของคลาสที่ฉันต้องการทดสอบจริง ๆ แต่ฉันคิดอยู่เสมอว่านี่จะเป็นปัญหาที่หลายคนต้องเผชิญเมื่อทำ TDD - ดังนั้นจะต้องมีวิธีแก้ไขปัญหานี้อยู่แล้ว กลยุทธ์ที่ดีที่สุดในการรักษาคลาสที่ใช้ตัวช่วยคงที่สามารถทดสอบได้คืออะไร

62 java  testing  tdd  static-methods 

ดังนั้นวันนี้ฉันได้พูดคุยกับเพื่อนร่วมทีมเกี่ยวกับการทดสอบหน่วย สิ่งทั้งหมดเริ่มต้นขึ้นเมื่อเขาถามฉันว่า "เฮ้การทดสอบของชั้นนั้นอยู่ที่ไหนฉันเห็นเพียงอันเดียว" ทั้งคลาสนั้นเป็นผู้จัดการ (หรือบริการถ้าคุณต้องการเรียกมันอย่างนั้น) และวิธีการเกือบทั้งหมดเป็นเพียงการมอบหมายสิ่งของให้กับ DAO ดังนั้นมันจึงคล้ายกับ: SomeClass getSomething(parameters) { return myDao.findSomethingBySomething(parameters); } ประเภทของแผ่นสำเร็จรูปที่ไม่มีตรรกะ (หรืออย่างน้อยฉันไม่ได้พิจารณาการมอบหมายอย่างง่ายเช่นตรรกะ) แต่เป็นแผ่นที่มีประโยชน์ในกรณีส่วนใหญ่ (การแยกชั้น ฯลฯ ) และเรามีการอภิปรายค่อนข้างยาวว่าควรทดสอบยูนิทหรือไม่ (ฉันคิดว่ามันคุ้มค่าที่จะกล่าวถึงว่าฉันทำการทดสอบยูนิทอย่างเต็มที่) ข้อโต้แย้งหลักของเขาคือว่าไม่ใช่ TDD (ชัดเจน) และบางคนอาจต้องการดูการทดสอบเพื่อตรวจสอบว่าวิธีการนี้ทำอะไร (ฉันไม่ทราบว่ามันจะชัดเจนมากขึ้น) หรือในอนาคตบางคนอาจต้องการเปลี่ยน การนำไปใช้งานและเพิ่มตรรกะ (หรือเช่น "ใด ๆ ") ใหม่ให้กับตรรกะนั้น (ซึ่งในกรณีนี้ฉันคิดว่าบางคนควรทดสอบตรรกะนั้น) นี่ทำให้ฉันคิดว่า เราควรมุ่งมั่นเพื่อให้ครอบคลุมการทดสอบมากที่สุดหรือไม่? หรือเป็นเพียงศิลปะเพื่อประโยชน์ของงานศิลปะในเวลานั้น? ฉันไม่เห็นเหตุผลใด ๆ ที่อยู่เบื้องหลังการทดสอบสิ่งต่าง ๆ เช่น: getters และ setters (ยกเว้นว่าพวกเขามีเหตุผลบางอย่างในตัวพวกเขา) รหัส "สำเร็จรูป" เห็นได้ชัดว่าการทดสอบวิธีการดังกล่าว …

61 testing  unit-testing  tdd 

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

54 unit-testing  tdd  solid 

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

54 unit-testing  development-process  tdd 

อะไรคือความแตกต่างระหว่างการสร้างแอปพลิเคชันOutside Inกับการสร้างInside Outโดยใช้ TDD นี่คือหนังสือที่ฉันอ่านเกี่ยวกับ TDD และการทดสอบหน่วย: การทดสอบพัฒนาขับเคลื่อน: โดยตัวอย่าง การพัฒนาขับเคลื่อนทดสอบ: คู่มือปฏิบัติ: แนวทางปฏิบัติ: แนวทางปฏิบัติ โซลูชั่นโลกแห่งความจริงสำหรับการพัฒนา PHP Framework คุณภาพสูงและ การพัฒนาทดสอบขับเคลื่อนแอพพลิเคชันใน Microsoft รูปแบบการทดสอบNET xUnit: รหัสการทดสอบการปรับ โครงสร้างใหม่ศิลปะการทดสอบหน่วย: ด้วยตัวอย่างใน. Net การพัฒนาซอฟต์แวร์เชิงวัตถุแนะนำโดยการทดสอบ ---> อันนี้ยากที่จะเข้าใจจริงๆเพราะ JAVA ไม่ใช่ภาษาหลักของฉัน :) เกือบทั้งหมดอธิบายถึงพื้นฐานของ TDD และการทดสอบหน่วยโดยทั่วไป แต่ด้วยการกล่าวถึงเพียงเล็กน้อยถึงวิธีต่างๆในการสร้างแอปพลิเคชัน อีกสิ่งที่ฉันสังเกตเห็นคือหนังสือส่วนใหญ่ (ถ้าไม่ใช่ทั้งหมด) จะไม่สนใจขั้นตอนการออกแบบเมื่อเขียนแอปพลิเคชัน พวกเขามุ่งเน้นที่การเขียนกรณีทดสอบอย่างรวดเร็วและปล่อยให้การออกแบบเกิดขึ้นเอง อย่างไรก็ตามฉันเจอย่อหน้าในรูปแบบการทดสอบ xUnit ที่กล่าวถึงวิธีการที่ผู้คนเข้าหา TDD มี 2 โรงเรียนออกมีนอกใน VS Inside Out น่าเศร้าที่หนังสือเล่มนี้ไม่ได้อธิบายเพิ่มเติมในประเด็นนี้ …

53 design  web-development  unit-testing  tdd 

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

53 tdd 

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

53 unit-testing  tdd  debugging 

ฉันพยายามคลุมศีรษะด้วย TDD โดยเฉพาะในส่วนของการพัฒนา ฉันได้ดูหนังสือบางเล่ม แต่หนังสือที่ฉันพบส่วนใหญ่จัดการกับส่วนทดสอบ - ประวัติของ NUnit ทำไมการทดสอบจึงดี Red / Green / Refactor และวิธีการสร้างเครื่องคำนวณสตริง สิ่งที่ดี แต่นั่นคือ "เพียงแค่" การทดสอบหน่วยไม่ใช่ TDD โดยเฉพาะฉันไม่เข้าใจว่า TDD ช่วยให้ฉันได้รับการออกแบบที่ดีได้อย่างไรถ้าฉันต้องการการออกแบบเพื่อเริ่มการทดสอบ เพื่ออธิบายให้นึกภาพ 3 ข้อเหล่านี้: แคตตาล็อกต้องมีรายการผลิตภัณฑ์ แค็ตตาล็อกควรจดจำผลิตภัณฑ์ที่ผู้ใช้ดู ผู้ใช้ควรสามารถค้นหาผลิตภัณฑ์ได้ ณ จุดนี้มีหนังสือหลายเล่มดึงกระต่ายเวทมนตร์ออกมาจากหมวกและกระโดดลงไปใน "การทดสอบบริการผลิตภัณฑ์" แต่พวกเขาไม่ได้อธิบายว่าพวกเขาสรุปได้อย่างไรว่ามีบริการผลิตภัณฑ์ในตอนแรก นั่นคือส่วน "การพัฒนา" ใน TDD ที่ฉันพยายามเข้าใจ จำเป็นต้องมีการออกแบบที่มีอยู่ แต่สิ่งที่อยู่นอกบริการ - เอนทิตี้ (นั่นคือ: มีผลิตภัณฑ์ดังนั้นควรมี ProductService) ไม่พบ (เช่นข้อกำหนดที่สองต้องการให้ฉันมีแนวคิดบางอย่างของ ผู้ใช้ แต่ฉันจะใส่ฟังก์ชั่นการเตือนไว้ที่ไหนและค้นหาคุณสมบัติของ ProductService …

50 java  c#  .net  tdd 

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

49 testing  unit-testing  tdd  automation  test-automation 

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

48 unit-testing  scrum  tdd 

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

47 testing  unit-testing  tdd  integration-tests 

คำถามนี้ไม่เกี่ยวกับกรอบการทดสอบหน่วย คำถามนี้ไม่เกี่ยวกับการเขียนการทดสอบหน่วย คำถามนี้เกี่ยวกับสถานที่ที่จะวางโค้ด UT และวิธี / เวลา / สถานที่ในการรวบรวมและเรียกใช้ ในการทำงานอย่างมีประสิทธิภาพด้วยรหัสมรดก Michael Feathers ยืนยันว่า ทดสอบหน่วยที่ดี ... ทำงานเร็ว และนั่น การทดสอบหน่วยที่ใช้เวลา 1 / 10th ของวินาทีในการทำงานคือการทดสอบหน่วยช้า ฉันคิดว่าคำจำกัดความเหล่านี้สมเหตุสมผล ฉันยังคิดว่าพวกเขาบอกเป็นนัยว่าคุณต้องเก็บชุดการทดสอบหน่วยและชุดการทดสอบรหัสเหล่านั้นที่ใช้เวลานานกว่าแยกจากกัน แต่ฉันคิดว่านั่นคือราคาที่คุณจ่ายสำหรับการโทรหาการทดสอบหน่วยเท่านั้น . เห็นได้ชัดว่าปัญหาใน C ++ คือการ "เรียกใช้" การทดสอบหน่วยของคุณคุณต้อง: แก้ไขรหัสของคุณ (การผลิตหรือการทดสอบหน่วยขึ้นอยู่กับ "รอบ" ที่คุณอยู่) รวบรวม ลิงค์ เริ่มการทดสอบหน่วยปฏิบัติการ ( s ) แก้ไข(หลังจากลงคะแนนเสียงแปลก ๆ ) : ก่อนลงรายละเอียดฉันจะลองสรุปประเด็นที่นี่: รหัสการทดสอบหน่วย C ++ …

47 c++  unit-testing  tdd  projects-and-solutions