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

เมื่อทำการทดสอบ TDD และเขียนการทดสอบหน่วยหนึ่งจะต่อต้านการกระตุ้นให้ "โกง" เมื่อเขียนรหัสซ้ำ "ครั้งแรกของ" การใช้งาน "ที่คุณกำลังทดสอบอยู่ได้อย่างไร ตัวอย่างเช่น: ฉันจะต้องคำนวณแฟคทอเรียลของตัวเลข ฉันเริ่มต้นด้วยการทดสอบหน่วย (ใช้ MSTest) สิ่งที่ชอบ: [TestClass] public class CalculateFactorialTests { [TestMethod] public void CalculateFactorial_5_input_returns_120() { // Arrange var myMath = new MyMath(); // Act long output = myMath.CalculateFactorial(5); // Assert Assert.AreEqual(120, output); } } ฉันเรียกใช้รหัสนี้และมันล้มเหลวเนื่องจากCalculateFactorialวิธีการไม่ได้อยู่ ดังนั้นตอนนี้ฉันเขียนการวนซ้ำครั้งแรกของรหัสเพื่อใช้วิธีการภายใต้การทดสอบการเขียนรหัสขั้นต่ำที่ จำเป็นในการผ่านการทดสอบ สิ่งคือฉันอยากจะเขียนต่อไปนี้: public class MyMath …

36 unit-testing  tdd 

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

33 testing  unit-testing  code-quality  tdd 

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

31 development-process  tdd 

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

30 agile  development-process  tdd  development-methodologies 

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

30 tdd  integration-tests 

ความสัมพันธ์ของ BDD และ TDD คืออะไร? จากสิ่งที่ฉันเข้าใจ BDD เพิ่มสองสิ่งสำคัญเหนือ TDD: การทดสอบการตั้งชื่อ (มั่นใจ / ควร) และการทดสอบการยอมรับ ฉันควรติดตาม TDD ในระหว่างการพัฒนาโดย BDD หรือไม่ ถ้าใช่จะทำการตั้งชื่อการทดสอบหน่วย TDD ของฉันในแบบเดียวกันให้แน่ใจว่า / ควรมีสไตล์?

30 tdd  bdd 

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

30 programming-practices  unit-testing  tdd 

สมมติว่าฉันเริ่มพัฒนาเกมสวมบทบาทกับตัวละครที่โจมตีตัวละครอื่นและสิ่งต่าง ๆ ใช้ TDD ฉันสร้างกรณีทดสอบเพื่อทดสอบตรรกะภายในCharacter.receiveAttack(Int)วิธี บางสิ่งเช่นนี้ @Test fun healthIsReducedWhenCharacterIsAttacked() { val c = Character(100) //arg is the health c.receiveAttack(50) //arg is the suffered attack damage assertThat(c.health, is(50)); } บอกว่าผมมี 10 วิธีการทดสอบreceiveAttackวิธีการ ตอนนี้ผมเพิ่มวิธีการCharacter.attack(Character)(ที่โทรreceiveAttackวิธี) และหลังจากที่บางรอบ TDD ทดสอบนั้นผมตัดสินใจ: ควรจะเป็นCharacter.receiveAttack(Int)private จะเกิดอะไรขึ้นกับ 10 กรณีทดสอบก่อนหน้า? ฉันควรจะลบมันเหรอ? ฉันควรรักษาวิธีpublic(ฉันไม่คิดอย่างนั้น)? คำถามนี้ไม่ได้เกี่ยวกับวิธีการทดสอบวิธีการส่วนตัว แต่วิธีการจัดการกับพวกเขาหลังจากการออกแบบใหม่เมื่อใช้ TDD

29 object-oriented-design  tdd 

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

29 testing  tdd 

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

29 development-process  tdd  refactoring 

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

28 unit-testing  tdd 

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

28 testing  tdd 

มันเป็นไปได้ที่จะคาดหวังความคุ้มครองรหัส 100% ในการใช้งานเว็บ jquery / backbonejs หนัก? มันสมเหตุสมผลที่จะล้มเหลวในการวิ่งเนื่องจากความครอบคลุม 100% ไม่พบเมื่อครอบคลุมรหัสจริงวนเวียนอยู่รอบ ๆ 92% -95% ใน javascript / jquery?

28 code-quality  tdd  bdd 

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

27 unit-testing  agile  tdd 

ฉันค่อนข้างใหม่สำหรับวิธีการ TDD และการทดลองครั้งแรกของฉันบอกว่าการเขียนโค้ดฟังก์ชัน 1 บรรทัดหมายถึงการเขียนโค้ดทดสอบประมาณ 2-3 บรรทัด ดังนั้นในกรณีที่ฉันจะเขียน 1,000 LOC, codebase ทั้งหมดรวมถึงการทดสอบจะเป็นอะไรที่เหมือน ~ 3500 LOC นี่ถือว่าเป็นเรื่องปกติหรือไม่ อัตราส่วนในโค้ดที่คุณเขียนคือเท่าใด

27 testing  unit-testing  tdd  metrics