คุณทดสอบหน่วยการทดสอบหน่วยอย่างไร [ปิด]

ฉันกำลังดูการออกอากาศทางเว็บของ Rob Connerys บนแอป MVCStoreFront และฉันสังเกตเห็นว่าเขากำลังทดสอบหน่วยแม้กระทั่งสิ่งที่ธรรมดาที่สุดเช่น:

public Decimal DiscountPrice
{
   get
   {
       return this.Price - this.Discount;
   }
}

จะมีการทดสอบเช่น:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,80);
}

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

หากเป็นเช่นนั้นการทดสอบหน่วยของคุณไม่มีความหมายสำหรับคุณ

นอกจากนี้การทดสอบหน่วยของคุณยังเป็นอีกจุดหนึ่งของความล้มเหลว:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,90);
}

ตอนนี้การทดสอบมีข้อบกพร่อง เห็นได้ชัดว่าในการทดสอบง่ายๆไม่ใช่เรื่องใหญ่ แต่บอกว่าเรากำลังทดสอบกฎทางธุรกิจที่ซับซ้อน เราได้อะไรจากที่นี่?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[แก้ไข]

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

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

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

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

เมื่อปฏิบัติตามขั้นตอนนี้อย่างเคร่งครัด '' หน่วย '' ทั้งหมดจะได้รับการปกป้องโดยตาข่ายนิรภัยที่การทดสอบหน่วยกำลังทำอยู่แม้จะเป็นเรื่องธรรมดาที่สุดก็ตาม

Assert.IsEqual(p.DiscountPrice,90);

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

ลองนึกดูว่าซอฟต์แวร์ของคุณจำเป็นต้องรองรับส่วนลดประเภทอื่นตามเปอร์เซ็นต์บางทีอาจขึ้นอยู่กับปริมาณที่ซื้อวิธี Product :: DiscountPrice () ของคุณอาจซับซ้อนขึ้น และเป็นไปได้ว่าการแนะนำการเปลี่ยนแปลงเหล่านั้นจะทำลายกฎส่วนลดง่ายๆที่เรามีในตอนแรก จากนั้นคุณจะเห็นค่าของการทดสอบนี้ซึ่งจะตรวจจับการถดถอยทันที

Red - Green - Refactor - นี่คือการจดจำสาระสำคัญของกระบวนการ TDD

สีแดงหมายถึงแถบสีแดง JUnit เมื่อการทดสอบล้มเหลว

สีเขียวคือสีของแถบความคืบหน้าของ JUnit เมื่อการทดสอบทั้งหมดผ่าน

Refactorภายใต้เงื่อนไขสีเขียว: ลบการซ้ำซ้อนปรับปรุงความสามารถในการอ่าน

ตอนนี้เพื่อพูดถึงประเด็นของคุณเกี่ยวกับ "3-4 เลเยอร์เหนือโค้ด" นี่เป็นเรื่องจริงในกระบวนการแบบดั้งเดิม (เหมือนน้ำตก) ไม่ใช่เมื่อกระบวนการพัฒนาคล่องตัว และ Agile คือโลกที่ TDD มาจาก; TDD เป็นรากฐานที่สำคัญของeXtreme การเขียนโปรแกรม

Agile เป็นเรื่องเกี่ยวกับการสื่อสารโดยตรงแทนที่จะเป็นเอกสารความต้องการแบบโยนข้ามกำแพง

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

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

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

... [I] ในกระบวนการจริงคุณมี 3-4 ชั้นเหนือรหัสของคุณ (คำขอทางธุรกิจเอกสารความต้องการเอกสารสถาปัตยกรรม) ซึ่งกฎทางธุรกิจที่กำหนดจริง (ราคาส่วนลดคือราคา - ส่วนลด) อาจถูกกำหนดผิด หากเป็นเช่นนั้นการทดสอบหน่วยของคุณไม่มีความหมายสำหรับคุณ

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

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

นอกจากนี้การทดสอบหน่วยของคุณยังเป็นอีกจุดหนึ่งของความล้มเหลว ...

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

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

เราได้อะไรจากที่นี่?

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

เมื่อพูดถึง Feathers มีแหล่งข้อมูลที่ยอดเยี่ยมสองอย่างที่คุณควรตรวจสอบในเรื่องนี้:

• ทำงานอย่างมีประสิทธิภาพกับ Legacy Code
• การพัฒนาแอปพลิเคชัน Brownfield ใน. NET

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

[I] หากราคาส่วนลดไม่ถูกต้องทีมทดสอบจะยังคงพบปัญหาอยู่การทดสอบหน่วยช่วยประหยัดงานได้อย่างไร?

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

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

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

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

มีคนสองสามคนกล่าวถึงการทดสอบช่วยบังคับใช้ข้อกำหนด เป็นประสบการณ์ของผมที่ spec ผิดเหมือนกันบ่อยกว่าไม่ ...

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

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

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

การทดสอบจะคุ้มค่ากับความพยายามอย่างไร? จากประสบการณ์ของฉันอย่างน้อยสี่วิธีอย่างน้อยเมื่อทำการทดสอบขับเคลื่อนการพัฒนา:

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

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

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

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

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

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

ฉันเห็นว่าการทดสอบหน่วยและรหัสการผลิตมีความสัมพันธ์ทางชีวภาพ ใส่เพียง: หนึ่งทดสอบอื่น ๆ และทั้งทดสอบนักพัฒนา

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

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

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

ฉันเห็นประเด็นของคุณ แต่มันคุยโวอย่างชัดเจน

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

แม้ว่าในบางกรณีอาจเป็นจริง แต่ส่วนใหญ่แทบจะไม่

TDD ถือว่า: การทดสอบเพิ่มเติม = ความล้มเหลวน้อยลง

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

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

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

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

ฉันได้คิดเกี่ยวกับวิธีที่ดีในการตอบคำถามนี้แล้วและต้องการวาดคู่ขนานไปกับวิธีการทางวิทยาศาสตร์ IMO คุณสามารถเขียนคำถามนี้ใหม่ได้ว่า "คุณจะทดลองการทดสอบอย่างไร"

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

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

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

คุณต้องใช้กระบวนทัศน์ที่ถูกต้องเมื่อเขียนแบบทดสอบ

1. เริ่มต้นด้วยการเขียนแบบทดสอบของคุณก่อน
2. ตรวจสอบให้แน่ใจว่าพวกเขาไม่สามารถเริ่มต้นได้
3. ทำให้พวกเขาผ่าน
4. ตรวจสอบโค้ดก่อนที่คุณจะตรวจสอบโค้ดของคุณ (ตรวจสอบให้แน่ใจว่าได้ตรวจสอบการทดสอบแล้ว)

คุณไม่สามารถแน่ใจได้เสมอไป แต่พวกเขาปรับปรุงการทดสอบโดยรวม

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

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