เยาะเย้ยวิธีการขยายด้วยขั้นต่ำ

ฉันมีส่วนต่อประสานก่อนหน้า ...

public interface ISomeInterface
{
    void SomeMethod();
}

และฉันได้ขยายอินเทอร์เฟซนี้โดยใช้มิกซ์อิน ...

public static class SomeInterfaceExtensions
{
    public static void AnotherMethod(this ISomeInterface someInterface)
    {
        // Implementation here
    }
}

ฉันมีคลาสที่เรียกสิ่งนี้ซึ่งฉันต้องการทดสอบ ...

public class Caller
{
    private readonly ISomeInterface someInterface;

    public Caller(ISomeInterface someInterface)
    {
        this.someInterface = someInterface;
    }

    public void Main()
    {
        someInterface.AnotherMethod();
    }
}

และการทดสอบที่ฉันต้องการจำลองอินเทอร์เฟซและยืนยันการโทรไปยังวิธีการขยาย ...

    [Test]
    public void Main_BasicCall_CallsAnotherMethod()
    {
        // Arrange
        var someInterfaceMock = new Mock<ISomeInterface>();
        someInterfaceMock.Setup(x => x.AnotherMethod()).Verifiable();

        var caller = new Caller(someInterfaceMock.Object);

        // Act
        caller.Main();

        // Assert
        someInterfaceMock.Verify();
    }

การเรียกใช้การทดสอบนี้จะสร้างข้อยกเว้น ...

System.ArgumentException: Invalid setup on a non-member method:
x => x.AnotherMethod()

คำถามของฉันคือมีวิธีที่ดีในการเยาะเย้ยโทร mixin?

คุณไม่สามารถ "คงที่" จำลองวิธีแบบคงที่ (ดังนั้นวิธีการขยาย) ด้วยกรอบการเยาะเย้ย คุณสามารถลองใช้โมล ( http://research.microsoft.com/en-us/projects/pex/downloads.aspx ) ซึ่งเป็นเครื่องมือฟรีจาก Microsoft ที่ใช้วิธีการที่แตกต่างกัน นี่คือคำอธิบายของเครื่องมือ:

โมลเป็นเฟรมเวิร์กที่มีน้ำหนักเบาสำหรับการทดสอบสตับและการออกนอกเส้นทางใน. NET ซึ่งขึ้นอยู่กับผู้รับมอบสิทธิ์

โมลอาจถูกใช้เพื่ออ้อมใด ๆ วิธี. NET รวมถึงวิธีการที่ไม่ใช่เสมือน / คงที่ในประเภทที่ปิดผนึก

คุณสามารถใช้โมลกับกรอบการทดสอบใด ๆ (เป็นอิสระเกี่ยวกับเรื่องนั้น)

ฉันใช้ Wrapper เพื่อแก้ไขปัญหานี้ สร้างวัตถุห่อหุ้มและผ่านวิธีการเยาะเย้ยของคุณ

ดูการเยาะเย้ยวิธีการคงที่สำหรับการทดสอบหน่วยโดย Paul Irwin มันมีตัวอย่างที่ดี

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

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

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

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

การใช้งาน mock ของคุณสามารถเรียกใช้วิธีการใดก็ได้ที่คุณต้องการหรือเพียงตรวจสอบว่าวิธีการนั้นเรียกว่า:

IReal //on which some extension method is defined
{
    ... SomeRegularMethod(...);
}

static ExtensionsForIReal
{
    static ... SomeExtensionMethod(this IReal iReal,...);
}

ITest: IReal
{
    //This is a regular method with same name and signature as the extension without the "this IReal iReal" parameter
    ... SomeExtensionMethod(...);
}

var someMock = new Mock<ITest>();
Mock.As<IReal>(); //ad IReal to the mock
someMock.Setup(x => x.SomeExtensionMethod(...)).Verifiable(); //Calls SomeExtensionMethod on ITest
someMock.As<IReal>().Setup(x => x.SomeRegularMethod(...)).Verifiable(); //Calls SomeRegularMethod on IReal

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

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

public static string Echo(this Foo foo, string strValue) 
{ 
    return strValue; 
}

ในการจัดเรียงและตรวจสอบวิธีการนี้ให้ใช้สิ่งต่อไปนี้:

string expected = "World";

var foo = new Foo();
Mock.Arrange(() => foo.Echo(Arg.IsAny<string>())).Returns(expected);

string result = foo.Echo("Hello");

Assert.AreEqual(expected, result);

นี่คือลิงค์ไปยังเอกสารประกอบ: ส่วนขยายวิธีการเยาะเย้ย

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

ฉันใช้คุณสมบัติ Lazy Injectable ภายในของทั้งประเภท Action, Func, Predicate หรือผู้รับมอบสิทธิ์และอนุญาตให้มีการฉีด (สลับออก) วิธีการระหว่างการทดสอบหน่วย

    internal Func<IMyObject, string, object> DoWorkMethod
    {
        [ExcludeFromCodeCoverage]
        get { return _DoWorkMethod ?? (_DoWorkMethod = (obj, val) => { return obj.DoWork(val); }); }
        set { _DoWorkMethod = value; }
    } private Func<IMyObject, string, object> _DoWorkMethod;

จากนั้นคุณเรียก Func แทนวิธีการที่เกิดขึ้นจริง

    public object SomeFunction()
    {
        var val = "doesn't matter for this example";
        return DoWorkMethod.Invoke(MyObjectProperty, val);
    }

สำหรับตัวอย่างที่สมบูรณ์ยิ่งขึ้นลองดูhttp://www.rhyous.com/2016/08/11/unit-testing-calls-to-complex-extension-methods/

ดังนั้นหากคุณกำลังใช้ Moq และต้องการที่จะเยาะเย้ยผลลัพธ์ของวิธีการส่วนขยายจากนั้นคุณสามารถใช้ SetupReturnsDefault<ReturnTypeOfExtensionMethod>(new ConcreteInstanceToReturn())กับอินสแตนซ์ของคลาสจำลองที่มีวิธีการขยายที่คุณพยายามที่จะจำลอง

มันไม่สมบูรณ์แบบ แต่สำหรับวัตถุประสงค์การทดสอบหน่วยมันทำงานได้ดี