文章/答案/技术大牛

发布

社区首页 >问答首页 >如何用Spring4D模拟DUnit事件

问如何用Spring4D模拟DUnit事件
EN

Stack Overflow用户

提问于 2015-05-20 12:01:16

回答 1查看 558关注 0票数 2

我正努力用DUnit成功地模拟一个DUnit事件。

事实上，我更多的是在嘲弄一个模拟事件.

这是基本结构。

TMyObject --EventContainer--> TMock<IEventContainer> --Event--> TMock<IEvent>

TMyObject有一个属性EventContainer : IEventContainer

IEventContainer有一个属性事件: IMyEvent

我想嘲笑

MyObject.EventContainer.Event.Add

我测试了我能想到的每一种可能性。我要么得到AVs要么无效的转换。我已经把源代码放在下面了。如果有人能帮我完成这个任务，那就太棒了！

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
    System.SysUtils,
    DUnitTestRunner,
    Spring.Events,
    Spring,
    Classes,
    TestFramework,
    Delphi.Mocks;
    //Unit1 in 'Unit1.pas';

type

{$M+}
    IMyEvent = interface(IEvent<TNotifyEvent>)
        procedure Add(const handler: TMethod);
    end;
{$M-}
{$M+}

    IMyEventMock = interface(IMyEvent)
        procedure Add(const handler: TMethod);
    end;
{$M-}
{$M+}

    IEventContainer = interface(IInterface)
        function GetEvent: IMyEvent;
        procedure SetEvent(const Value: IMyEvent);
        property Event: IMyEvent
            read GetEvent
            write SetEvent;
    end;
{$M-}
{$M+}

    ITestEventContainer = interface(IEventContainer)
        function GetEvent: TMock<IMyEvent>;
        procedure SetEvent(const Value: TMock<IMyEvent>);
        property Event: TMock<IMyEvent>
            read GetEvent
            write SetEvent;
    end;
{$M-}
{$REGION 'TEventContainer'}

    TEventContainer = class(TInterfacedObject, IEventContainer)

    private
        FAEvent: IMyEvent;
        function GetEvent: IMyEvent;
        procedure SetEvent(const Value: IMyEvent);

    public
        property Event: IMyEvent
            read GetEvent
            write SetEvent;
    end;

{$ENDREGION}
{$REGION 'TMyObject'}

    TMyObject = class(TObject)
    private
        FEventContainer: IEventContainer;
        function GetEventContainer: IEventContainer;
        procedure SetEventContainer(const Value: IEventContainer);

    public
        property EventContainer: IEventContainer
            read GetEventContainer
            write SetEventContainer;
    end;

{$ENDREGION}
{$REGION 'TMyObjectTest'}

    TMyObjectTest = class(TTestCase)
    strict private
        FMyObject: TMyObject;
        FMyEventContainerMock: TMock<IEventContainer>;
        FMyTestEventContainerMock: TMock<ITestEventContainer>;
        FEventMock: TMock<IMyEventMock>;

    public
        procedure SetUp; override;
        procedure TearDown; override;

    published
        procedure Test_InstanceAsValue;
        procedure Test_Value_Make;
        procedure Test_Value_From;
        procedure Test_Value_From_Instance;
        procedure Test_Value_From_Variant;
        procedure Test_Value_From_Variant_Instance;
        procedure Test_Mocked_Container_Value_Make;
        procedure Test_Mocked_Container_Value_From;
        procedure Test_Mocked_Container_Value_From_Instance;
        procedure Test_Mocked_Container_Value_From_Variant;
        procedure Test_Mocked_Container_Value_From_Variant_Instance;
    end;
{$ENDREGION}


{$REGION 'TEventContainer'}

function TEventContainer.GetEvent: IMyEvent;
begin
    Result := FAEvent;
end;

procedure TEventContainer.SetEvent(const Value: IMyEvent);
begin
    FAEvent := Value;
end;
{$ENDREGION}

{$REGION 'TMyObject'}

function TMyObject.GetEventContainer: IEventContainer;
begin
    Result := FEventContainer;
end;

procedure TMyObject.SetEventContainer(const Value: IEventContainer);
begin
    FEventContainer := Value;
end;
{$ENDREGION}

{$REGION 'TMyObjectTest'}

procedure TMyObjectTest.SetUp;
begin
    inherited;

    FMyObject := TMyObject.Create;

    FMyEventContainerMock := TMock<IEventContainer>.Create;

    FMyObject.EventContainer := FMyEventContainerMock;

end;

procedure TMyObjectTest.TearDown;
begin
    inherited;

    FMyObject.Free;

    FMyObject := nil;
end;

procedure TMyObjectTest.Test_Value_Make;
var aValue : TValue;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    TValue.Make(@FEventMock, TypeInfo(IMyEventMock), aValue);

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', aValue);

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_InstanceAsValue;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', FEventMock.InstanceAsValue);

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Mocked_Container_Value_From;
begin

    FMyTestEventContainerMock := TMock<ITestEventContainer>.Create;

    FMyObject.EventContainer := FMyTestEventContainerMock;

    FEventMock := TMock<IMyEventMock>.Create;

    FMyTestEventContainerMock.SetUp.WillReturnDefault('GetEvent', FEventMock.InstanceAsValue);

    FMyObject.EventContainer.Event;

end;

procedure TMyObjectTest.Test_Mocked_Container_Value_From_Instance;
begin
FMyTestEventContainerMock := TMock<ITestEventContainer>.Create;

    FMyObject.EventContainer := FMyTestEventContainerMock;

    FEventMock := TMock<IMyEventMock>.Create;

    FMyTestEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.From(FEventMock));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Mocked_Container_Value_From_Variant;
begin
    FMyTestEventContainerMock := TMock<ITestEventContainer>.Create;

    FMyObject.EventContainer := FMyTestEventContainerMock;

    FEventMock := TMock<IMyEventMock>.Create;

    FMyTestEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.FromVariant(FEventMock));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Mocked_Container_Value_From_Variant_Instance;
begin
    FMyTestEventContainerMock := TMock<ITestEventContainer>.Create;

    FMyObject.EventContainer := FMyTestEventContainerMock;

    FEventMock := TMock<IMyEventMock>.Create;

    FMyTestEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.FromVariant(FEventMock.Instance));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Mocked_Container_Value_Make;
var aValue : TValue;
begin
    FMyTestEventContainerMock := TMock<ITestEventContainer>.Create;

    FMyObject.EventContainer := FMyTestEventContainerMock;

    FEventMock := TMock<IMyEventMock>.Create;

    TValue.Make(@aValue, TypeInfo(TMock<IMyEventMock>), aValue);

    FMyTestEventContainerMock.SetUp.WillReturnDefault('GetEvent', aValue);

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Value_From;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.From(FEventMock));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Value_From_Instance;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.From(FEventMock.Instance));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Value_From_Variant;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.FromVariant(FEventMock));

    FMyObject.EventContainer.Event;
end;

procedure TMyObjectTest.Test_Value_From_Variant_Instance;
begin
    FEventMock := TMock<IMyEventMock>.Create;

    FMyEventContainerMock.SetUp.WillReturnDefault('GetEvent', TValue.FromVariant(FEventMock.Instance));

    FMyObject.EventContainer.Event;
end;

begin
    RegisterTest(TMyObjectTest.Suite);
    try
        DUnitTestRunner.RunRegisteredTests;
        ReadLn;
    except
        on E: Exception do
        begin
            Writeln(E.ClassName, ': ', E.Message);
            ReadLn;
        end;
    end;

end.

spring4d

unit-testing

delphi

dunit

回答 1

Stack Overflow用户

回答已采纳

发布于 2015-05-20 13:31:08

首先，你的做法是错误的。继承一个接口，然后添加{$M+}，将只包含从那里添加的方法的方法信息。这意味着，即使添加了与父接口具有相同签名的方法，也无法使模拟工作，因为代码仍然将调用父接口方法，而不是您添加的方法。

此外，在本例中，DelphiMocks是将接口转换为父类型的TValue错误的受害者。这只是不支持-参见Rtti.ConvIntf2Intf。

我建议使用从Spring4D继承的IEvent来编译IInvokable，以获取方法信息，并避免从其中继承。

如果这样做，下面的测试就会通过--所有其他测试都只是通过了模拟错误：

Test_InstanceAsValue;
Test_Value_From_Instance;
Test_Mocked_Container_Value_From;

在Spring4D 1.2中，我们引入了一个新的拦截库，该库也用于我们的模拟解决方案。此外，容器将能够提供自动锁定。所以你可以这样写你的测试：

var
  container: TContainer;
  event: IMyEvent;
begin
  container := TContainer.Create;
  container.AddExtension<TAutoMockExtension>;
  try
    FMyObject.EventContainer := container.Resolve<ITestEventContainer>;

    event := FMyObject.EventContainer.Event;
    event.Add(nil);
  finally
    container.Free;
  end;
end;

容器将为它需要解析的、它不知道的任何类型创建模拟。在这个测试中，您可以注册要测试的类，并且容器会自动将任何依赖项注入模拟。

var
  container: TContainer;
  event: IMyEvent;
begin
  container := TContainer.Create;
  container.AddExtension<TAutoMockExtension>;
  container.RegisterType<TMyObject>.InjectProperty('EventContainer');
  container.Build;
  try
    FMyObject := container.Resolve<TMyObject>;

    event := FMyObject.EventContainer.Event;
    event.Add(nil);
  finally
    container.Free;
  end;
end;

您还可以更进一步地将自动模拟容器集成到一个基本的testcase类中：

program Project2;

{$APPTYPE CONSOLE}

uses
  Classes,
  SysUtils,
  DUnitTestRunner,
  TestFramework,
  Spring.Events,
  Spring,
  Spring.Container,
  Spring.Container.Registration,
  Spring.Container.AutoMockExtension,
  Spring.Mocking;

type
  IMyEvent = IEvent<TNotifyEvent>;

  IEventContainer = interface(IInvokable)
    function GetEvent: IMyEvent;
    procedure SetEvent(const Value: IMyEvent);
    property Event: IMyEvent read GetEvent write SetEvent;
  end;

  TMyObject = class(TObject)
  private
    FEventContainer: IEventContainer;
  public
    property EventContainer: IEventContainer read FEventContainer write FEventContainer;
  end;

  TAutoMockingTestCase<T: class> = class(TTestCase)
  protected
    fContainer: TContainer;
    fSUT: T;
    procedure SetUp; overload; override;
    procedure TearDown; override;
    procedure SetUp(const registration: TRegistration<T>); reintroduce; overload; virtual;
  end;

  TMyTest = class(TAutoMockingTestCase<TMyObject>)
  protected
    procedure SetUp(const registration: TRegistration<TMyObject>); override;
  published
    procedure Test_EventAdd;
  end;

procedure TAutoMockingTestCase<T>.SetUp(const registration: TRegistration<T>);
begin
end;

procedure TAutoMockingTestCase<T>.SetUp;
begin
  inherited;
  fContainer := TContainer.Create;
  fContainer.AddExtension<TAutoMockExtension>;
  SetUp(fContainer.RegisterType<T>);
  fContainer.Build;
  fSUT := fContainer.Resolve<T>;
end;

procedure TAutoMockingTestCase<T>.TearDown;
begin
  fSUT.Free;
  fContainer.Free;
  inherited;
end;

procedure TMyTest.SetUp(const registration: TRegistration<TMyObject>);
begin
  registration.InjectProperty('EventContainer');
end;

procedure TMyTest.Test_EventAdd;
begin
  fSUT.EventContainer.Event.Add(nil);
end;

begin
  RegisterTest(TMyTest.Suite);
  try
    DUnitTestRunner.RunRegisteredTests;
    ReadLn;
  except
    on E: Exception do
    begin
      Writeln(E.ClassName, ': ', E.Message);
      ReadLn;
    end;
  end;
end.

票数 6

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/30349058

复制

相似问题

问如何用Spring4D模拟DUnit事件
EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何用Spring4D模拟DUnit事件EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何用Spring4D模拟DUnit事件
EN