ฉันต้องการกรอบการทดสอบหน่วยจริงหรือไม่?

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

VERIFY(cond) if (!(cond)) {std::cout << "unit test failed at " << __FILE__ << "," << __LINE__; asserst(false)}

จากนั้นเราก็สร้างฟังก์ชั่นสำหรับการทดสอบแต่ละแบบของเราเช่น

void CheckBehaviorYWhenXHappens()
{
    // a bunch of code to run the test
    //
    VERIFY(blah != blah2);
    // more VERIFY's as needed
}

เซิร์ฟเวอร์ CI ของเรารับ "การทดสอบหน่วยล้มเหลว" และล้มเหลวในการสร้างส่งอีเมลข้อความถึงนักพัฒนา

และถ้าเรามีรหัสการตั้งค่าที่ซ้ำกันเราเพียงแค่ refactor มันเหมือนว่าเราจะทำซ้ำรหัสอื่น ๆ ที่เราต้องการในการผลิต เราห่อมันไว้เบื้องหลังฟังก์ชั่นตัวช่วยทำให้คลาสการทดสอบบางส่วนพันกันตั้งค่าสถานการณ์ที่ใช้บ่อย

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

อย่างที่คนอื่นพูดไปแล้วคุณมีกรอบงานที่เรียบง่ายและทำเองที่บ้าน

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

• การรวบรวมกรณีทดสอบอัตโนมัติ เช่นการกำหนดวิธีการทดสอบใหม่ควรจะเพียงพอที่จะทำการประมวลผล JUnit รวบรวมวิธีการทั้งหมดที่มีชื่อขึ้นต้นโดยอัตโนมัติtestNUnit มีการเพิ่มความคิดเห็น[Test], Boost.Test ใช้BOOST_AUTO_TEST_CASEและBOOST_FIXTURE_TEST_CASEมาโคร

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

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

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

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

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

ดูเหมือนว่าคุณใช้เฟรมเวิร์กซึ่งเป็นโฮมเมดอยู่แล้ว

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

ในทางกลับกันกรอบการทำงานที่บ้านบังคับให้คุณไม่ใช้รหัสของคุณร่วมกันหรือกำหนดกรอบงานเองซึ่งอาจยุ่งยากกับการเติบโตของกรอบงานนั้น

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

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

สุดท้าย แต่ไม่ท้ายสุดเฟรมเวิร์กที่ใหญ่กว่าจะมอบคุณสมบัติเพิ่มเติมที่คุณอาจต้องใช้ในเฟรมเวิร์กของคุณเองหนึ่งวัน Assert.AreEqual(expected, actual)ไม่เพียงพอเสมอ ถ้าคุณต้องการ:

• วัดความแม่นยำ?

  Assert.AreEqual(3.1415926535897932384626433832795, actual, 25)
  

• ทดสอบเป็นโมฆะถ้ามันใช้เวลานานเกินไป? การปรับใช้การหมดเวลาอีกครั้งอาจไม่ตรงไปตรงมาแม้แต่ในภาษาที่อำนวยความสะดวกในการเขียนโปรแกรมแบบอะซิงโครนัส

• ทดสอบวิธีการซึ่งคาดว่าจะมีข้อยกเว้นโยน?

• มีรหัสที่หรูหรามากขึ้น?

  Assert.Verify(a == null);
  

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

  Assert.IsNull(a);
  

อย่างที่คนอื่นพูดไปแล้วคุณมีกรอบทำที่บ้านของตัวเองแล้ว

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

นอกจากนี้กรอบการทดสอบอื่น ๆ อาจมีคุณสมบัติเพิ่มเติมที่คุณสามารถใช้ประโยชน์ได้

คุณมีกรอบแม้ว่ามันจะง่าย

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

ใช้เวลานานแค่ไหนในการปรับโครงสร้างหน่วยการทดสอบให้เป็นกรอบใหม่ วันหรือสองสามสัปดาห์อาจจะคุ้มค่า แต่อาจจะไม่มากนัก

วิธีที่ฉันเห็นคุณทั้งสองมีข้อได้เปรียบและคุณอยู่ที่ "เสียเปรียบ" (sic)

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

ข้อดีอย่างหนึ่งของการมี API ทดสอบหน่วยที่ออกแบบมาอย่างดีคือมีการสนับสนุนดั้งเดิมมากมายใน IDE ที่ทันสมัยที่สุด สิ่งนี้จะไม่ส่งผลกระทบต่อผู้ใช้ hard-core VI และ emacs ที่มีผู้ใช้ Visual Studio แต่ผู้ใช้ที่ใช้ IDE ที่ดีคุณสามารถดีบักการทดสอบและดำเนินการภายใน IDE เอง สิ่งนี้เป็นสิ่งที่ดี แต่มีข้อได้เปรียบที่ยิ่งใหญ่กว่าขึ้นอยู่กับกรอบงานที่คุณใช้และเป็นภาษาที่ใช้ในการทดสอบรหัสของคุณ

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

เป็นตัวอย่างของสิ่งที่ฉันพูดถึงเปรียบเทียบสิ่งต่อไปนี้

ใช้การยืนยัน:

Assert(variable_A == expected_value_1); // if this fails...
Assert(variable_B == expected_value_2); // ...this will not execute
Assert(variable_C == expected_value_3); // ...and nor will this!

การใช้ BDD API ที่คล่องแคล่ว: (ลองจินตนาการว่าบิตตัวเอียงเป็นวิธีตัวชี้)

WithScenario("Test Scenario")
    .Given(*AConfiguration*) // each method
    .When(*MyMethodToTestIsCalledWith*, variable_A, variable_B, variable_C) // in the
    .Then(*ExpectVariableAEquals*, expected_value_1) // Scenario will
        .And(*ExpectVariableBEquals*, expected_value_2) // indicate if it has
        .And(*ExpectVariableCEquals*, expected_value_3) // passed or failed execution.
    .Execute();

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

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

ใช้Nunit :

[Test]
void TestMyMethod()
{
    const int theExpectedValue = someValue;

    GivenASetupToTestMyMethod();

    var theActualValue = WhenIExecuteMyMethodToTest();

    Assert.That(theActualValue, Is.EqualTo(theExpectedValue)); // nice, but it's not BDD
}

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

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

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

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

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