การใช้ C # ฉันต้องการคลาสUserที่มีชื่อผู้ใช้รหัสผ่านแฟล็กที่ใช้งานชื่อนามสกุลชื่อเต็ม ฯลฯ

ควรมีวิธีการพิสูจน์ตัวตนและบันทึกผู้ใช้ ฉันเพิ่งเขียนแบบทดสอบสำหรับวิธีการนี้หรือไม่? และฉันต้องกังวลเกี่ยวกับการทดสอบคุณสมบัติหรือไม่เนื่องจากเป็น. Net's getter and setters?

คำตอบที่ดีมากมายสำหรับคำถามนี้ยังอยู่ในคำถามของฉัน: " Beginning TDD - Challenges? Solutions? Recommendations? "

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

ฉันไม่รู้ว่าจะเริ่มจากตรงไหน?

• เริ่มใหม่อีกครั้ง คิดถึงการทดสอบการเขียนเมื่อคุณเขียนโค้ดใหม่เท่านั้น สิ่งนี้สามารถนำโค้ดเก่ากลับมาใช้ใหม่หรือเป็นคุณลักษณะใหม่ทั้งหมดได้
• เริ่มง่ายๆ อย่าไปวิ่งหนีและพยายามทำให้หัวของคุณอยู่ในกรอบการทดสอบรวมถึงการเป็น TDD-esque Debug.Assert ทำงานได้ดี ใช้เป็นจุดเริ่มต้น ไม่ยุ่งกับโครงการของคุณหรือสร้างการอ้างอิง
• เริ่มต้นในเชิงบวก คุณกำลังพยายามปรับปรุงงานฝีมือของคุณรู้สึกดีกับมัน ฉันได้เห็นนักพัฒนามากมายที่มีความสุขที่จะหยุดนิ่งและไม่ลองสิ่งใหม่ ๆ เพื่อให้ตัวเองดีขึ้น คุณกำลังทำในสิ่งที่ถูกต้องจำสิ่งนี้ไว้และมันจะช่วยหยุดคุณไม่ให้ท้อถอย
• เริ่มต้นพร้อมสำหรับความท้าทาย การเริ่มเข้าสู่การทดสอบค่อนข้างยาก คาดหวังความท้าทาย แต่จำไว้ว่าความท้าทายสามารถเอาชนะได้

ทดสอบเฉพาะสิ่งที่คุณคาดหวัง

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

ทดสอบสิ่งเดียวเท่านั้น

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

ฉันหวังว่านี่หมายความว่าเราสามารถก้าวต่อไปจาก "getters and setters" :)

ทดสอบรหัสของคุณไม่ใช่ภาษา

การทดสอบหน่วยเช่น:

Integer i = new Integer(7);
assert (i.instanceOf(integer));

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

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

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

เราเพิ่งเริ่มทำการทดสอบหน่วย เป็นเวลานานแล้วที่ฉันรู้ว่าการเริ่มทำมันเป็นเรื่องดี แต่ฉันไม่รู้ว่าจะเริ่มอย่างไรและที่สำคัญกว่านั้นจะต้องทดสอบอะไร

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

ฉันไม่รู้ว่าจะเริ่มเขียนโค้ดอย่างไรเนื่องจากมีตัวเลือกการชำระเงินที่แตกต่างกันมากมาย ใบแจ้งหนี้อาจเป็น $ 100 แต่ลูกค้าโอนเงินเพียง $ 99 บางทีคุณอาจส่งใบแจ้งหนี้การขายให้กับลูกค้า แต่คุณได้ซื้อจากลูกค้ารายนั้นด้วย คุณขายเขาในราคา 300 ดอลลาร์ แต่คุณซื้อมาในราคา 100 ดอลลาร์ คุณสามารถคาดหวังให้ลูกค้าของคุณจ่ายเงินให้คุณ $ 200 เพื่อชำระยอดคงเหลือ แล้วถ้าคุณขายได้ 500 เหรียญ แต่ลูกค้าจ่ายให้คุณแค่ 250 เหรียญ?

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

นี่คือจุดที่การทดสอบหน่วยมาช่วย

ฉันเริ่มเขียน (ในรหัสทดสอบ) วิธีสร้างรายการใบแจ้งหนี้ทั้งสำหรับการขายและการซื้อ จากนั้นฉันเขียนวิธีที่สองเพื่อสร้างการชำระเงินจริง โดยปกติผู้ใช้จะป้อนข้อมูลนั้นผ่านอินเทอร์เฟซผู้ใช้

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

หลังจากการทดสอบเสร็จสิ้นฉันจะไปที่ฐานข้อมูลและตรวจสอบอีกครั้งว่าสิ่งที่ฉันคาดหวังอยู่ที่นั่นหรือไม่

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

ฉันทำการทดสอบครั้งแรกแก้ไขข้อบกพร่องเล็ก ๆ น้อย ๆ จนกว่าการทดสอบจะผ่านไป

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

ขณะทดสอบความถูกต้องด้วยส่วนลดการชำระเงินฉันยังทดสอบการชำระเงินแบบธรรมดา การทดสอบทั้งสองควรผ่านแน่นอน

จากนั้นฉันก็หาทางลงไปสู่สถานการณ์ที่ซับซ้อนมากขึ้น

1) คิดถึงสถานการณ์ใหม่

2) เขียนแบบทดสอบสำหรับสถานการณ์นั้น ๆ

3) ทำการทดสอบเดี่ยวนั้นเพื่อดูว่าจะผ่านหรือไม่

4) หากไม่ได้ฉันจะทำการดีบักและแก้ไขโค้ดจนกว่าจะผ่าน

5) ในขณะที่แก้ไขโค้ดฉันยังคงทำการทดสอบทั้งหมด

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

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

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

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

ด้านล่างนี้เป็นเพียงการทดสอบบางส่วนที่ฉันสร้างขึ้นเพื่อทดสอบวิธีการชำระเงินของฉัน

public class TestPayments
{
    InvoiceDiaryHeader invoiceHeader = null;
    InvoiceDiaryDetail invoiceDetail = null;
    BankCashDiaryHeader bankHeader = null;
    BankCashDiaryDetail bankDetail = null;



    public InvoiceDiaryHeader CreateSales(string amountIncVat, bool sales, int invoiceNumber, string date)
    {
        ......
        ......
    }

    public BankCashDiaryHeader CreateMultiplePayments(IList<InvoiceDiaryHeader> invoices, int headerNumber, decimal amount, decimal discount)
    {
       ......
       ......
       ......
    }


    [TestMethod]
    public void TestSingleSalesPaymentNoDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 1, "01-09-2008"));
        bankHeader = CreateMultiplePayments(list, 1, 119.00M, 0);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(1, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(119M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(0M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
    }

    [TestMethod]
    public void TestSingleSalesPaymentDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 2, "01-09-2008"));
        bankHeader = CreateMultiplePayments(list, 2, 118.00M, 1M);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(1, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(118M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(1M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
    }

    [TestMethod]
    [ExpectedException(typeof(ApplicationException))]
    public void TestDuplicateInvoiceNumber()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("100", true, 2, "01-09-2008"));
        list.Add(CreateSales("200", true, 2, "01-09-2008"));

        bankHeader = CreateMultiplePayments(list, 3, 300, 0);
        bankHeader.Save();
        Assert.Fail("expected an ApplicationException");
    }

    [TestMethod]
    public void TestMultipleSalesPaymentWithPaymentDiscount()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("119", true, 11, "01-09-2008"));
        list.Add(CreateSales("400", true, 12, "02-09-2008"));
        list.Add(CreateSales("600", true, 13, "03-09-2008"));
        list.Add(CreateSales("25,40", true, 14, "04-09-2008"));

        bankHeader = CreateMultiplePayments(list, 5, 1144.00M, 0.40M);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(4, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(118.60M, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(400, bankHeader.BankCashDetails[0].Payments[1].PaymentAmount);
        Assert.AreEqual(600, bankHeader.BankCashDetails[0].Payments[2].PaymentAmount);
        Assert.AreEqual(25.40M, bankHeader.BankCashDetails[0].Payments[3].PaymentAmount);

        Assert.AreEqual(0.40M, bankHeader.BankCashDetails[0].Payments[0].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[2].PaymentDiscount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[3].PaymentDiscount);

        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[2].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[3].InvoiceHeader.Balance);
    }

    [TestMethod]
    public void TestSettlement()
    {
        IList<InvoiceDiaryHeader> list = new List<InvoiceDiaryHeader>();
        list.Add(CreateSales("300", true, 43, "01-09-2008")); //Sales
        list.Add(CreateSales("100", false, 6453, "02-09-2008")); //Purchase

        bankHeader = CreateMultiplePayments(list, 22, 200, 0);
        bankHeader.Save();

        Assert.AreEqual(1, bankHeader.BankCashDetails.Count);
        Assert.AreEqual(2, bankHeader.BankCashDetails[0].Payments.Count);
        Assert.AreEqual(300, bankHeader.BankCashDetails[0].Payments[0].PaymentAmount);
        Assert.AreEqual(-100, bankHeader.BankCashDetails[0].Payments[1].PaymentAmount);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[0].InvoiceHeader.Balance);
        Assert.AreEqual(0, bankHeader.BankCashDetails[0].Payments[1].InvoiceHeader.Balance);
    }

หากพวกเขาเป็นเรื่องเล็กน้อยก็ไม่ต้องกังวลกับการทดสอบ เช่นหากมีการดำเนินการเช่นนี้

public class User
{
    public string Username { get; set; }
    public string Password { get; set; }
}

ในทางกลับกันหากคุณกำลังทำบางสิ่งที่ชาญฉลาด (เช่นการเข้ารหัสและถอดรหัสรหัสผ่านใน getter / setter) จากนั้นให้ทำการทดสอบ

กฎคือคุณต้องทดสอบตรรกะทุกชิ้นที่คุณเขียน หากคุณใช้ฟังก์ชันเฉพาะบางอย่างใน getters และ setters ฉันคิดว่ามันคุ้มที่จะทดสอบ หากพวกเขากำหนดเฉพาะค่าให้กับฟิลด์ส่วนตัวบางช่องไม่ต้องกังวล

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

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

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

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

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

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

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

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

อีกคำตอบที่เป็นที่ยอมรับ สิ่งนี้ฉันเชื่อจากรอนเจฟฟรีส์:

ทดสอบเฉพาะโค้ดที่คุณต้องการใช้งาน

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

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

รหัสที่ไม่สำคัญจริงๆเช่น getters และ setters ที่ไม่มีพฤติกรรมพิเศษไปกว่าการตั้งค่าฟิลด์ส่วนตัวนั้นเกินความจำเป็นในการทดสอบ ใน 3.0 C # ยังมีน้ำตาลวากยสัมพันธ์ที่คอมไพเลอร์ดูแลฟิลด์ส่วนตัวดังนั้นคุณจึงไม่ต้องตั้งโปรแกรมนั้น

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

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

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

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

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

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

ในลำดับชั้นการสืบทอดตรวจสอบให้แน่ใจว่าได้ทดสอบการปฏิบัติตามLSP

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

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

คำตอบที่ยอมรับคือ "ทดสอบอะไรก็ได้ที่อาจแตกได้" หากคุณแน่ใจว่าคุณสมบัติจะไม่แตกอย่าทดสอบ

และเมื่อพบว่ามีบางอย่างเสีย (คุณพบข้อบกพร่อง) แน่นอนว่าคุณต้องทดสอบ เขียนการทดสอบเพื่อสร้างข้อบกพร่องซ้ำดูว่าล้มเหลวจากนั้นแก้ไขข้อบกพร่องจากนั้นดูการทดสอบผ่าน

ในขณะที่ฉันเข้าใจการทดสอบหน่วยในบริบทของการพัฒนาแบบว่องไว Mike ใช่แล้วคุณต้องทดสอบ getters และ setters (สมมติว่าจะเปิดเผยต่อสาธารณะ) แนวคิดทั้งการทดสอบหน่วยคือการทดสอบหน่วยซอฟต์แวร์ซึ่งเป็นชั้นในกรณีนี้เป็นกล่องสีดำ เนื่องจาก getters และ setters สามารถมองเห็นได้จากภายนอกคุณจึงต้องทดสอบพร้อมกับ Authenticate and Save

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

ฉันจะทดสอบ getters และ setters ของคุณ ขึ้นอยู่กับว่าใครเป็นคนเขียนโค้ดบางคนเปลี่ยนความหมายของวิธี getter / setter ฉันเคยเห็นการเริ่มต้นตัวแปรและการตรวจสอบความถูกต้องอื่น ๆ เป็นส่วนหนึ่งของเมธอด getter ในการทดสอบสิ่งนี้คุณต้องการทดสอบหน่วยที่ครอบคลุมรหัสนั้นอย่างชัดเจน

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

โดยส่วนตัวแล้วฉันใช้Moqเป็นกรอบวัตถุจำลองจากนั้นตรวจสอบว่าวัตถุของฉันเรียกวัตถุรอบข้างอย่างที่ควรจะเป็น

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

ในกรณีของจำนวนเต็มธรรมดาที่ใช้ด้วย - จะเกิดอะไรขึ้นถ้าคุณผ่าน long แทนที่จะเป็นจำนวนเต็ม? นั่นคือเหตุผลที่คุณเขียน UT เพื่อ :)

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

คุณควรทดสอบ "ทุกบล็อกโค้ดที่ไม่สำคัญ" โดยใช้การทดสอบหน่วยเท่าที่จะทำได้

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

เมธอด Authenticate () และ Save () ของคุณดูเหมือนผู้สมัครที่ดีสำหรับการทดสอบ

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

การเขียนแบบทดสอบหลังจากนั้นเจ็บปวดกว่ามาก แต่ก็ทำได้

นี่คือสิ่งที่ฉันทำในตำแหน่งของคุณ:

1. เขียนชุดการทดสอบพื้นฐานที่ทดสอบฟังก์ชันหลัก
2. รับ NCover และรันในการทดสอบของคุณ ความครอบคลุมการทดสอบของคุณอาจอยู่ที่ประมาณ 50% ณ จุดนี้
3. เพิ่มการทดสอบที่ครอบคลุมขอบเคสของคุณต่อไปจนกว่าคุณจะครอบคลุมประมาณ 80% -90%

สิ่งนี้ควรให้ชุดการทดสอบหน่วยที่ใช้งานได้ดีซึ่งจะทำหน้าที่เป็นบัฟเฟอร์ที่ดีในการต่อต้านการถดถอย

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

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

อย่าทดสอบโค้ดที่ใช้งานได้ (สำเร็จรูป) อย่างชัดเจน ดังนั้นหาก setters และ getters ของคุณเป็นเพียง "propertyvalue = value" และ "return propertyvalue" ก็ไม่มีเหตุผลที่จะทดสอบ

แม้แต่ get / set ก็อาจมีผลแปลก ๆ ขึ้นอยู่กับวิธีการใช้งานดังนั้นจึงควรถือเป็นวิธีการ

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

คุณต้องระวัง gotchas ด้านความปลอดภัยเช่น SQL injection ตัวอย่างและทดสอบสิ่งเหล่านี้

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

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

ฉันจะเขียนแบบทดสอบสำหรับทุกสิ่งที่คุณกำลังเขียนโค้ดซึ่งสามารถทดสอบได้นอกอินเทอร์เฟซ GUI

โดยปกติตรรกะใด ๆ ที่ฉันเขียนว่ามีตรรกะทางธุรกิจใด ๆ ที่ฉันวางไว้ในชั้นอื่นหรือชั้นตรรกะทางธุรกิจ

จากนั้นการทดสอบการเขียนสำหรับสิ่งที่ทำบางสิ่งก็ทำได้ง่าย

ขั้นแรกให้เขียนการทดสอบหน่วยสำหรับแต่ละวิธีสาธารณะใน "Business Logic Layer" ของคุณ

ถ้าฉันมีชั้นเรียนเช่นนี้:

   public class AccountService
    {
        public void DebitAccount(int accountNumber, double amount)
        {

        }

        public void CreditAccount(int accountNumber, double amount)
        {

        }

        public void CloseAccount(int accountNumber)
        {

        }
    }

สิ่งแรกที่ฉันจะทำก่อนที่จะเขียนโค้ดใด ๆ ที่รู้ว่าฉันมีการดำเนินการเหล่านี้คือการเริ่มเขียนการทดสอบหน่วย

   [TestFixture]
    public class AccountServiceTests
    {
        [Test]
        public void DebitAccountTest()
        {

        }

        [Test]
        public void CreditAccountTest()
        {

        }

        [Test]
        public void CloseAccountTest()
        {

        }
    }

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

มีแนวทางอื่น ๆ อีกมากมายที่คุณสามารถทำได้เช่น Behavoir Driven Development (BDD) ซึ่งเกี่ยวข้องมากกว่าและไม่ใช่จุดเริ่มต้นที่ดีในการเริ่มต้นด้วยทักษะการทดสอบหน่วยของคุณ

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

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

ฉันแนะนำTestDriven.NetหรือReSharperเนื่องจากทั้งคู่รวมเข้ากับ Visual Studio ได้อย่างง่ายดาย

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

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

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

รหัสที่มีการทดสอบมากมาย แต่ความครอบคลุมเพียงเล็กน้อยยังไม่ได้รับการทดสอบอย่างดี ที่กล่าวว่ารหัสที่ครอบคลุม 100% แต่ไม่ได้ทดสอบขอบเขตและกรณีข้อผิดพลาดก็ไม่ดีเช่นกัน

คุณต้องการความสมดุลระหว่างความครอบคลุมสูง (ขั้นต่ำ 90%) และข้อมูลอินพุตตัวแปร

อย่าลืมทดสอบ "ขยะใน"!

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

คุณต้องออกแบบการทดสอบเพื่อให้รายงานความล้มเหลวหรือข้อมูลที่ไม่คาดคิด / ไม่ต้องการอยู่เสมอ!

ทำให้โค้ดของเราดีขึ้น ... งวด!

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

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

เพื่อช่วยสื่อสารแนวคิดนี้ได้ดีขึ้นสิ่งต่อไปนี้อาจเป็นประโยชน์ในการอ่าน:

ทฤษฎีข้อบกพร่องของการทดสอบหน่วยการพัฒนาซอฟต์แวร์ตามวัตถุประสงค์

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