标签: jmock

我坐下来,今天写一个匹配,并决定采取快速查找在JMock的文档刷新我对进程的内存,并注意到在org.hamcrest.Factory注释的参考.注释的文档说明.

标记Hamcrest静态工厂方法,以便工具识别它们.工厂方法等同于命名构造函数.

是否有任何工具实际使用此注释？

我正在编写类似TotalCommander的应用程序.我有一个单独的文件列表组件,以及它的模型.模型支持侦听器并CurrentDirChanged以下列方式发出诸如此类事件的通知:

private void fireCurrentDirectoryChanged(final IFile dir) {
    if (SwingUtilities.isEventDispatchThread())
        for (FileTableEventsListener listener : tableListeners)
            listener.currentDirectoryChanged(dir);
    else {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                for (FileTableEventsListener listener : tableListeners)
                    listener.currentDirectoryChanged(dir);
            }
        });
    }
}

我为此写了一个简单的测试:

@Test
public void testEvents() throws IOException {
    IFile testDir = mockDirectoryStructure();
    final FileSystemEventsListener listener = 
                context.mock(FileSystemEventsListener.class);
    context.checking(new Expectations() {{
        oneOf(listener).currentDirectoryChanged(with(any(IFile.class)));
    }});

    FileTableModel model = new FileTableModel(testDir);
    model.switchToInnerDirectory(1);
}

这不起作用,因为没有EventDispatchThread.有没有办法在无头构建中进行单元测试？

单元测试java swing jmock

我有一个看起来像的测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:/test-context.xml"})
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
public abstract class TestClass {
  @Rule @Resource public JUnitRuleMockery jMockContext;

  public void test1() {
    //Expectations and test
  }
  public void test2() {
    //Expectations and test
  }
}

在test-context.xml我JUnitRuleMockery通过a 定义加上几个模拟对象factory-method,就像

<bean id="mockContextFactory" class="MockContextFactory" />

<bean id="jMockContext" factory-bean="mockContextFactory" factory-method="getContext" scope="prototype" />

<bean id="firstMock" factory-bean="mockContextFactory" factory-method="getFirstMock" />

<bean id="secondMock" factory-bean="mockContextFactory" factory-method="getSecondMock" />

MockContextFactory 是

public class MockContextFactory
{
  private JUnitRuleMockery jUnitRuleMockery;

  public MockContextFactory() {
    jUnitRuleMockery = new JUnitRuleMockery();
    jUnitRuleMockery.setThreadingPolicy(new …

在JMock中是否有一种已经内置的标准方法来捕获方法参数,以便稍后使用标准JUnit功能测试参数对象？

就像是

final CapturedContainer<SimpleMailMessage>capturedArgumentContainer = new ...
context.checking(new Expectations() {{
    oneOf(emailService.getJavaMailSender()).send(
       with(captureTo(capturedArgumentContainer)));
}});

assertEquals("helloWorld", capturedArgumentContainer.getItem().getBody());

CapturedContainer并且captureTo不存在 - 它们就是我要求的.

或者我需要自己实现这个？

我已经开始使用吉斯做一个项目的一些依赖注入,主要是因为我需要注入嘲笑(使用JMock的目前)层从单元测试,这使得人工注射非常尴尬了.

我的问题是引入模拟的最佳方法是什么？我目前所拥有的是在单元测试中创建一个满足依赖关系的新模块,并将它们绑定到如下所示的提供者:

public class JMockProvider<T> implements Provider<T> {
    private T mock;

    public JMockProvider(T mock) {
        this.mock = mock;
    }

    public T get() {
        return mock;
    }
}

在构造函数中传递mock,因此JMock设置可能如下所示:

    final CommunicationQueue queue = context.mock(CommunicationQueue.class);
    final TransactionRollBack trans = context.mock(TransactionRollBack.class);
    Injector injector = Guice.createInjector(new AbstractModule() {
        @Override
        protected void configure() {
            bind(CommunicationQueue.class).toProvider(new JMockProvider<QuickBooksCommunicationQueue>(queue));
            bind(TransactionRollBack.class).toProvider(new JMockProvider<TransactionRollBack>(trans));
        }
    });
    context.checking(new Expectations() {{
        oneOf(queue).retrieve(with(any(int.class)));
        will(returnValue(null));
        never(trans);
    }});
    injector.getInstance(RunResponse.class).processResponseImpl(-1);

有没有更好的办法？我知道,AtUnit试图解决这个问题,虽然我失去了它是如何自动奇迹般地注入这是本地创建像上面的一个模拟,但是我正在寻找无论是令人信服的理由,AtUnit是正确的答案在这里(其他而不是在不改变测试的情况下改变DI和模拟框架的能力,或者是否有更好的解决方案来手动完成.

我正在努力学习如何编写测试.我也在学习Java,有人告诉我应该学习/使用/练习jMock,我在网上发现了一些有助于某些扩展的文章:

http://www.theserverside.com/news/1365050/Using-JMock-in-Test-Driven-Development

http://jeantessier.com/SoftwareEngineering/Mocking.html#jMock

我发现的大多数文章都是关于测试驱动的开发,首先编写测试然后编写代码以使测试通过.我现在不是在寻找,我正在尝试使用jMock为现有代码编写测试.

该官方文档是模糊,我不说,只是太辛苦了.有没有人有更好的方法来学习这个.好书/链接/教程对我很有帮助.谢谢

编辑 - 更具体的问题:

http://jeantessier.com/SoftwareEngineering/Mocking.html#jMock - 来自这篇文章

试过这个来模拟这个简单的类:

import java.util.Map;
    public class Cache {
        private Map<Integer, String> underlyingStorage;
        public Cache(Map<Integer, String> underlyingStorage) {
            this.underlyingStorage = underlyingStorage;
        }
        public String get(int key) {
            return underlyingStorage.get(key);
        }
        public void add(int key, String value) {
            underlyingStorage.put(key, value);
        }
        public void remove(int key) {
            underlyingStorage.remove(key);
        }
        public int size() {
            return underlyingStorage.size();
        }
        public void clear() {
            underlyingStorage.clear();
        }
    }

以下是我尝试创建测试/模拟的方法:

public class CacheTest extends TestCase {

    private …

我正在尝试为这个类编写一个名为Receiver的测试:

public void get(People person) {
            if(null != person) {
               LOG.info("Person with ID " + person.getId() + " received");
               processor.process(person);
             }else{
              LOG.info("Person not received abort!");   
              }
        }

这是测试:

@Test
    public void testReceivePerson(){
        context.checking(new Expectations() {{          
            receiver.get(person);
            atLeast(1).of(person).getId();
            will(returnValue(String.class));        
        }});
    }

注意:receiver是Receiver类的实例(真的不是mock),processor是处理person(People类的模拟对象)的Processor类(真实不是mock)的实例.GetId是一个String not int方法,不是错误的.

测试失败:person.getId()的意外调用

我正在使用jMock任何帮助将不胜感激.据我所知,当我称这种get方法正确执行时,我需要嘲笑person.getId(),而且我已经在圈子里徘徊了一段时间,现在任何帮助都会受到赞赏.

如何在Android上使用JMock？我几个职位称其不可能的,但肯定有一些办法做到这一点？

问题似乎是让Android甚至能够识别JMock jar文件.那么也许有一个解决方案,将jar放入资产并制作自定义类加载器？这看起来很麻烦,但听起来有点像吗？

我编写了一个转换器类,它接受HttpServletRequest并将其转换为另一种类型,该类型保存来自servlet请求的InputStream指针.(我的想法是从请求处理中抽象出传输传输协议,所以我也可以从FTP编写类似的转换器.)

现在我正在尝试为此编写一个单元测试,我遇到了问题.我已经设法找出正确的样板来创建一个有效的Multipart HTTP请求(使用Spring类MockMultipartHttpServletRequest和MockMultipartFile),但现在我在initialize()我的UploadRequest类的方法中得到一个NullPointerException .我猜测问题是,MockMultipartHttpServletRequest中的流不能正确初始化,但我无法弄清楚我应该做些什么不同.

任何建议都会感激不尽!

这是堆栈跟踪:

java.lang.NullPointerException
    at org.apache.commons.fileupload.MultipartStream$ItemInputStream.makeAvailable(MultipartStream.java:976)
    at org.apache.commons.fileupload.MultipartStream$ItemInputStream.read(MultipartStream.java:886)
    at java.io.InputStream.read(InputStream.java:82)
    at org.apache.commons.fileupload.util.Streams.copy(Streams.java:96)
    at org.apache.commons.fileupload.util.Streams.copy(Streams.java:66)
    at org.apache.commons.fileupload.MultipartStream.readBodyData(MultipartStream.java:592)
    at org.apache.commons.fileupload.MultipartStream.discardBodyData(MultipartStream.java:618)
    at org.apache.commons.fileupload.MultipartStream.skipPreamble(MultipartStream.java:637)
    at org.apache.commons.fileupload.FileUploadBase$FileItemIteratorImpl.findNextItem(FileUploadBase.java:984)
    at org.apache.commons.fileupload.FileUploadBase$FileItemIteratorImpl.<init>(FileUploadBase.java:965)
    at org.apache.commons.fileupload.FileUploadBase.getItemIterator(FileUploadBase.java:331)
    at org.apache.commons.fileupload.servlet.ServletFileUpload.getItemIterator(ServletFileUpload.java:148)
    at com.ooyala.UploadRequest.initialize(UploadRequest.java:51)
    at com.ooyala.UploadRequestTest.testCreateFromServletRequest(UploadRequestTest.java:57)

这是我的变压器类的缩写版本:

public class UploadRequest {
  private Map<String, String> params;
  private InputStream strIn;
  private Logger Log = Logger.getLogger(UploadRequest.class.getName());

  public UploadRequest()
  {
    params = new HashMap<String, String>();
  }

  public void initialize(HttpServletRequest sRequest, 
                         ServletFileUpload upload)
    throws IOException, FileUploadException
  {
    Enumeration<String> paramNames = sRequest.getParameterNames();
    while …

我目前正在编写一些涉及JMock的测试.我无法理解代码的以下结构:

context.checking(new Expectations() {  //context is of type Mockery of course
            {
                allowing(csv).getFileName();
                will(returnValue(fileName));
            }
        });

据我所知,慢慢分析,

context.checking(new Expectations() { ... }

这将产生一个非常实例化的Expectations.但是为什么我们之后会有另一个括号,然后我会相信一些奇怪的静态方法,例如allow()等？如果有人能从Java的角度向我解释这里发生了什么,我将非常感激.