content: /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.activemq.transport.mqtt;
  
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.EOFException;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.atomic.AtomicReference;
  
  import org.apache.activemq.util.Wait;
  import org.apache.activemq.util.Wait.Condition;
  import org.fusesource.hawtdispatch.DispatchQueue;
  import org.fusesource.hawtdispatch.internal.SerialDispatchQueue;
  import org.fusesource.hawtdispatch.transport.Transport;
  import org.fusesource.mqtt.client.BlockingConnection;
  import org.fusesource.mqtt.client.Callback;
  import org.fusesource.mqtt.client.CallbackConnection;
  import org.fusesource.mqtt.client.FutureConnection;
  import org.fusesource.mqtt.client.MQTT;
  import org.fusesource.mqtt.client.Tracer;
  import org.fusesource.mqtt.codec.MQTTFrame;
  import org.fusesource.mqtt.codec.MQTTProtocolCodec;
  import org.fusesource.mqtt.codec.PINGREQ;
  import org.fusesource.mqtt.codec.PINGRESP;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.Timeout;
  import org.junit.runner.RunWith;
  import org.junit.runners.Parameterized;
  import org.junit.runners.Parameterized.Parameters;
  import org.mockito.Mockito;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Test to show that a PINGRESP will only be sent for a PINGREQ
   * packet after a CONNECT packet has been received.
   */
  @RunWith(Parameterized.class)
  public class MQTTPingReqTest extends MQTTTestSupport {
  
      private static final Logger LOG = LoggerFactory.getLogger(MQTTPingReqTest.class);
  
      @Rule
      public Timeout timeout = new Timeout(15, TimeUnit.SECONDS);
  
      private final String version;
  
      @Parameters(name = "mqtt-version:{0}")
      public static Collection<Object[]> data() {
          return Arrays.asList(new Object[][] {
              {"3.1"},
              {"3.1.1"}
          });
      }
  
      public MQTTPingReqTest(final String version) {
          this.version = version;
      }
  
      @Test(expected=EOFException.class)
      public void testPingReqWithoutConnectFail() throws Exception {
          MQTT mqtt = createMQTTConnection();
          mqtt.setClientId("clientId");
          mqtt.setVersion(version);
  
          final CountDownLatch latch = new CountDownLatch(1);
          final AtomicReference<Transport> transport = new AtomicReference<>();
          final AtomicReference<Throwable> error = new AtomicReference<>();
          final Callback<Transport> con = new Callback<Transport>() {
  
              @Override
              public void onSuccess(Transport value) {
                  transport.set(value);
                  latch.countDown();
              }
  
              @Override
              public void onFailure(Throwable value) {
                  error.set(value);
                  latch.countDown();
              }
          };
  
          //Connect to the transport by using the createTransport method with a custom callback
          //This will ensure that we connect without sending a CONNECT packet for testing
          //and that we won't receive automatically
          CallbackConnection connection = new CallbackConnection(mqtt);
          Method createTransportMethod = connection.getClass().getDeclaredMethod("createTransport", Callback.class);
          createTransportMethod.setAccessible(true);
          createTransportMethod.invoke(connection, con);
          latch.await();
  
          //Make sure no error on connect
          if (error.get() != null) {
              LOG.error(error.get().getMessage(), error.get());
              fail(error.get().getMessage());
          }
  
          disableDispatchAssertion(transport.get());
  
          //Send a PINGREQ without a connect packet first
          final MQTTProtocolCodec codec = new MQTTProtocolCodec();
          codec.setTransport(transport.get());
          transport.get().offer(new PINGREQ().encode());
  
          //Protocol should throw an exception since we never sent a CONNECT
          Wait.waitFor(new Condition() {
  
              @Override
              public boolean isSatisified() throws Exception {
                  //Wait for exception to be thrown
                  codec.read();
                  return false;
              }
          }, 5000, 100);
      }
  
      @Test
      public void testPingReqConnectSuccess() throws Exception {
          MQTT mqtt = createMQTTConnection();
          mqtt.setClientId("clientId");
          mqtt.setVersion(version);
  
          final CountDownLatch pingRespReceived = new CountDownLatch(1);
          //Tracer to assert we received the response by waiting for it
          mqtt.setTracer(new Tracer() {
  
              @Override
              public void onReceive(MQTTFrame frame) {
                  if (frame.messageType() == PINGRESP.TYPE) {
                      pingRespReceived.countDown();
                  }
              }
  
          });
          CallbackConnection callbackConnection = new CallbackConnection(mqtt);
          BlockingConnection connection = new BlockingConnection(new FutureConnection(callbackConnection));
          connection.connect();
          Transport transport =  callbackConnection.transport();
          disableDispatchAssertion(transport);
  
          //SEND a PINGREQ and wait for the response
          final MQTTProtocolCodec codec = new MQTTProtocolCodec();
          codec.setTransport(transport);
          transport.offer(new PINGREQ().encode());
  
          //Wait for the response
          assertTrue(pingRespReceived.await(5, TimeUnit.SECONDS));
      }
  
      private void disableDispatchAssertion(final Transport transport) {
          //Since we are purposefully bypassing the normal way of sending a packet, turn off the
          //assertion
          DispatchQueue dispatchQueue = transport.getDispatchQueue();
          if (dispatchQueue instanceof SerialDispatchQueue) {
              SerialDispatchQueue spyQueue = Mockito.spy((SerialDispatchQueue)dispatchQueue);
              Mockito.doNothing().when(spyQueue).assertExecuting();
              transport.setDispatchQueue(spyQueue);
          }
      }
  }
  