How to use

RMQNormalProducer

in

org.apache.rocketmq.test.client.rmq

/**
 * @since version3.4.6
 */
@Test
public void testTwoProducerSameGroupAndInstanceName() {
  RMQNormalProducer producer1 = getProducer(nsAddr, topic);
  assertThat(producer1.isStartSuccess()).isEqualTo(true);
  RMQNormalProducer producer2 = getProducer(nsAddr, topic,
    producer1.getProducerGroupName(), producer1.getProducerInstanceName());
  assertThat(producer2.isStartSuccess()).isEqualTo(false);
}

  @Test
  public void testSynSendMessage() {
    int msgSize = 10;
    producer.send(msgSize);
    Assert.assertEquals("Not all sent succeeded", msgSize, producer.getAllUndupMsgBody().size());
    consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
    assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
      consumer.getListener().getAllMsgBody()))
      .containsExactlyElementsIn(producer.getAllMsgBody());
  }
}

public static RMQNormalProducer getProducer(String nsAddr, String topic, boolean useTLS) {
  RMQNormalProducer producer = new RMQNormalProducer(nsAddr, topic, useTLS);
  if (debug) {
    producer.setDebug();
  }
  mqClients.add(producer);
  return producer;
}

public RMQNormalProducer(String nsAddr, String topic, String producerGroupName,
  String producerInstanceName, boolean useTLS) {
  super(topic);
  this.producerGroupName = producerGroupName;
  this.producerInstanceName = producerInstanceName;
  this.nsAddr = nsAddr;
  create(useTLS);
  start();
}

protected void create(boolean useTLS) {
  producer = new DefaultMQProducer();
  producer.setProducerGroup(getProducerGroupName());
  producer.setInstanceName(getProducerInstanceName());
  producer.setUseTLS(useTLS);
  if (nsAddr != null) {
    producer.setNamesrvAddr(nsAddr);
  }
}

  @Test
  public void testSendRandomQueues() {
    int msgSize = 10;
    List<MessageQueue> mqs = producer.getMessageQueue();
    MessageQueueMsg mqMsgs = new MessageQueueMsg(
      MQMessageFactory.getMessageQueues(mqs.get(0), mqs.get(1), mqs.get(mqs.size() - 1)),
      msgSize);
    producer.send(mqMsgs.getMsgsWithMQ());

    consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);

    assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
      consumer.getListener().getAllMsgBody()))
      .containsExactlyElementsIn(mqMsgs.getMsgBodys());

    assertThat(VerifyUtils.verifyOrder(((RMQOrderListener) consumer.getListener()).getMsgs()))
      .isEqualTo(true);
  }
}

  @Test
  public void testConsumeWithDiffTagAndFilter() {
    int msgSize = 10;
    String topic1 = initTopic();
    String topic2 = initTopic();
    String tag1 = "jueyin_tag_1";
    String tag2 = "jueyin_tag_2";
    RMQNormalConsumer consumer = getConsumer(nsAddr, topic1, "*", new RMQNormalListener());
    consumer.subscribe(topic2, tag1);

    producer.send(MQMessageFactory.getMsg(topic2, msgSize, tag2));
    producer.clearMsg();
    producer.send(MQMessageFactory.getMsg(topic1, msgSize));
    producer.send(MQMessageFactory.getMsg(topic2, msgSize, tag1));

    Assert.assertEquals("Not all are sent", msgSize * 2, producer.getAllUndupMsgBody().size());
    consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
    assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
      consumer.getListener().getAllMsgBody()))
      .containsExactlyElementsIn(producer.getAllMsgBody());
  }
}

@Test
public void testQueryMsgByErrorMsgId() {
  producer.clearMsg();
  int msgSize = 20;
  String errorMsgId = "errorMsgId";
  producer.send(msgSize);
  Assert.assertEquals("Not all are sent", msgSize, producer.getAllUndupMsgBody().size());
  MessageExt queryMsg = null;
  try {
    queryMsg = producer.getProducer().viewMessage(errorMsgId);
  } catch (Exception e) {
  }
  assertThat(queryMsg).isNull();
}

  /**
   * @since version3.4.6
   */
  @Test
  public void testSendChinaUserProp() {
    Message msg = MessageFactory.getRandomMessage(topic);
    String msgKey = "jueyinKey";
    String msgValue = "jueyinzhi";
    msg.putUserProperty(msgKey, msgValue);

    RMQNormalConsumer consumer = getConsumer(nsAddr, topic, "*", new RMQNormalListener());

    producer.send(msg, null);
    assertThat(producer.getAllMsgBody().size()).isEqualTo(1);

    consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);

    Message sendMsg = (Message) producer.getFirstMsg();
    Message recvMsg = (Message) consumer.getListener().getFirstMsg();
    assertThat(recvMsg.getUserProperty(msgKey)).isEqualTo(sendMsg.getUserProperty(msgKey));
  }
}

@Test
public void testOrderMsgWithTag1AndTag2SubTag1() {
  int msgSize = 5;
  String tag1 = "jueyin_tag_1";
  String tag2 = "jueyin_tag_2";
  RMQNormalConsumer consumer = getConsumer(nsAddr, topic, tag1, new RMQOrderListener());
  List<MessageQueue> mqs = producer.getMessageQueue();
  MessageQueueMsg mqMsgs = new MessageQueueMsg(mqs, msgSize, tag2);
  producer.send(mqMsgs.getMsgsWithMQ());
  producer.clearMsg();
  mqMsgs = new MessageQueueMsg(mqs, msgSize, tag1);
  producer.send(mqMsgs.getMsgsWithMQ());
  consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
  assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
    consumer.getListener().getAllMsgBody()))
    .containsExactlyElementsIn(mqMsgs.getMsgBodys());
  assertThat(VerifyUtils.verifyOrder(((RMQOrderListener) consumer.getListener()).getMsgs()))
    .isEqualTo(true);
}

@Test
public void testSendAndReceiveMessageOverTLS() {
  int numberOfMessagesToSend = 16;
  producer.send(numberOfMessagesToSend);
  boolean consumedAll = MQWait.waitConsumeAll(consumeTime, producer.getAllMsgBody(), consumer.getListener());
  Assertions.assertThat(consumedAll).isEqualTo(true);
}

  @Test
  public void testConsumeWithDiffTagAndFilter() {
    int msgSize = 10;
    String topic1 = initTopic();
    String topic2 = initTopic();
    String tag1 = "jueyin_tag_1";
    String tag2 = "jueyin_tag_2";
    RMQNormalConsumer consumer1 = getConsumer(nsAddr, topic1, "*", new RMQNormalListener());
    consumer1.subscribe(topic2, tag1);
    RMQNormalConsumer consumer2 = getConsumer(nsAddr, topic1, "*", new RMQNormalListener());
    consumer2.subscribe(topic2, tag1);

    producer.send(MQMessageFactory.getMsg(topic2, msgSize, tag2));
    producer.clearMsg();
    producer.send(MQMessageFactory.getMsg(topic1, msgSize));
    producer.send(MQMessageFactory.getMsg(topic2, msgSize, tag1));

    boolean recvAll = MQWait.waitConsumeAll(consumeTime, producer.getAllMsgBody(),
      consumer1.getListener(), consumer2.getListener());
    assertThat(recvAll).isEqualTo(true);
  }
}

  @Test
  public void testQueryMsg() {
    int msgSize = 20;
    producer.send(msgSize);
    Assert.assertEquals("Not all are sent", msgSize, producer.getAllUndupMsgBody().size());
    consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
    Assert.assertEquals("Not all are consumed", 0, VerifyUtils.verify(producer.getAllMsgBody(),
      consumer.getListener().getAllMsgBody()));

    MessageExt recvMsg = (MessageExt) consumer.getListener().getFirstMsg();
    MessageExt queryMsg = null;
    try {
      TestUtils.waitForMoment(3000);
      queryMsg = producer.getProducer().viewMessage(((MessageClientExt) recvMsg).getOffsetMsgId());
    } catch (Exception e) {
    }

    assertThat(queryMsg).isNotNull();
    assertThat(new String(queryMsg.getBody())).isEqualTo(new String(recvMsg.getBody()));
  }
}

@Test
public void testQueryMsg() {
  int msgSize = 20;
  String key = "jueyin";
  long begin = System.currentTimeMillis();
  List<Object> msgs = MQMessageFactory.getKeyMsg(topic, key, msgSize);
  producer.send(msgs);
  Assert.assertEquals("Not all are sent", msgSize, producer.getAllUndupMsgBody().size());
  List<MessageExt> queryMsgs = null;
  try {
    TestUtils.waitForMoment(500 * 3);
    queryMsgs = producer.getProducer().queryMessage(topic, key, msgSize, begin - 5000,
      System.currentTimeMillis() + 5000).getMessageList();
  } catch (Exception e) {
  }
  assertThat(queryMsgs).isNotNull();
  assertThat(queryMsgs.size()).isEqualTo(msgSize);
}

/**
 * @since version3.4.6
 */
@Test
public void testTwoProducerSameGroup() {
  RMQNormalProducer producer1 = getProducer(nsAddr, topic);
  assertThat(producer1.isStartSuccess()).isEqualTo(true);
  RMQNormalProducer producer2 = getProducer(nsAddr, topic,
    producer1.getProducerGroupName(), RandomUtils.getStringByUUID());
  assertThat(producer2.isStartSuccess()).isEqualTo(true);
}

public void send(Map<MessageQueue, List<Object>> msgs) {
  for (MessageQueue mq : msgs.keySet()) {
    send(msgs.get(mq), mq);
  }
}

@Test
public void testAddOneConsumer() {
  int msgSize = 100;
  RMQNormalConsumer consumer1 = getConsumer(nsAddr, topic, "*", new RMQNormalListener());
  MQAsyncProducer asyncDefaultMQProducer = new MQAsyncProducer(producer, msgSize, 100);
  asyncDefaultMQProducer.start();
  TestUtils.waitForSeconds(waitTime);
  RMQNormalConsumer consumer2 = getConsumer(nsAddr, consumer1.getConsumerGroup(), topic,
    "*", new RMQNormalListener());
  asyncDefaultMQProducer.waitSendAll(waitTime * 6);
  MQWait.waitConsumeAll(consumeTime, producer.getAllMsgBody(), consumer1.getListener(),
    consumer2.getListener());
  boolean recvAll = MQWait.waitConsumeAll(consumeTime, producer.getAllMsgBody(),
    consumer1.getListener(), consumer2.getListener());
  assertThat(recvAll).isEqualTo(true);
}

@Test
public void testOrderMsg() {
  int msgSize = 10;
  List<MessageQueue> mqs = producer.getMessageQueue();
  MessageQueueMsg mqMsgs = new MessageQueueMsg(mqs, msgSize);
  producer.send(mqMsgs.getMsgsWithMQ());
  consumer.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
  assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
    consumer.getListener().getAllMsgBody()))
    .containsExactlyElementsIn(mqMsgs.getMsgBodys());
  assertThat(VerifyUtils.verifyOrder(((RMQOrderListener) consumer.getListener()).getMsgs()))
    .isEqualTo(true);
}

  @Test
  public void testTwoConsumerFilter() {
    int msgSize = 40;
    String tag1 = "jueyin_tag_1";
    String tag2 = "jueyin_tag_2";

    RMQBroadCastConsumer consumer1 = getBroadCastConsumer(nsAddr, topic, tag1,
      new RMQNormalListener());
    RMQBroadCastConsumer consumer2 = getBroadCastConsumer(nsAddr,
      consumer1.getConsumerGroup(), topic, tag1, new RMQNormalListener());
    TestUtils.waitForSeconds(waitTime);

    producer.send(tag2, msgSize);
    Assert.assertEquals("Not all sent succeeded", msgSize, producer.getAllUndupMsgBody().size());
    producer.clearMsg();
    producer.send(tag1, msgSize);

    consumer1.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);
    consumer2.getListener().waitForMessageConsume(producer.getAllMsgBody(), consumeTime);

    assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
      consumer1.getListener().getAllMsgBody()))
      .containsExactlyElementsIn(producer.getAllMsgBody());
    assertThat(VerifyUtils.getFilterdMessage(producer.getAllMsgBody(),
      consumer2.getListener().getAllMsgBody()))
      .containsExactlyElementsIn(producer.getAllMsgBody());
  }
}

  @Test
  public void testQueryMsgByNullMsgId() {
    producer.clearMsg();
    int msgSize = 20;
    String errorMsgId = null;
    producer.send(msgSize);
    Assert.assertEquals("Not all are sent", msgSize, producer.getAllUndupMsgBody().size());

    MessageExt queryMsg = null;
    try {
      queryMsg = producer.getProducer().viewMessage(errorMsgId);
    } catch (Exception e) {
    }

    assertThat(queryMsg).isNull();
  }
}