import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testFailedCreateConsumerConnectionStillWorks() throws JMSException {
    Connection connection = pooledConnFact.createConnection("guest", "password");
    connection.start();

    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Queue queue = session.createQueue(name.getMethodName());

    try {
        session.createConsumer(queue);
        fail("Should fail to create consumer");
    } catch (JMSSecurityException ex) {
        LOG.info("Caught expected security error");
    }

    queue = session.createQueue("GUESTS." + name.getMethodName());

    MessageProducer producer = session.createProducer(queue);
    producer.close();

    connection.close();
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
private void ensureConnected() throws JMSException {
    if (isConnected() || closed.get()) {
        return;
    }

    synchronized(this.connectionId) {
        if (isConnected() || closed.get()) {
            return;
        }

        if (clientID == null || clientID.trim().isEmpty()) {
            throw new IllegalArgumentException("Client ID cannot be null or empty string");
        }

        if (!user.isValid()) {
            executor.shutdown();

            throw new JMSSecurityException(user.getFailureCause());
        }

        connected.set(true);
    }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
private MockJMSConnection createMockConnection(String username, String password) throws JMSException {
    MockJMSUser user = validateUser(username, password);

    if (!user.isValid() && !deferAuthenticationToConnection) {
        throw new JMSSecurityException(user.getFailureCause());
    }

    MockJMSConnection connection = new MockJMSConnection(user);

    if (clientID != null && !clientID.isEmpty()) {
        connection.setClientID(clientID, true);
    } else {
        connection.setClientID(UUID.randomUUID().toString(), false);
    }

    try {
        connection.initialize();
    } catch (JMSException e) {
        connection.close();
    }

    return connection;
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testFailedConnectThenSucceeds() throws JMSException {
    Connection connection = pooledConnFact.createConnection("invalid", "credentials");

    try {
        connection.start();
        fail("Should fail to connect");
    } catch (JMSSecurityException ex) {
        LOG.info("Caught expected security error");
    }

    connection = pooledConnFact.createConnection("system", "manager");
    connection.start();

    LOG.info("Successfully create new connection.");

    connection.close();
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testFailedConnectThenSucceedsWithListener() throws JMSException {
    Connection connection = pooledConnFact.createConnection("invalid", "credentials");
    connection.setExceptionListener(new ExceptionListener() {

        @Override
        public void onException(JMSException exception) {
            LOG.warn("Connection get error: {}", exception.getMessage());
        }
    });

    try {
        connection.start();
        fail("Should fail to connect");
    } catch (JMSSecurityException ex) {
        LOG.info("Caught expected security error");
    }

    connection = pooledConnFact.createConnection("system", "manager");
    connection.start();

    LOG.info("Successfully create new connection.");

    connection.close();
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testFailoverWithInvalidCredentialsCanConnect() throws JMSException {

    ActiveMQConnectionFactory cf = new ActiveMQConnectionFactory(
        "failover:(" + connectionURI + ")");

    pooledConnFact = new JmsPoolConnectionFactory();
    pooledConnFact.setConnectionFactory(cf);
    pooledConnFact.setMaxConnections(1);

    Connection connection = pooledConnFact.createConnection("invalid", "credentials");

    try {
        connection.start();
        fail("Should fail to connect");
    } catch (JMSSecurityException ex) {
        LOG.info("Caught expected security error");
    }

    connection = pooledConnFact.createConnection("system", "manager");
    connection.start();

    LOG.info("Successfully create new connection.");

    connection.close();
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testAutoCreateOnSendToQueueSecurity() throws Exception {
   ((ActiveMQJAASSecurityManager) server.getSecurityManager()).getConfiguration().addUser("guest", "guest");
   ((ActiveMQJAASSecurityManager) server.getSecurityManager()).getConfiguration().setDefaultUser("guest");
   ((ActiveMQJAASSecurityManager) server.getSecurityManager()).getConfiguration().addRole("guest", "rejectAll");
   Role role = new Role("rejectAll", false, false, false, false, false, false, false, false, false, false);
   Set<Role> roles = new HashSet<>();
   roles.add(role);
   server.getSecurityRepository().addMatch("#", roles);
   Connection connection = cf.createConnection();
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

   javax.jms.Queue queue = ActiveMQJMSClient.createQueue(QUEUE_NAME);

   try {
      session.createProducer(queue);
      Assert.fail("Sending a message here should throw a JMSSecurityException");
   } catch (Exception e) {
      Assert.assertTrue(e instanceof JMSSecurityException);
   }

   connection.close();
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testRepeatedWrongPasswordAttempts() throws Exception {
   for (int i = 0; i < 25; ++i) {
      Connection connection = null;
      try {
         connection = createConnection(fullUser, "wrongPassword", null, false);
         connection.start();
         fail("Expected JMSException");
      } catch (JMSSecurityException ex) {
         IntegrationTestLogger.LOGGER.debug("Failed to authenticate connection with incorrect password.");
      } finally {
         if (connection != null) {
            connection.close();
         }
      }
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testConsumerNotAuthorized() throws Exception {
   Connection connection = createConnection(noprivUser, noprivPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      javax.jms.Queue queue = session.createQueue(getQueueName());
      try {
         session.createConsumer(queue);
         fail("Should not be able to consume here.");
      } catch (JMSSecurityException jmsSE) {
         IntegrationTestLogger.LOGGER.info("Caught expected exception");
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testBrowserNotAuthorized() throws Exception {
   Connection connection = createConnection(noprivUser, noprivPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      javax.jms.Queue queue = session.createQueue(getQueueName());
      try {
         QueueBrowser browser = session.createBrowser(queue);
         // Browser is not created until an enumeration is requesteda
         browser.getEnumeration();
         fail("Should not be able to consume here.");
      } catch (JMSSecurityException jmsSE) {
         IntegrationTestLogger.LOGGER.info("Caught expected exception");
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testConsumerNotAuthorizedToCreateQueues() throws Exception {
   Connection connection = createConnection(noprivUser, noprivPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      javax.jms.Queue queue = session.createQueue(getQueueName(getPrecreatedQueueSize() + 1));
      try {
         session.createConsumer(queue);
         fail("Should not be able to consume here.");
      } catch (JMSSecurityException jmsSE) {
         IntegrationTestLogger.LOGGER.info("Caught expected exception");
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testProducerNotAuthorized() throws Exception {
   Connection connection = createConnection(guestUser, guestPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      javax.jms.Queue queue = session.createQueue(getQueueName());
      try {
         session.createProducer(queue);
         fail("Should not be able to produce here.");
      } catch (JMSSecurityException jmsSE) {
         IntegrationTestLogger.LOGGER.info("Caught expected exception");
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testAnonymousProducerNotAuthorized() throws Exception {
   Connection connection = createConnection(guestUser, guestPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      javax.jms.Queue queue = session.createQueue(getQueueName());
      MessageProducer producer = session.createProducer(null);

      try {
         producer.send(queue, session.createTextMessage());
         fail("Should not be able to produce here.");
      } catch (JMSSecurityException jmsSE) {
         IntegrationTestLogger.LOGGER.info("Caught expected exception");
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testCreateTemporaryQueueNotAuthorized() throws JMSException {
   Connection connection = createConnection(guestUser, guestPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      try {
         session.createTemporaryQueue();
      } catch (JMSSecurityException jmsse) {
         IntegrationTestLogger.LOGGER.info("Client should have thrown a JMSSecurityException but only threw JMSException");
      }

      // Should not be fatal
      assertNotNull(connection.createSession(false, Session.AUTO_ACKNOWLEDGE));
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 30000)
public void testCreateTemporaryTopicNotAuthorized() throws JMSException {
   Connection connection = createConnection(guestUser, guestPass);

   try {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      try {
         session.createTemporaryTopic();
      } catch (JMSSecurityException jmsse) {
         IntegrationTestLogger.LOGGER.info("Client should have thrown a JMSSecurityException but only threw JMSException");
      }

      // Should not be fatal
      assertNotNull(connection.createSession(false, Session.AUTO_ACKNOWLEDGE));
   } finally {
      connection.close();
   }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
private void doMechanismSelectedTestImpl(String username, String password, Symbol clientSelectedMech, Symbol[] serverMechs, boolean wait) throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {

        testPeer.expectFailingSaslAuthentication(serverMechs, clientSelectedMech);

        ConnectionFactory factory = new JmsConnectionFactory("amqp://localhost:" + testPeer.getServerPort() + "?jms.clientID=myclientid");
        try {
            factory.createConnection(username, password);
            fail("Excepted exception to be thrown");
        }catch (JMSSecurityException jmsse) {
            // Expected, we deliberately failed the SASL process,
            // we only wanted to verify the correct mechanism
            // was selected, other tests verify the remainder.

            LOG.info("Caught expected security exception: {}", jmsse.getMessage());
        }

        if (wait) {
            Thread.sleep(200);
        }

        testPeer.waitForAllHandlersToComplete(1000);
    }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
private void doMechanismSelectionRestrictedTestImpl(String username, String password, Symbol clientSelectedMech, Symbol[] serverMechs, String mechanismsOptionValue) throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {

        testPeer.expectFailingSaslAuthentication(serverMechs, clientSelectedMech);

        String uriOptions = "?jms.clientID=myclientid";
        if(mechanismsOptionValue != null) {
            uriOptions += "&amqp.saslMechanisms=" + mechanismsOptionValue;
        }

        ConnectionFactory factory = new JmsConnectionFactory("amqp://localhost:" + testPeer.getServerPort() + uriOptions);
        try {
            factory.createConnection(username, password);

            fail("Excepted exception to be thrown");
        }catch (JMSSecurityException jmsse) {
            // Expected, we deliberately failed the SASL process,
            // we only wanted to verify the correct mechanism
            // was selected, other tests verify the remainder.
        }

        testPeer.waitForAllHandlersToComplete(1000);
    }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test(timeout = 20000)
public void testSaslGssApiKrbConfigError() throws Exception {
    final String loginConfigScope = "KRB5-CLIENT-DOES-NOT-EXIST";

    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {
        testPeer.expectSaslGSSAPIFail();

        String uriOptions = "?sasl.options.configScope=" + loginConfigScope + "&amqp.saslMechanisms=" + GSSAPI;
        ConnectionFactory factory = new JmsConnectionFactory("amqp://localhost:" + testPeer.getServerPort() + uriOptions);
        factory.createConnection();

        fail("Expect exception on no login config");
    } catch (JMSSecurityException expected) {
        assertTrue(expected.getMessage().contains(loginConfigScope));
    }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
private void doMechanismSelectedTestImpl(String username, String password, Symbol clientSelectedMech, Symbol[] serverMechs, boolean enableGssapiExplicitly) throws Exception {
    try (TestAmqpPeer testPeer = new TestAmqpPeer();) {

        testPeer.expectFailingSaslAuthentication(serverMechs, clientSelectedMech);

        String uriOptions = "?jms.clientID=myclientid";
        if(enableGssapiExplicitly) {
            uriOptions += "&amqp.saslMechanisms=PLAIN," + GSSAPI;
        }
        ConnectionFactory factory = new JmsConnectionFactory("amqp://localhost:" + testPeer.getServerPort() + uriOptions);

        try {
            factory.createConnection(username, password);
            fail("Excepted exception to be thrown");
        }catch (JMSSecurityException jmsse) {
            // Expected, we deliberately failed the SASL process,
            // we only wanted to verify the correct mechanism
            // was selected, other tests verify the remainder.

            LOG.info("Caught expected security exception: {}", jmsse.getMessage());
        }

        testPeer.waitForAllHandlersToComplete(1000);
    }
}
 

import javax.jms.JMSSecurityException; //导入依赖的package包/类
@Test
public void testContextClosePreservesSessionCloseException() throws JMSException {
    JmsConnection connection = Mockito.mock(JmsConnection.class);
    JmsSession session = Mockito.mock(JmsSession.class);
    Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
    JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);

    Mockito.doThrow(IllegalStateException.class).when(session).close();
    Mockito.doThrow(JMSSecurityException.class).when(connection).close();

    context.createTemporaryTopic();
    Mockito.verify(connection, Mockito.times(1)).createSession(JMSContext.AUTO_ACKNOWLEDGE);

    try {
        context.close();
        fail("Should throw ISRE");
    } catch (IllegalStateRuntimeException isre) {
    }
}