การเขียนโค้ดขั้นต่ำเพื่อผ่านการทดสอบหน่วย - โดยไม่ต้องโกง!

เมื่อทำการทดสอบ 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
{
    public long CalculateFactorial(long input)
    {
        return 120;
    }
}

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

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

มันถูกต้องสมบูรณ์แบบ สีแดงสีเขียว Refactor

การทดสอบครั้งแรกผ่านไป

เพิ่มการทดสอบที่สองด้วยอินพุตใหม่

ตอนนี้ให้เป็นสีเขียวอย่างรวดเร็วคุณสามารถเพิ่ม if-else ซึ่งทำงานได้ดี มันผ่านไปแล้ว แต่ยังไม่เสร็จ

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

ฉันไม่ได้พูดว่าอย่าเขียนมันอย่างถูกต้องในครั้งแรก ฉันแค่บอกว่ามันไม่ใช่การโกงถ้าคุณไม่ทำ

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

TDD ไม่ใช่กระสุนวิเศษสำหรับการออกแบบ คุณยังต้องรู้วิธีแก้ปัญหาด้วยการใช้รหัสและคุณยังต้องรู้วิธีการทำในระดับที่สูงกว่ารหัสสองสามบรรทัดเพื่อทำการทดสอบ

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

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

ลุง Bob Martin กล่าวสิ่งนี้:

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

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

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

เป็นคำถามที่ดีมาก ... และฉันต้องไม่เห็นด้วยกับเกือบทุกคนยกเว้น @Robert

การเขียน

return 120;

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

นี่คือเหตุผล:

• คำนวณแฟคทอเรียลเป็นคุณลักษณะไม่ใช่ "คืนค่าคงที่" "return 120" ไม่ใช่การคำนวณ

• อาร์กิวเมนต์ 'refactor' ถูกเข้าใจผิด หากคุณมีสองกรณีทดสอบสำหรับ 5 และ 6 รหัสนี้ยังคงผิดเพราะคุณไม่ได้คำนวณแฟคทอเรียลเลย :

  if (input == 5) { return 120; } //input=5 case
  else { return 720; }   //input=6 case
  

• ถ้าเราทำตามอาร์กิวเมนต์ 'refactor' ตามตัวอักษรเมื่อเรามี 5 กรณีทดสอบเราจะเรียกใช้ YAGNI และใช้ฟังก์ชันโดยใช้ตารางการค้นหา:

  if (factorialDictionary.Contains(input)) {
      return factorialDictionary[input]; 
  }
  throw new Exception("Input failure");
  

ไม่มีของเหล่านี้เป็นจริงการคำนวณอะไรที่คุณอยู่ และนั่นไม่ใช่งาน!

เมื่อคุณเขียนการทดสอบหน่วยเดียวเท่านั้นการใช้งานแบบบรรทัดเดียว ( return 120;) นั้นถูกต้องตามกฎหมาย การเขียนลูปคำนวณค่า 120 - นั่นจะเป็นการโกง!

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

กฎง่ายๆที่อาจมีประโยชน์ในที่นี้คือ: ศูนย์หนึ่งอันมากๆ ศูนย์และหนึ่งเป็นกรณีขอบที่สำคัญสำหรับแฟคทอเรียล พวกเขาสามารถนำมาใช้กับหนึ่งสมุทร กรณีทดสอบ "หลายคน" (เช่น 5!) จะบังคับให้คุณเขียนลูป กรณีทดสอบ "ล็อต" (1,000 !?) อาจบังคับให้คุณใช้อัลกอริธึมทางเลือกเพื่อจัดการกับตัวเลขที่มีขนาดใหญ่มาก

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

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

โปรดจำไว้ว่าการทดสอบนั้นเป็นเวอร์ชั่นที่รันได้ของสเปคของคุณและถ้าสเปคทั้งหมดที่กล่าวคือ f (6) = 120 ดังนั้นมันจึงเหมาะกับบิล

หากคุณสามารถ "โกง" ในลักษณะดังกล่าวแสดงว่าการทดสอบหน่วยของคุณมีข้อบกพร่อง

แทนที่จะทดสอบวิธีแฟกทอเรียลด้วยค่าเดียวลองทดสอบว่าเป็นช่วงของค่า การทดสอบที่ขับเคลื่อนด้วยข้อมูลสามารถช่วยได้ที่นี่

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

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

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

เพียงแค่เขียนแบบทดสอบเพิ่มเติม ในที่สุดมันจะสั้นกว่าที่จะเขียน

public long CalculateFactorial(long input)
{
    return input <= 1 ? 1 : CalculateFactorial(input-1)*input;
}

กว่า

public long CalculateFactorial(long input)
{
    switch (input) {
       case 0: return 1;
       case 1: return 1;
       case 2: return 2;
       case 3: return 6;
       case 4: return 24;
       case 5: return 120;
    }
}

:-)

การเขียนการทดสอบ "cheat" นั้นใช้ได้สำหรับค่าที่พอเพียงของ "OK" แต่การเรียกคืน - หน่วยทดสอบเสร็จสมบูรณ์ก็ต่อเมื่อการทดสอบทั้งหมดผ่านและไม่มีการทดสอบใหม่สามารถเขียนได้ที่จะล้มเหลว หากคุณต้องการมีวิธี CalculateFactorial ที่มีประโยคif (หรือดีกว่านั้นคือคำสั่งswitch / caseขนาดใหญ่:-) คุณสามารถทำได้และเนื่องจากคุณต้องจัดการกับหมายเลขที่มีความแม่นยำคงที่ซึ่งจำเป็นต้องใช้รหัส การใช้งานนี้มีขอบเขต จำกัด (แม้ว่าอาจจะค่อนข้างใหญ่และน่าเกลียดและอาจถูก จำกัด โดยข้อ จำกัด ของคอมไพเลอร์หรือระบบในขนาดสูงสุดของโค้ดของโพรซีเดอร์) ณ จุดนี้ถ้าคุณจริงๆยืนยันว่าการพัฒนาทั้งหมดจะต้องขับเคลื่อนด้วยการทดสอบหน่วยคุณสามารถเขียนการทดสอบที่ต้องใช้รหัสในการคำนวณผลลัพธ์ในจำนวนเวลาที่สั้นกว่าที่สามารถทำได้โดยทำตามกิ่งไม้ทั้งหมดของคำสั่งif

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

แบ่งปันและเพลิดเพลิน

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

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

สำหรับ Factorials การทดสอบจะมีลักษณะเช่นนี้:

    [Theory]
    [InlineData(0, 1)]
    [InlineData( 1, 1 )]
    [InlineData( 2, 2 )]
    [InlineData( 3, 6 )]
    [InlineData( 4, 24 )]
    public void Test_Factorial(int input, int expected)
    {
        int result = Factorial( input );
        Assert.Equal( result, expected);
    }

คุณสามารถนำเสนอการทดสอบข้อมูล (ที่ส่งคืนIEnumerable<Tuple<xxx>>) และเข้ารหัสค่าคงที่ทางคณิตศาสตร์เช่นการหารซ้ำ ๆ โดย n จะให้ผลตอบแทน n-1)

ฉันพบว่า TP นี้เป็นวิธีทดสอบที่ทรงพลังมาก

หากคุณยังคงสามารถโกงการทดสอบนั้นไม่เพียงพอ เขียนแบบทดสอบเพิ่มเติม! สำหรับตัวอย่างของคุณฉันจะพยายามเพิ่มการทดสอบด้วยอินพุต 1, -1, -1000, 0, 10, 200

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

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

ฉันขอแนะนำให้คุณเลือกการทดสอบไม่ใช่การทดสอบที่ดีที่สุด

ฉันจะเริ่มด้วย:

แฟกทอเรียล (1) เป็นการทดสอบครั้งแรก

แฟกทอเรียล (0) เป็นตัวที่สอง

แฟกทอเรียล (-ve) เป็นอันดับสาม

แล้วดำเนินการต่อกับกรณีที่ไม่น่ารำคาญ

และจบลงด้วยกรณีล้น