测试Storm螺栓和喷口

Question

因此，如果您使用基于JUnit的单元测试，是否建议您运行一个小型模拟拓扑(localmode？）并测试该拓扑下的bolt（或spout)的隐含契约？或者，是否可以使用JUnit，但这意味着我们必须仔细模拟Bolt的生命周期（创建它、调用prepare()、嘲弄config等）？在这种情况下，被测类（螺栓/喷口）有哪些一般的测试点需要考虑？

其他开发人员在创建正确的单元测试方面做了什么？

我注意到有一个拓扑测试API（参见：https://github.com/xumingming/storm-lib/blob/master/src/jvm/storm/testingapidemo.java）。使用这些API，并为每个Bolt&spout建立“测试拓扑”（并验证Bolt必须提供的隐式契约，例如-它声明的输出），是不是更好？

谢谢

Answer 1

我们的方法是使用构造函数--将一个可序列化的工厂注入到喷口/螺栓中。然后，喷口/螺栓在其打开/准备方法中咨询工厂。工厂的唯一责任是以可串行化的方式封装获得喷口/螺栓的依赖关系。这种设计允许我们的单元测试注入假/测试/模拟工厂，当被咨询时，这些工厂返回模拟服务。通过这种方式，我们可以使用Mockito等模拟工具对喷口/螺栓进行狭义的单元测试。

下面是一个螺栓的通用示例和它的测试。我已经省略了工厂usernotificationFactory的实现，因为它取决于您的应用程序。您可以使用服务定位器来获取服务、序列化配置、HDFS可访问的配置，或者任何获取正确服务的方法，只要工厂能够在一个serde周期之后完成这些操作。您应该介绍该类的序列化。

螺栓

public class NotifyUserBolt extends BaseBasicBolt {
  public static final String NAME = "NotifyUser";
  private static final String USER_ID_FIELD_NAME = "userId";

  private final UserNotifierFactory factory;
  transient private UserNotifier notifier;

  public NotifyUserBolt(UserNotifierFactory factory) {
    checkNotNull(factory);

    this.factory = factory;
  }

  @Override
  public void prepare(Map stormConf, TopologyContext context) {
    notifier = factory.createUserNotifier();
  }

  @Override
  public void execute(Tuple input, BasicOutputCollector collector) {
    // This check ensures that the time-dependency imposed by Storm has been observed
    checkState(notifier != null, "Unable to execute because user notifier is unavailable.  Was this bolt successfully prepared?");

    long userId = input.getLongByField(PreviousBolt.USER_ID_FIELD_NAME);

    notifier.notifyUser(userId);

    collector.emit(new Values(userId));
  }

  @Override
  public void declareOutputFields(OutputFieldsDeclarer declarer) {
    declarer.declare(new Fields(USER_ID_FIELD_NAME));
  }
}

public class NotifyUserBoltTest {

  private NotifyUserBolt bolt;

  @Mock
  private TopologyContext topologyContext;

  @Mock
  private UserNotifier notifier;

  // This test implementation allows us to get the mock to the unit-under-test.
  private class TestFactory implements UserNotifierFactory {

    private final UserNotifier notifier;

    private TestFactory(UserNotifier notifier) {
      this.notifier = notifier;
    }

    @Override
    public UserNotifier createUserNotifier() {
      return notifier;
    }
  }

  @Before
  public void before() {
    MockitoAnnotations.initMocks(this);

    // The factory will return our mock `notifier`
    bolt = new NotifyUserBolt(new TestFactory(notifier));
    // Now the bolt is holding on to our mock and is under our control!
    bolt.prepare(new Config(), topologyContext);
  }

  @Test
  public void testExecute() {
    long userId = 24;
    Tuple tuple = mock(Tuple.class);
    when(tuple.getLongByField(PreviousBolt.USER_ID_FIELD_NAME)).thenReturn(userId);
    BasicOutputCollector collector = mock(BasicOutputCollector.class);

    bolt.execute(tuple, collector);

    // Here we just verify a call on `notifier`, but we could have stubbed out behavior befor
    //  the call to execute, too.
    verify(notifier).notifyUser(userId);
    verify(collector).emit(new Values(userId));
  }
}