ความแตกต่างระหว่างการกำหนดเมื่อถึงตอนนั้น (GWT) และ Arrange Act Assert (AAA)?

ใน TDD มีไวยากรณ์จัดเรียง Assert (AAA):

[Test]
public void Test_ReturnItemForRefund_ReturnsStockOfBlackSweatersAsTwo_WhenOneInStockAndOneIsReturned()
{
    //Arrange
    ShopStock shopStock = new ShopStock();
    Item blackSweater = new Item("ID: 25");
    shopStock.AddStock(blackSweater);
    int expectedResult = 2;
    Item blackSweaterToReturn = new Item("ID: 25");

    //Act
    shopStock.ReturnItemForRefund(blackSweaterToReturn);
    int actualResult = shopStock.GetStock("ID: 25");

    //Assert
    Assert.AreEqual(expectedResult, actualResult);
}

ในการทดสอบการเขียน BDD ใช้โครงสร้างที่คล้ายกัน แต่มีไวยากรณ์เมื่อเมื่อ (GWT):

    [Given(@"a customer previously bought a black sweater from me")]
    public void GivenACustomerPreviouslyBoughtABlackSweaterFromMe()
    { /* Code goes here */   }

    [Given(@"I currently have three black sweaters left in stock")]
    public void GivenICurrentlyHaveThreeBlackSweatersLeftInStock()
    { /* Code goes here */   }

    [When(@"he returns the sweater for a refund")]
    public void WhenHeReturnsTheSweaterForARefund()
    { /* Code goes here */   }

    [Then(@"I should have four black sweaters in stock")]
    public void ThenIShouldHaveFourBlackSweatersInStock()
    { /* Code goes here */   }

แม้ว่าพวกเขามักจะถือว่าเหมือนกันมีความแตกต่าง กุญแจสำคัญไม่กี่:

1. GWT สามารถแมปโดยตรงกับข้อมูลจำเพาะของไฟล์คุณสมบัติในกรอบงานของ BDD

2. GWT ง่ายขึ้นสำหรับผู้ที่ไม่ใช่นักพัฒนาที่จะเข้าใจโดยการส่งเสริมการใช้ภาษาอังกฤษธรรมดาและมีคำอธิบายสั้น ๆ ว่าแต่ละส่วนทำอะไร

3. ได้รับเมื่อและจากนั้นเป็นคำหลักในกรอบ BDD ต่างๆเช่น SpecFlow และแตงกวา

คำถามของฉันมีความแตกต่างอื่น ๆ (นอกเหนือจากชื่อ) ระหว่าง AAA และ GWT หรือไม่? และมีเหตุผลใดนอกเหนือจากที่ระบุไว้ข้างต้นว่าควรจะชอบมากกว่าที่อื่น ๆ ?

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

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

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

• ข้อกำหนดระดับผู้ใช้: เนื่องจากคลังสินค้ามีอย่างน้อย N รายการ (s) ในสินค้าคงคลังเมื่อผู้ใช้ซื้อสินค้า N รายการจากนั้นคลังสินค้าจัดส่งสินค้า N รายการไปยังผู้ใช้
• ข้อกำหนดระดับระบบ 1: กำหนดระบบสินค้าคงคลังมี N รายการ (s) ในสินค้าคงคลังเมื่อการร้องขอสำหรับ N รายการจะถูกป้อนเข้าสู่ระบบสินค้าคงคลังแล้วระบบสินค้าคงคลังลดลงนับสินค้าคงคลังสำหรับประเภทของรายการนั้น
• ข้อกำหนดระดับระบบ 2: เมื่อระบบการชำระเงินมีรายการ N รายการในสินค้าคงคลังเมื่อมีการป้อนรายการคำขอ N รายการลงในระบบการชำระเงินระบบชำระเงินจะเรียกเก็บเงินจากผู้ใช้สำหรับรายการ N รายการ
• ...
• ข้อกำหนดระดับโปรแกรมเมอร์ 1: กำหนดเสื้อสเวตเตอร์ 5 ตัวในสินค้าคงคลังเมื่อถอดเสื้อสเวตเตอร์ 3 ตัวออกจากสต็อกแล้ว 2 ที่นั่งเหลืออยู่ในสินค้าคงคลัง
• ...

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

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

public void Test_CaseWhereThereAreEnoughSweatersLeft() {
    // Arrange
    // setup Sweater Inventory mock (DB mocks, etc)
    // count = 5
    // when The number of sweaters remaining is request, return count
    // when Inventory is requested to remove N items, then count = count - N

    // Act
    // call the Unit Under Test to remove 3 items from inventory

    // Assert
    // the number of sweaters in the inventory is 2
    // the removal should return indicating a successful removal of items from the inventory
}

public void Test_CaseWhereThereAreNotEnoughSweatersLeft() {
    // Arrange
    // setup Sweater Inventory mock (DB mocks, etc)
    // count = 2
    // when The number of sweaters remaining is request, return count
    // when Inventory is requested to remove N items, then count = count - N

    // Act
    // call the Unit Under Test to remove 3 items from inventory

    // Assert
    // the number of sweaters remaining is still 2
    // the removal should return an error indicating not enough items in the inventory
}

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

ไม่มีความแตกต่างเลย
สามสถานะของการทดสอบ:
กำหนด = จัดเรียง
เมื่อ = ทำ
แล้ว = ยืนยัน

ความแตกต่างที่คุณระบุไว้ในคำถามคือความแตกต่างระหว่าง TDD และ BDD ไม่ใช่ GWT และ AAA

ใน TDD คุณสามารถมีสามวิธีที่แตกต่างกันสำหรับการทดสอบเดียว

public class TestsOfFormatMethod
{        
    public void Arrange() { // set dependencies }
    public string Act() { // return formattted result }
    public string AssertThatFormatIsEmpty()
    {
        Arrange();
        var actual = Act();
        Assert.IsEmpty(actual);
    }
}