是否有一种更简洁的方法来测试对列表中每个项目的模拟方法的调用

Question

这是我最近经常遇到的模式的一个例子。 我有一个要测试的方法，它接受一个列表，并可能为列表中的每个项目调用一些其他方法。 为了测试这一点，我定义了一个具有预期调用参数的迭代器，并在 JMock 期望中定义了一个循环，以检查是否针对迭代器的每个项目进行了调用（请参见下面的简单示例）。

我看过 Hamcrest 匹配器，但没有找到对此进行测试的东西（或者误解了可用匹配器的工作原理）。 有人有更优雅的方法吗？

package com.hsbc.maven.versionupdater;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.maven.plugin.testing.AbstractMojoTestCase;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.Sequence;
import org.jmock.internal.NamedSequence;

public class FooTest extends AbstractMojoTestCase {

    public interface Bar {
        void doIt(String arg);
    }

    public class Foo {

        private Bar bar;

        public void executeEven(final List<String> allParameters) {
            for (int i = 0; i < allParameters.size(); i++) {
                if (i % 2 == 0) {
                    bar.doIt(allParameters.get(i));
                }
            }
        }

        public Bar getBar() {
            return bar;
        }

        public void setBar(final Bar bar) {
            this.bar = bar;
        }

    }

    public void testExecuteEven() {
        Mockery mockery = new Mockery();

        final Bar bar = mockery.mock(Bar.class);
        final Sequence sequence = new NamedSequence("sequence");

        final List<String> allParameters = new ArrayList<String>();
        final List<String> expectedParameters = new ArrayList<String>();

        for (int i = 0; i < 3; i++) {
            allParameters.add("param" + i);
            if (i % 2 == 0) {
            expectedParameters.add("param" + i);
            }
        }

        final Iterator<String> iter = expectedParameters.iterator();

        mockery.checking(new Expectations() {
            {
                while (iter.hasNext()) {
                    one(bar).doIt(iter.next());
                    inSequence(sequence);
                }
            }
        });

        Foo subject = new Foo();
        subject.setBar(bar);
        subject.executeEven(allParameters);
        mockery.assertIsSatisfied();
    }
}

Answer 1

我认为您当前的测试实现非常接近理想。 任何进一步的压缩都有可能改变测试的语义或使读者模糊测试的意图（或两者兼而有之）。

但是，如果您正在寻找一种方法来预期对方法的特定调用次数，则可以使用 exactly(n).of()：（

mockery.checking(new Expectations() {{
  exactly(expectedParameters.length()).of(bar).doIt(with(anyOf(expectedParameters)));
}});

我省略了均匀性检查，但您明白了）。 这与不同答案中的 jmockit 示例类似。 请注意，这不会测试与原始测试相同的内容。 特别是，它不会检查：

1. 调用 doIt 的顺序
2. 参数列表的每个元素都只传递一次

例如，如果您的方法以相反的顺序迭代列表，则此测试将通过，或者，如果它只是调用 doIt 方法 n 次，但每次都传递了列表的第一个元素。 如果您想确保列表中的每个元素都被传递，您几乎必须对其进行迭代，为每个元素设置单独的期望。 如果您不关心调用的顺序，则可以省略 Sequence 的使用（在这种情况下，您可能需要更改原始方法以接受 Collection 而不是 List）。

Answer 2

也许以下（使用 JMockit 而不是 jMock）？

import java.util.*;

import org.junit.*;
import org.junit.runner.*;

import org.hamcrest.*;
import static org.hamcrest.core.AnyOf.*;
import static org.hamcrest.core.Is.*;
import org.hamcrest.core.*;

import mockit.*;
import mockit.integration.junit4.*;

@RunWith(JMockit.class)
public class FooTest
{
   public interface Bar { void doIt(String arg); }

   public class Foo
   {
      private Bar bar;

      public void executeEven(final List<String> allParameters)
      {
         for (int i = 0; i < allParameters.size(); i++) {
            if (i % 2 == 0) {
               bar.doIt(allParameters.get(i));
            }
         }
      }

      public void setBar(final Bar bar) { this.bar = bar; }
   }

   @Test
   public void testExecuteEven(final Bar bar)
   {
      final List<String> allParameters = new ArrayList<String>();
      final List<Matcher<? extends String>> expectedParameters =
         new ArrayList<Matcher<? extends String>>();

      for (int i = 0; i < 3; i++) {
         allParameters.add("param" + i);

         if (i % 2 == 0) {
            expectedParameters.add(new IsEqual<String>("param" + i));
         }
      }

      new Expectations()
      {
         {
            bar.doIt(with(anyOf(expectedParameters))); repeats(expectedParameters.size());
         }
      };

      Foo subject = new Foo();
      subject.setBar(bar);
      subject.executeEven(allParameters);
   }

   @Test // a shorter version of the same test
   public void testExecuteEven2(final Bar bar)
   {
      final List<String> allParameters = Arrays.asList("param0", "param1", "param2");

      new Expectations()
      {
         {
            bar.doIt(with(anyOf(is("param0"), is("param2")))); repeats(2);
         }
      };

      Foo subject = new Foo();
      subject.setBar(bar);
      subject.executeEven(allParameters);
   }
}

Answer 3

您可以简化此测试。 您知道自己想要什么，因此可以更具体地了解代码：

public void testExecuteEven() {
  final List<String> values = Arrays.asList("param0", "param1", "param2", "param3");
  Sequence evens = mockery.sequence("evens");

  mockery.checking(new Expectations() {{
    oneOf(bar).doIt(values.get(0)); inSequence(evens);
    oneOf(bar).doIt(values.get(2)); inSequence(evens);
  }});

  subject.executeEven(values);
}

如果您使用 JUnit 4，请不要忘记类上的 @RunWith(JMock.class) 注释避免了对 assertIsSatisfied() 调用的需要。

Answer 4

值得记住的是，您不必一次性创建所有期望。 您可以在 checking(new Expectations(){{}}) 块之外执行循环，并在最终将其传递给模拟之前操作期望列表。 这可以帮助澄清复杂的期望设置（注释也是如此！）：

@Test
public void testExecuteEven() {

  Mockery mockery = new Mockery();
  Sequence evens = mockery.sequence("evens");
  final Bar bar = mockery.mock(Bar.class);

  List<Expectations> expectations = new ArrayList<Expectations>();

  final List<String> allParameters = new ArrayList<String>();
  final List<String> expectedParameters = new ArrayList<String>();


  // generate some parameters 
  for (int i = 0; i < 3; i++) {
      allParameters.add("param" + i);
      if (i % 2 == 0) {
      expectedParameters.add("param" + i);
      }
  }

  // define expectations for the expected parameters
  for (String param : expectedParameters) {
    expectations.add(new Expectations() {{ oneOf(bar).doIt(param); inSequence(evens); }});
  }

  // define any special expectations here
  expectations.add(new Expectations() {{ oneOf(bar).doSomethingElse() /* whatever */ }});

  // load the expectations into the mockery
  for (Expectations expectation : expectations) {
    mockery.checking(expectation);
  }

  Foo subject = new Foo();
  subject.setBar(bar);
  subject.executeEven(allParameters);

}

另外，我注意到您没有使用 Java 5 foreach 语句。 如果您不纠结于使用 Java 4，这也可以帮助您更加清晰。