Java 如何通过委托EasyMockRule或EasyMockRunner使用EasyMockSupport？

通过委托（而不是继承）使用

EasyMockSupport

时，是否可以同时利用和（或）

换句话说：如何使

EasyMockSupport

意识到由

EasyMockRule

创建的模拟

以下是一个MWE演示我面临的问题：

//测试中的类
公共类MyClass{
私人合作者；
公共MyClass（）{
协作者=新协作者（）；
}
//测试中的方法
公共int-myMethod（）{
返回collaborator.mockedMethod（）+1；
}
}
//要嘲笑的类
公共类合作者{
公共int-mockedMethod（）{
返回1；
}
}
//测试用例
公共类MyClassTest{
私有EasyMockSupport EasyMockSupport=新EasyMockSupport（）；
@规则公共EasyMockRule EasyMockRule=新EasyMockRule（此）；
@TestSubject私有MyClass TestSubject=新MyClass（）；
@模拟私人合作者collaboratorMock；
@测试公共void testMyMethod（）{
expect（collaboratorMock.mockedMethod（））.andReturn（2）；
easyMockSupport.Replayal（）；
int result=testSubject.myMethod（）；
Assert.assertEquals（“成功模拟时应返回2+1”，3，结果）；
//抛出java.lang.AssertionError:应为：但为：
}
}

测试失败，而如果

MyClassTest

extends

EasyMockSupport

，则测试通过。（但我不能将继承用于我正在做的事情，因此我提出了问题。）

我对这种行为的理解是，在我的示例中，

EasyMockSupport

不知道

协作者

mock，因此调用

replayAll（）

无效，在

testSubject.myMethod（）

中调用时，mock仍处于记录状态（因此

mockedMethod（）

返回0）。 事实上，他说：

如果该参数扩展了EasyMockSupport，则将使用该参数创建模拟，以允许replayAll/verifyAll随后工作

但是当使用委托时，参数（即测试类）不会扩展

EasyMockSupport

。有什么我遗漏了还是不可能

旁注：我正在使用EasyMock 3.6。理想情况下，我希望找到一个保持该版本的解决方案，但请随时指出在以后的版本中是否有相关的功能/错误修复

---

提前感谢您的帮助

不容易。然而，这是一个有用的用例，所以我建议您填写一个

同时，我们需要让规则意识到EasyMocksSupport。这里有一个解决方案

import org.easymock.EasyMock;
import org.easymock.EasyMockRule;
import org.easymock.EasyMockSupport;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.easymock.internal.MocksControl;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;

import java.lang.reflect.Field;

// Class under test
class MyClass {
    private Collaborator collaborator;
    public MyClass() {
        collaborator = new Collaborator();
    }

    // Method under test
    public int myMethod() {
        return collaborator.mockedMethod() + 1;
    }
}

// Class to be mocked
class Collaborator {
    public int mockedMethod() {
        return 1;
    }
}

class ExtendedEasyMockSupport extends EasyMockSupport {
    public void addMock(Object mock) {
        if(EasyMockSupport.getMockedClass(mock) == null)  {
            throw new IllegalArgumentException(mock + " is not a mock");
        }
        MocksControl control = MocksControl.getControl(mock);
        controls.add(control);
    }

    public void addAllMocks(Object testClass) {
        Field[] fields = testClass.getClass().getDeclaredFields();
        for (Field field : fields) {
            Mock annotation = field.getAnnotation(Mock.class);
            if(annotation != null) {
                field.setAccessible(true);
                Object mock;
                try {
                    mock = field.get(testClass);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
                addMock(mock);
            }
        }
    }
}

// Test case
public class MyClassTest {
    private final ExtendedEasyMockSupport easyMockSupport = new ExtendedEasyMockSupport();
    @Rule
    public EasyMockRule easyMockRule = new EasyMockRule(this);

    @TestSubject
    private final MyClass testSubject = new MyClass();

    @Mock
    private Collaborator collaboratorMock;

    @Before
    public void before() {
        easyMockSupport.addAllMocks(this);
    }

    @Test
    public void testMyMethod() {
        EasyMock.expect(collaboratorMock.mockedMethod()).andReturn(2);
        easyMockSupport.replayAll();

        int result = testSubject.myMethod();
        Assert.assertEquals("Should return 2+1 when successfully mocked", 3, result);
        // throws java.lang.AssertionError: expected: <3> but was: <1>
    }
}

import org.easymock.easymock；
导入org.easymock.EasyMockRule；
导入org.easymock.EasyMockSupport；
导入org.easymock.Mock；
导入org.easymock.TestSubject；
导入org.easymock.internal.mocks控件；
导入org.junit.Assert；
导入org.junit.Before；
导入org.junit.Rule；
导入org.junit.Test；
导入java.lang.reflect.Field；
//正在测试的类
类MyClass{
私人合作者；
公共MyClass（）{
协作者=新协作者（）；
}
//测试中的方法
公共int-myMethod（）{
返回collaborator.mockedMethod（）+1；
}
}
//要嘲笑的类
类协作者{
公共int-mockedMethod（）{
返回1；
}
}
类ExtendedEasyMockSupport扩展EasyMockSupport{
公共void addMock（对象模拟）{
if（EasyMockSupport.getMockedClass（mock）==null）{
抛出新的IllegalArgumentException（mock+“不是mock”）；
}
MocksControl-control=MocksControl.getControl（mock）；
控件。添加（控件）；
}
public void addallmock（对象测试类）{
Field[]fields=testClass.getClass（）.getDeclaredFields（）；
用于（字段：字段）{
Mock annotation=field.getAnnotation（Mock.class）；
if（注释！=null）{
字段。setAccessible（true）；
对象模拟；
试一试{
mock=field.get（testClass）；
}捕获（非法访问例外e）{
抛出新的运行时异常（e）；
}
addMock（mock）；
}
}
}
}
//测试用例
公共类MyClassTest{
private final ExtendedEasyMockSupport easyMockSupport=新的ExtendedEasyMockSupport（）；
@统治
public EasyMockRule EasyMockRule=新EasyMockRule（此）；
@测试对象
私有最终MyClass testSubject=新MyClass（）；
@嘲弄
私人合作方collaboratorMock；
@以前
在（）之前公开无效{
easyMockSupport.addAllMocks（此）；
}
@试验
公共void testMyMethod（）{
expect（collaboratorMock.mockedMethod（））.andReturn（2）；
easyMockSupport.Replayal（）；
int result=testSubject.myMethod（）；
Assert.assertEquals（“成功模拟时应返回2+1”，3，结果）；
//抛出java.lang.AssertionError:应为：但为：
}
}

非常感谢！在EasyMock提供支持之前，我将使用您的解决方案。：）顺便说一句，我填了。