Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
ProducerFlowControlOverflowPolicyHandler implements OverflowPolicyHandler { boolean isQueueFlowStopped() { return _handler.isQueueFlowStopped(); } ProducerFlowControlOverflowPolicyHandler(Queue<?> queue, EventLogger eventLogger); @Override void checkOverflow(final QueueEntry newlyEnqueued); }
@Test public void testIsQueueFlowStopped() throws Exception { assertFalse("Flow should not be stopped", _producerFlowControlOverflowPolicyHandler.isQueueFlowStopped()); when(_queue.getQueueDepthBytes()).thenReturn(11L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(10L); checkOverflow(mock(AMQPSession.class)); assertTrue("Flow should be stopped", _producerFlowControlOverflowPolicyHandler.isQueueFlowStopped()); }
RejectPolicyHandler { void checkReject(final ServerMessage<?> newMessage) throws MessageUnacceptableException { _handler.checkReject(newMessage); } RejectPolicyHandler(final Queue<?> queue); }
@Test public void testOverfullBytes() throws Exception { ServerMessage incomingMessage = createIncomingMessage(6); when(_queue.getQueueDepthBytes()).thenReturn(5L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(10L); when(_queue.getQueueDepthMessages()).thenReturn(1); try { _rejectOverflowPolicyHandler.checkReject(incomingMessage); fail("Exception expected"); } catch (MessageUnacceptableException e) { } } @Test public void testOverfullMessages() throws Exception { ServerMessage incomingMessage = createIncomingMessage(5); when(_queue.getMaximumQueueDepthMessages()).thenReturn(7L); when(_queue.getQueueDepthMessages()).thenReturn(7); when(_queue.getQueueDepthBytes()).thenReturn(10L); try { _rejectOverflowPolicyHandler.checkReject(incomingMessage); fail("Exception expected"); } catch (MessageUnacceptableException e) { } }
RingOverflowPolicyHandler implements OverflowPolicyHandler { @Override public void checkOverflow(final QueueEntry newlyEnqueued) { _handler.checkOverflow(); } RingOverflowPolicyHandler(final Queue<?> queue, final EventLogger eventLogger); @Override void checkOverflow(final QueueEntry newlyEnqueued); }
@Test public void testCheckOverflowWhenOverfullBytes() throws Exception { QueueEntry lastEntry = createLastEntry(); when(_queue.getLeastSignificantOldestEntry()).thenReturn(lastEntry, (QueueEntry) null); when(_queue.getQueueDepthBytes()).thenReturn(10L, 4L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(5L); when(_queue.getQueueDepthMessages()).thenReturn(3, 1); _ringOverflowPolicyHandler.checkOverflow(null); verify(_queue).deleteEntry(lastEntry); LogMessage dropped = QueueMessages.DROPPED(1L, 4, 1, 5,-1); verify(_eventLogger).message(same(_subject), argThat(new LogMessageMatcher(dropped))); verifyNoMoreInteractions(_eventLogger); } @Test public void testCheckOverflowWhenOverfullMessages() throws Exception { QueueEntry lastEntry = createLastEntry(); when(_queue.getLeastSignificantOldestEntry()).thenReturn(lastEntry, (QueueEntry) null); when(_queue.getQueueDepthMessages()).thenReturn(10, 5); when(_queue.getMaximumQueueDepthMessages()).thenReturn(5L); when(_queue.getQueueDepthBytes()).thenReturn(10L, 4L); _ringOverflowPolicyHandler.checkOverflow(null); verify((AbstractQueue<?>) _queue).deleteEntry(lastEntry); LogMessage dropped = QueueMessages.DROPPED(1, 4, 5, -1,5); verify(_eventLogger).message(same(_subject), argThat(new LogMessageMatcher(dropped))); verifyNoMoreInteractions(_eventLogger); } @Test public void testCheckOverflowWhenUnderfullBytes() throws Exception { when(_queue.getQueueDepthBytes()).thenReturn(5L); when(_queue.getMaximumQueueDepthBytes()).thenReturn(5L); when(_queue.getQueueDepthMessages()).thenReturn(3); _ringOverflowPolicyHandler.checkOverflow(null); verify(_queue, never()).deleteEntry(any(QueueEntry.class)); verifyNoMoreInteractions(_eventLogger); } @Test public void testCheckOverflowWhenUnderfullMessages() throws Exception { when(_queue.getQueueDepthMessages()).thenReturn(5); when(_queue.getMaximumQueueDepthMessages()).thenReturn(5L); when(_queue.getQueueDepthBytes()).thenReturn(10L); _ringOverflowPolicyHandler.checkOverflow(null); verify(_queue, never()).deleteEntry(any(QueueEntry.class)); verifyNoMoreInteractions(_eventLogger); }
SortedQueueEntry extends QueueEntryImpl { @Override public int compareTo(final QueueEntry other) { SortedQueueEntry o = (SortedQueueEntry)other; final String otherKey = o._key; final int compare = _key == null ? (otherKey == null ? 0 : -1) : otherKey == null ? 1 : _key.compareTo(otherKey); return compare == 0 ? super.compareTo(o) : compare; } SortedQueueEntry(final SortedQueueEntryList queueEntryList); SortedQueueEntry(final SortedQueueEntryList queueEntryList, final ServerMessage message, final long entryId, final MessageEnqueueRecord messageEnqueueRecord); @Override int compareTo(final QueueEntry other); Colour getColour(); String getKey(); SortedQueueEntry getLeft(); @Override SortedQueueEntry getNextNode(); @Override SortedQueueEntry getNextValidEntry(); SortedQueueEntry getParent(); SortedQueueEntry getPrev(); SortedQueueEntry getRight(); void setColour(final Colour colour); void setKey(final String key); void setLeft(final SortedQueueEntry left); void setNext(final SortedQueueEntry next); void setParent(final SortedQueueEntry parent); void setPrev(final SortedQueueEntry prev); void setRight(final SortedQueueEntry right); @Override String toString(); }
@Override @Test public void testCompareTo() { assertTrue(_queueEntry.compareTo(_queueEntry2) > 0); assertTrue(_queueEntry.compareTo(_queueEntry3) > 0); assertTrue(_queueEntry2.compareTo(_queueEntry3) < 0); assertTrue(_queueEntry2.compareTo(_queueEntry) < 0); assertTrue(_queueEntry3.compareTo(_queueEntry2) > 0); assertTrue(_queueEntry3.compareTo(_queueEntry) < 0); assertTrue(_queueEntry.compareTo(_queueEntry) == 0); assertTrue(_queueEntry2.compareTo(_queueEntry2) == 0); assertTrue(_queueEntry3.compareTo(_queueEntry3) == 0); }
RollingPolicyDecorator implements RollingPolicy { @Override public void setParent(FileAppender appender) { _decorated.setParent(appender); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }
@Test public void testSetParent() { FileAppender appender = mock(FileAppender.class); _policy.setParent(appender); verify(_delegate).setParent(appender); }
SortedQueueEntry extends QueueEntryImpl { @Override public SortedQueueEntry getNextValidEntry() { return getNextNode(); } SortedQueueEntry(final SortedQueueEntryList queueEntryList); SortedQueueEntry(final SortedQueueEntryList queueEntryList, final ServerMessage message, final long entryId, final MessageEnqueueRecord messageEnqueueRecord); @Override int compareTo(final QueueEntry other); Colour getColour(); String getKey(); SortedQueueEntry getLeft(); @Override SortedQueueEntry getNextNode(); @Override SortedQueueEntry getNextValidEntry(); SortedQueueEntry getParent(); SortedQueueEntry getPrev(); SortedQueueEntry getRight(); void setColour(final Colour colour); void setKey(final String key); void setLeft(final SortedQueueEntry left); void setNext(final SortedQueueEntry next); void setParent(final SortedQueueEntry parent); void setPrev(final SortedQueueEntry prev); void setRight(final SortedQueueEntry right); @Override String toString(); }
@Override @Test public void testTraverseWithNoDeletedEntries() { QueueEntry current = _queueEntry2; current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry3, current); current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry, current); current = current.getNextValidEntry(); assertNull(current); } @Override @Test public void testTraverseWithDeletedEntries() { _queueEntry3.acquire(); _queueEntry3.delete(); assertTrue(_queueEntry3.isDeleted()); QueueEntry current = _queueEntry2; current = current.getNextValidEntry(); assertSame("Unexpected current entry", _queueEntry, current); current = current.getNextValidEntry(); assertNull(current); }
LastValueQueueList extends OrderedQueueEntryList { @Override public ConflationQueueEntry add(final ServerMessage message, final MessageEnqueueRecord enqueueRecord) { final ConflationQueueEntry addedEntry = (ConflationQueueEntry) super.add(message, enqueueRecord); final Object keyValue = message.getMessageHeader().getHeader(_conflationKey); if (keyValue != null) { if(LOGGER.isDebugEnabled()) { LOGGER.debug("Adding entry " + addedEntry + " for message " + message.getMessageNumber() + " with conflation key " + keyValue); } final AtomicReference<ConflationQueueEntry> referenceToEntry = new AtomicReference<ConflationQueueEntry>(addedEntry); AtomicReference<ConflationQueueEntry> entryReferenceFromMap; ConflationQueueEntry entryFromMap; boolean keepTryingToUpdateEntryReference; do { do { entryReferenceFromMap = getOrPutIfAbsent(keyValue, referenceToEntry); entryFromMap = entryReferenceFromMap.get(); } while(entryFromMap == _deleteInProgress); boolean entryFromMapIsOlder = entryFromMap != _newerEntryAlreadyBeenAndGone && entryFromMap.compareTo(addedEntry) < 0; keepTryingToUpdateEntryReference = entryFromMapIsOlder && !entryReferenceFromMap.compareAndSet(entryFromMap, addedEntry); } while(keepTryingToUpdateEntryReference); if (entryFromMap == _newerEntryAlreadyBeenAndGone) { discardEntry(addedEntry); } else if (entryFromMap.compareTo(addedEntry) > 0) { if(LOGGER.isDebugEnabled()) { LOGGER.debug("New entry " + addedEntry.getEntryId() + " for message " + addedEntry.getMessage().getMessageNumber() + " being immediately discarded because a newer entry arrived. The newer entry is: " + entryFromMap + " for message " + entryFromMap.getMessage().getMessageNumber()); } discardEntry(addedEntry); } else if (entryFromMap.compareTo(addedEntry) < 0) { if(LOGGER.isDebugEnabled()) { LOGGER.debug("Entry " + addedEntry + " for message " + addedEntry.getMessage().getMessageNumber() + " replacing older entry " + entryFromMap + " for message " + entryFromMap.getMessage().getMessageNumber()); } discardEntry(entryFromMap); } addedEntry.setLatestValueReference(entryReferenceFromMap); } return addedEntry; } LastValueQueueList(LastValueQueue<?> queue, QueueStatistics queueStatistics); @Override ConflationQueueEntry add(final ServerMessage message, final MessageEnqueueRecord enqueueRecord); @Override QueueEntry getLeastSignificantOldestEntry(); }
@Test public void testAddMessageWithoutConflationKeyValue() { ServerMessage message = createTestServerMessage(null); _list.add(message, null); int numberOfEntries = countEntries(_list); assertEquals((long) 1, (long) numberOfEntries); } @Test public void testAddAndDiscardMessageWithoutConflationKeyValue() { ServerMessage message = createTestServerMessage(null); QueueEntry addedEntry = _list.add(message, null); addedEntry.acquire(); addedEntry.delete(); int numberOfEntries = countEntries(_list); assertEquals((long) 0, (long) numberOfEntries); } @Test public void testAddMessageWithConflationKeyValue() { ServerMessage message = createTestServerMessage(TEST_KEY_VALUE); _list.add(message, null); int numberOfEntries = countEntries(_list); assertEquals((long) 1, (long) numberOfEntries); } @Test public void testAddAndRemoveMessageWithConflationKeyValue() { ServerMessage message = createTestServerMessage(TEST_KEY_VALUE); QueueEntry addedEntry = _list.add(message, null); addedEntry.acquire(); addedEntry.delete(); int numberOfEntries = countEntries(_list); assertEquals((long) 0, (long) numberOfEntries); } @Test public void testAddTwoMessagesWithDifferentConflationKeyValue() { ServerMessage message1 = createTestServerMessage(TEST_KEY_VALUE1); ServerMessage message2 = createTestServerMessage(TEST_KEY_VALUE2); _list.add(message1, null); _list.add(message2, null); int numberOfEntries = countEntries(_list); assertEquals((long) 2, (long) numberOfEntries); } @Test public void testAddTwoMessagesWithSameConflationKeyValue() { ServerMessage message1 = createTestServerMessage(TEST_KEY_VALUE); ServerMessage message2 = createTestServerMessage(TEST_KEY_VALUE); _list.add(message1, null); _list.add(message2, null); int numberOfEntries = countEntries(_list); assertEquals((long) 1, (long) numberOfEntries); } @Test public void testSupersededEntryIsDiscardedOnRelease() { ServerMessage message1 = createTestServerMessage(TEST_KEY_VALUE); ServerMessage message2 = createTestServerMessage(TEST_KEY_VALUE); QueueEntry entry1 = _list.add(message1, null); entry1.acquire(); _list.add(message2, null); assertFalse(entry1.isDeleted()); assertEquals((long) 2, (long) countEntries(_list)); entry1.release(); assertEquals((long) 1, (long) countEntries(_list)); assertTrue(entry1.isDeleted()); }
InternalMessageMutator implements ServerMessageMutator<InternalMessage> { @Override public void setPriority(final byte priority) { _priority = priority; } InternalMessageMutator(final InternalMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override InternalMessage create(); }
@Test public void setPriority() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); assertThat(_messageMutator.getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); }
RollingPolicyDecorator implements RollingPolicy { @Override public void start() { ScanTask task = createScanTaskAndCancelInProgress(); _decorated.start(); _executorService.execute(task); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }
@Test public void testStart() { _policy.start(); verify(_delegate).start(); }
InternalMessageMutator implements ServerMessageMutator<InternalMessage> { @Override public byte getPriority() { return _priority; } InternalMessageMutator(final InternalMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override InternalMessage create(); }
@Test public void getPriority() { assertThat((int) _messageMutator.getPriority(), is(equalTo((int) TEST_PRIORITY))); }
InternalMessageMutator implements ServerMessageMutator<InternalMessage> { @Override public InternalMessage create() { final InternalMessageHeader messageHeader = _message.getMessageHeader(); final InternalMessageHeader newHeader = new InternalMessageHeader(new HashMap<>(messageHeader.getHeaderMap()), messageHeader.getCorrelationId(), messageHeader.getExpiration(), messageHeader.getUserId(), messageHeader.getAppId(), messageHeader.getMessageId(), messageHeader.getMimeType(), messageHeader.getEncoding(), _priority, messageHeader.getTimestamp(), messageHeader.getNotValidBefore(), messageHeader.getType(), messageHeader.getReplyTo(), _message.getArrivalTime()); final long contentSize = _message.getSize(); final InternalMessageMetaData metaData = InternalMessageMetaData.create(_message.isPersistent(), newHeader, (int) contentSize); final MessageHandle<InternalMessageMetaData> handle = _messageStore.addMessage(metaData); final QpidByteBuffer content = _message.getContent(); if (content != null) { handle.addContent(content); } final StoredMessage<InternalMessageMetaData> storedMessage = handle.allContentAdded(); return new InternalMessage(storedMessage, newHeader, _message.getMessageBody(), _message.getTo()); } InternalMessageMutator(final InternalMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override InternalMessage create(); }
@Test public void create() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); final InternalMessage newMessage = _messageMutator.create(); assertThat(newMessage.getMessageHeader().getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); assertThat(newMessage.getMessageHeader().getMimeType(), is(equalTo(TEST_CONTENT_TYPE))); assertThat(newMessage.getMessageHeader().getHeader(TEST_HEADER_NAME), is(equalTo(TEST_HEADER_VALUE))); final QpidByteBuffer content = newMessage.getContent(); final byte[] bytes = new byte[content.remaining()]; content.copyTo(bytes); assertThat(new String(bytes, UTF_8), is(equalTo(TEST_CONTENT))); }
UUIDGenerator { public static UUID generateQueueUUID(String queueName, String virtualHostName) { return createUUID(Queue.class.getName(), virtualHostName, queueName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testQueueIdGeneration() throws Exception { UUID queue1 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_1, VIRTUAL_HOST_NAME_1); UUID queue2 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_1, VIRTUAL_HOST_NAME_1); assertEquals("Queue IDs should be equal", queue1, queue2); queue1 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_1, VIRTUAL_HOST_NAME_1); queue2 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_2, VIRTUAL_HOST_NAME_1); assertFalse("Queue IDs should not be equal", queue1.equals(queue2)); queue1 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_1, VIRTUAL_HOST_NAME_1); queue2 = UUIDGenerator.generateQueueUUID(QUEUE_NAME_1, VIRTUAL_HOST_NAME_2); assertFalse("Queue IDs should not be equal", queue1.equals(queue2)); }
UUIDGenerator { public static UUID generateExchangeUUID(String exchangeName, String virtualHostName) { return createUUID(Exchange.class.getName(), virtualHostName, exchangeName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testExchangeIdGeneration() throws Exception { UUID exchange1 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_1, VIRTUAL_HOST_NAME_1); UUID exchange2 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_1, VIRTUAL_HOST_NAME_1); assertEquals("Exchange IDs should be equal", exchange1, exchange2); exchange1 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_1, VIRTUAL_HOST_NAME_1); exchange2 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_2, VIRTUAL_HOST_NAME_1); assertFalse("Exchange IDs should not be equal", exchange1.equals(exchange2)); exchange1 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_1, VIRTUAL_HOST_NAME_1); exchange2 = UUIDGenerator.generateExchangeUUID(EXCHANGE_NAME_1, VIRTUAL_HOST_NAME_2); assertFalse("Exchange IDs should not be equal", exchange1.equals(exchange2)); }
UUIDGenerator { public static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName) { return createUUID(Binding.class.getName(), virtualHostName, exchangeName, queueName, bindingKey); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testBindingIdGeneration() throws Exception { UUID binding1 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_1, VIRTUAL_HOST_NAME_1); UUID binding2 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_1, VIRTUAL_HOST_NAME_1); assertEquals("Binding IDs should be equal", binding1, binding2); binding1 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_1, VIRTUAL_HOST_NAME_1); binding2 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_2, VIRTUAL_HOST_NAME_1); assertFalse("Binding IDs should not be equal", binding1.equals(binding2)); binding1 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_1, VIRTUAL_HOST_NAME_1); binding2 = UUIDGenerator.generateBindingUUID(EXCHANGE_NAME_1, QUEUE_NAME_1, BINDING_KEY_1, VIRTUAL_HOST_NAME_2); assertFalse("Binding IDs should not be equal", binding1.equals(binding2)); }
UUIDGenerator { public static UUID generateVhostUUID(String virtualHostName) { return createUUID(VirtualHost.class.getName(), virtualHostName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testVhostIdGeneration() throws Exception { UUID vhost1 = UUIDGenerator.generateVhostUUID(VIRTUAL_HOST_NAME_1); UUID vhost2 = UUIDGenerator.generateVhostUUID(VIRTUAL_HOST_NAME_1); assertTrue("Virtualhost IDs should be equal", vhost1.equals(vhost2)); vhost1 = UUIDGenerator.generateVhostUUID(VIRTUAL_HOST_NAME_1); vhost2 = UUIDGenerator.generateVhostUUID(VIRTUAL_HOST_NAME_2); assertFalse("Virtualhost IDs should not be equal", vhost1.equals(vhost2)); }
UUIDGenerator { public static UUID generateVhostAliasUUID(String virtualHostName, String portName) { return createUUID(VirtualHostAlias.class.getName(), virtualHostName, portName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testVhostAliasIdGeneration() throws Exception { UUID alias1 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_1, PORT_1); UUID alias2 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_1, PORT_1); assertTrue("Virtualhost Alias IDs should be equal", alias1.equals(alias2)); alias1 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_1, PORT_1); alias2 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_2, PORT_1); assertFalse("Virtualhost Alias IDs should not be equal", alias1.equals(alias2)); alias1 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_1, PORT_1); alias2 = UUIDGenerator.generateVhostAliasUUID(VHOST_ALIAS_1, PORT_2); assertFalse("Virtualhost Alias IDs should not be equal", alias1.equals(alias2)); }
UUIDGenerator { public static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName) { return createUUID(Consumer.class.getName(), virtualHostName, queueName, connectionRemoteAddress, channelNumber, consumerName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testConsumerIdGeneration() throws Exception { UUID consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); UUID consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); assertTrue("Consumer IDs should be equal", consumer1.equals(consumer2)); consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_2); assertFalse("Consumer IDs should not be equal", consumer1.equals(consumer2)); consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_2, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); assertFalse("Consumer IDs should not be equal", consumer1.equals(consumer2)); consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_2, CONSUMER_NAME_1); assertFalse("Consumer IDs should not be equal", consumer1.equals(consumer2)); consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_2, CHANNEL_NUMBER_1, CONSUMER_NAME_1); assertFalse("Consumer IDs should not be equal", consumer1.equals(consumer2)); consumer1 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_1, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); consumer2 = UUIDGenerator.generateConsumerUUID(VIRTUAL_HOST_NAME_1, QUEUE_NAME_2, CONN_REMOTE_ADDR_1, CHANNEL_NUMBER_1, CONSUMER_NAME_1); assertFalse("Consumer IDs should not be equal", consumer1.equals(consumer2)); }
UUIDGenerator { public static UUID generateUserUUID(String authenticationProviderName, String userName) { return createUUID(User.class.getName(), authenticationProviderName, userName); } static UUID generateRandomUUID(); static UUID generateExchangeUUID(String exchangeName, String virtualHostName); static UUID generateQueueUUID(String queueName, String virtualHostName); static UUID generateBindingUUID(String exchangeName, String queueName, String bindingKey, String virtualHostName); static UUID generateUserUUID(String authenticationProviderName, String userName); static UUID generateGroupUUID(String groupProviderName, String groupName); static UUID generateVhostUUID(String virtualHostName); static UUID generateVhostAliasUUID(String virtualHostName, String portName); static UUID generateConsumerUUID(String virtualHostName, String queueName, String connectionRemoteAddress, String channelNumber, String consumerName); static UUID generateGroupMemberUUID(String groupProviderName, String groupName, String groupMemberName); static UUID generateBrokerChildUUID(String type, String childName); }
@Test public void testUserIdGeneration() throws Exception { UUID user1 = UUIDGenerator.generateUserUUID(PROVIDER_1, USER_1); UUID user2 = UUIDGenerator.generateUserUUID(PROVIDER_1, USER_1); assertTrue("User IDs should be equal", user1.equals(user2)); user1 = UUIDGenerator.generateUserUUID(PROVIDER_1, USER_1); user2 = UUIDGenerator.generateUserUUID(PROVIDER_1, USER_2); assertFalse("User IDs should not be equal", user1.equals(user2)); user1 = UUIDGenerator.generateUserUUID(PROVIDER_1, USER_1); user2 = UUIDGenerator.generateUserUUID(PROVIDER_2, USER_1); assertFalse("User IDs should not be equal", user1.equals(user2)); }
ConfiguredObjectJacksonModule extends SimpleModule { public static ObjectMapper newObjectMapper(final boolean forPersistence) { final ObjectMapper objectMapper = new ObjectMapper(); objectMapper.registerModule(forPersistence ? PERSISTENCE_INSTANCE : INSTANCE); return objectMapper; } private ConfiguredObjectJacksonModule(final boolean forPersistence); static ObjectMapper newObjectMapper(final boolean forPersistence); }
@Test public void testPrincipalSerialisation() throws Exception { final String username = "testuser@withFunky%"; final String originType = "authType"; final String originName = "authName('also')with%funky@Characters'"; final String expectedSerialisation = String.format("\"%s@%s('%s')\"", URLEncoder.encode(username, UTF8), originType, URLEncoder.encode(originName, UTF8)); AuthenticationProvider<?> authProvider = mock(AuthenticationProvider.class); when(authProvider.getType()).thenReturn(originType); when(authProvider.getName()).thenReturn(originName); Principal p = new UsernamePrincipal(username, authProvider); ObjectMapper mapper = ConfiguredObjectJacksonModule.newObjectMapper(false); String json = mapper.writeValueAsString(p); assertEquals("unexpected principal serialisation", expectedSerialisation, json); } @Test public void testManageableAttributeType() throws IOException { ManagedAttributeValue testType = new TestManagedAttributeValue(); ObjectMapper encoder = ConfiguredObjectJacksonModule.newObjectMapper(false); String encodedValue = encoder.writeValueAsString(testType); ObjectMapper decoder = new ObjectMapper(); Map decodedMap = decoder.readValue(encodedValue, Map.class); assertEquals((long) 3, (long) decodedMap.size()); assertTrue(decodedMap.containsKey("name")); assertTrue(decodedMap.containsKey("map")); assertTrue(decodedMap.containsKey("type")); assertEquals("foo", decodedMap.get("name")); assertEquals(Collections.singletonMap("key", "value"), decodedMap.get("map")); assertEquals(Collections.singletonMap("nested", true), decodedMap.get("type")); }
RollingPolicyDecorator implements RollingPolicy { @Override public void stop() { _decorated.stop(); synchronized (_publishResultsLock) { if (_currentScanTask != null) { _currentScanTask.cancel(); } _previousScanResults = null; } } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }
@Test public void testStop() { _policy.stop(); verify(_delegate).stop(); }
FileBasedGroupProviderImpl extends AbstractCaseAwareGroupProvider<FileBasedGroupProviderImpl> implements FileBasedGroupProvider<FileBasedGroupProviderImpl> { @Override public Set<Principal> getGroupPrincipalsForUser(Principal userPrincipal) { Set<String> groups = _groupDatabase == null ? Collections.<String>emptySet() : _groupDatabase.getGroupsForUser(userPrincipal.getName()); if (groups.isEmpty()) { return Collections.emptySet(); } else { Set<Principal> principals = new HashSet<Principal>(); for (String groupName : groups) { principals.add(new GroupPrincipal(groupName, this)); } return principals; } } @ManagedObjectFactoryConstructor FileBasedGroupProviderImpl(Map<String, Object> attributes, Container<?> container); @Override void onValidate(); @Override String getPath(); @Override Set<Principal> getGroupPrincipalsForUser(Principal userPrincipal); static final String GROUP_FILE_PROVIDER_TYPE; }
@Test public void testExistingGroupFile() throws Exception { Map<String, Set<String>> input = new HashMap<>(); input.put("super", Sets.newHashSet("root")); _groupFile = createTemporaryGroupFile(input); Map<String, Object> providerAttrs = new HashMap<>(); String groupsFile = _groupFile.getAbsolutePath(); providerAttrs.put(FileBasedGroupProvider.TYPE, GROUP_FILE_PROVIDER_TYPE); providerAttrs.put(FileBasedGroupProvider.PATH, groupsFile); providerAttrs.put(FileBasedGroupProvider.NAME, getTestName()); @SuppressWarnings("unchecked") GroupProvider<?> provider = _objectFactory.create(GroupProvider.class, providerAttrs, _broker); Set<Principal> adminGroups = provider.getGroupPrincipalsForUser(() -> "root"); assertThat("root has unexpected group membership", adminGroups.stream().map(Principal::getName).collect(Collectors.toSet()), containsInAnyOrder("super")); Collection<Group> groups = provider.getChildren(Group.class); assertThat(groups.size(), is(equalTo(1))); Group<?> superGroup = groups.iterator().next(); assertThat(superGroup.getName(), is(equalTo("super"))); Collection<GroupMember> members = superGroup.getChildren(GroupMember.class); assertThat(members.size(), is(equalTo(1))); GroupMember rootMember = members.iterator().next(); assertThat(rootMember.getName(), is(equalTo("root"))); } @Test public void testGetGroupPrincipalsForUserCaseAware() throws Exception { Map<String, Set<String>> input = new HashMap<>(); input.put("super", Sets.newHashSet("root")); _groupFile = createTemporaryGroupFile(input); Map<String, Object> providerAttrs = new HashMap<>(); String groupsFile = _groupFile.getAbsolutePath(); providerAttrs.put(FileBasedGroupProvider.TYPE, GROUP_FILE_PROVIDER_TYPE); providerAttrs.put(FileBasedGroupProvider.PATH, groupsFile); providerAttrs.put(FileBasedGroupProvider.NAME, getTestName()); @SuppressWarnings("unchecked") GroupProvider<?> provider = _objectFactory.create(GroupProvider.class, providerAttrs, _broker); assertThat(provider, is(instanceOf(FileBasedGroupProvider.class))); assertThat(((FileBasedGroupProvider)provider).isCaseSensitive(), is(true)); Set<Principal> adminGroups = provider.getGroupPrincipalsForUser(() -> "Root"); assertThat("No group should be found when caseSensitive=true", adminGroups.stream().map(Principal::getName).collect(Collectors.toSet()), is(empty())); provider.setAttributes(Collections.singletonMap("caseSensitive", false)); assertThat(((FileBasedGroupProvider)provider).isCaseSensitive(), is(false)); Set<Principal> adminGroups2 = provider.getGroupPrincipalsForUser(() -> "Root"); assertThat("root has unexpected group membership", adminGroups2.stream().map(Principal::getName).collect(Collectors.toSet()), containsInAnyOrder("super")); }
ArrivalTimeFilterFactory implements MessageFilterFactory { @Override public MessageFilter newInstance(final List<String> arguments) { if(arguments == null || arguments.size() != 1) { throw new IllegalArgumentException(String.format("Cannot create a %s filter from these arguments: %s", getType(), arguments)); } final String periodArgument = arguments.get(0); try { long periodInSeconds = Long.parseLong(periodArgument); return new ArrivalTimeFilter(System.currentTimeMillis() - (periodInSeconds * 1000L), periodInSeconds == 0L); } catch (NumberFormatException e) { throw new IllegalArgumentException(String.format("Cannot create a %s filter. Period value '%s' does not contain a parsable long value", getType(), periodArgument), e); } } @Override MessageFilter newInstance(final List<String> arguments); @Override String getType(); }
@Test public void testNewInstance() throws Exception { long currentTime = System.currentTimeMillis(); int periodInSeconds = 60; MessageFilter filter = new ArrivalTimeFilterFactory().newInstance(Collections.singletonList(String.valueOf(periodInSeconds))); Filterable message = mock(Filterable.class); when(message.getArrivalTime()).thenReturn(currentTime - periodInSeconds * 1000 - 1); assertFalse("Message arrived before '1 minute before filter creation' should not be accepted", filter.matches(message)); when(message.getArrivalTime()).thenReturn(currentTime - periodInSeconds * 1000 / 2); assertTrue("Message arrived after '1 minute before filter creation' should be accepted", filter.matches(message)); when(message.getArrivalTime()).thenReturn(System.currentTimeMillis()); assertTrue("Message arrived after filter creation should be accepted", filter.matches(message)); }
JMSSelectorFilter implements MessageFilter { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final JMSSelectorFilter that = (JMSSelectorFilter) o; return getSelector().equals(that.getSelector()); } JMSSelectorFilter(String selector); @Override String getName(); @Override boolean matches(Filterable message); @Override boolean startAtTail(); String getSelector(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testEqualsAndHashCodeUsingSelectorString() throws Exception { final String selectorString = "1 = 1"; JMSSelectorFilter filter1 = new JMSSelectorFilter(new String(selectorString)); JMSSelectorFilter filter2 = new JMSSelectorFilter(new String(selectorString)); assertEquals(filter1 + " should equal itself", filter1, filter1); assertFalse(filter1 + " should not equal null", filter1.equals(null)); assertEqualsAndHashCodeMatch(filter1, filter2); JMSSelectorFilter differentFilter = new JMSSelectorFilter("2 = 2"); assertNotEqual(filter1, differentFilter); }
ExchangeMessages { public static LogMessage CREATED(String param1, String param2, boolean opt1) { String rawMessage = _messages.getString("CREATED"); StringBuffer msg = new StringBuffer(); String[] parts = rawMessage.split("\\["); msg.append(parts[0]); int end; if (parts.length > 1) { end = parts[1].indexOf(']'); if (opt1) { msg.append(parts[1].substring(0, end)); } msg.append(parts[1].substring(end + 1)); } rawMessage = msg.toString(); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CREATED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ExchangeMessages(); static LogMessage CREATED(String param1, String param2, boolean opt1); static LogMessage DELETED(); static LogMessage DISCARDMSG(String param1, String param2); static LogMessage OPERATION(String param1); static final String EXCHANGE_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String DELETED_LOG_HIERARCHY; static final String DISCARDMSG_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testExchangeCreated_Transient() throws Exception { Exchange<?> exchange = BrokerTestHelper.createExchange("test", false, getEventLogger()); String type = exchange.getType(); String name = exchange.getName(); _logMessage = ExchangeMessages.CREATED(type, name, false); List<Object> log = getLog(); String[] expected = {"Create :", "Type:", type, "Name:", name}; validateLogMessageNoSubject(log, "EXH-1001", expected); } @Test public void testExchangeCreated_Persistent() throws Exception { Exchange<?> exchange = BrokerTestHelper.createExchange("test", true, getEventLogger()); String type = exchange.getType(); String name = exchange.getName(); _logMessage = ExchangeMessages.CREATED(type, name, true); List<Object> log = getLog(); String[] expected = {"Create :", "Durable", "Type:", type, "Name:", name}; validateLogMessageNoSubject(log, "EXH-1001", expected); }
ExchangeMessages { public static LogMessage DELETED() { String rawMessage = _messages.getString("DELETED"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return DELETED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ExchangeMessages(); static LogMessage CREATED(String param1, String param2, boolean opt1); static LogMessage DELETED(); static LogMessage DISCARDMSG(String param1, String param2); static LogMessage OPERATION(String param1); static final String EXCHANGE_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String DELETED_LOG_HIERARCHY; static final String DISCARDMSG_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testExchangeDeleted() { _logMessage = ExchangeMessages.DELETED(); List<Object> log = performLog(); String[] expected = {"Deleted"}; validateLogMessage(log, "EXH-1002", expected); }
ExchangeMessages { public static LogMessage DISCARDMSG(String param1, String param2) { String rawMessage = _messages.getString("DISCARDMSG"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return DISCARDMSG_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ExchangeMessages(); static LogMessage CREATED(String param1, String param2, boolean opt1); static LogMessage DELETED(); static LogMessage DISCARDMSG(String param1, String param2); static LogMessage OPERATION(String param1); static final String EXCHANGE_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String DELETED_LOG_HIERARCHY; static final String DISCARDMSG_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testExchangeDiscardedMessage() throws Exception { Exchange<?> exchange = BrokerTestHelper.createExchange("test", false, getEventLogger()); final String name = exchange.getName(); final String routingKey = "routingKey"; clearLog(); _logMessage = ExchangeMessages.DISCARDMSG(name, routingKey); List<Object> log = performLog(); String[] expected = {"Discarded Message :","Name:", "\"" + name + "\"", "Routing Key:", "\"" + routingKey + "\""}; validateLogMessage(log, "EXH-1003", expected); }
BrokerMessages { public static LogMessage STARTUP(String param1, String param2) { String rawMessage = _messages.getString("STARTUP"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return STARTUP_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerStartup() { String version = "Qpid 0.6"; String build = "796936M"; _logMessage = BrokerMessages.STARTUP(version, build); List<Object> log = performLog(); String[] expected = {"Startup :", "Version:", version, "Build:", build}; validateLogMessage(log, "BRK-1001", expected); }
RollingPolicyDecorator implements RollingPolicy { @Override public boolean isStarted() { return _decorated.isStarted(); } RollingPolicyDecorator(RollingPolicyBase decorated, RolloverListener listener, ScheduledExecutorService executorService); @Override void rollover(); @Override String getActiveFileName(); @Override CompressionMode getCompressionMode(); @Override void setParent(FileAppender appender); @Override void start(); @Override void stop(); @Override boolean isStarted(); RollingPolicyBase getDecorated(); static final int DEFAULT_RESCAN_DELAY; static final String ROLLOVER_RESCAN_DELAY_MS_PROPERTY_NAME; static final int DEFAULT_RESCAN_LIMIT; static final String ROLLOVER_RESCAN_LIMIT_PROPERTY_NAME; }
@Test public void testIsStarted() { _policy.isStarted(); verify(_delegate).isStarted(); }
BrokerMessages { public static LogMessage LISTENING(String param1, Number param2) { String rawMessage = _messages.getString("LISTENING"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return LISTENING_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerListening() { String transport = "TCP"; Integer port = 2765; _logMessage = BrokerMessages.LISTENING(transport, port); List<Object> log = performLog(); String[] expected = {"Starting", "Listening on ", transport, "port ", String.valueOf(port)}; validateLogMessage(log, "BRK-1002", expected); }
BrokerMessages { public static LogMessage SHUTTING_DOWN(String param1, Number param2) { String rawMessage = _messages.getString("SHUTTING_DOWN"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return SHUTTING_DOWN_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerShuttingDown() { String transport = "TCP"; Integer port = 2765; _logMessage = BrokerMessages.SHUTTING_DOWN(transport, port); List<Object> log = performLog(); String[] expected = {"Shutting down", transport, "port ", String.valueOf(port)}; validateLogMessage(log, "BRK-1003", expected); }
BrokerMessages { public static LogMessage READY() { String rawMessage = _messages.getString("READY"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return READY_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerReady() { _logMessage = BrokerMessages.READY(); List<Object> log = performLog(); String[] expected = {"Ready"}; validateLogMessage(log, "BRK-1004", expected); }
BrokerMessages { public static LogMessage STOPPED() { String rawMessage = _messages.getString("STOPPED"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return STOPPED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerStopped() { _logMessage = BrokerMessages.STOPPED(); List<Object> log = performLog(); String[] expected = {"Stopped"}; validateLogMessage(log, "BRK-1005", expected); }
BrokerMessages { public static LogMessage CONFIG(String param1) { String rawMessage = _messages.getString("CONFIG"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CONFIG_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerConfig() { String path = "/file/path/to/configuration.xml"; _logMessage = BrokerMessages.CONFIG(path); List<Object> log = performLog(); String[] expected = {"Using configuration :", path}; validateLogMessage(log, "BRK-1006", expected); }
BrokerMessages { public static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6) { String rawMessage = _messages.getString("PLATFORM"); final Object[] messageArguments = {param1, param2, param3, param4, param5, param6}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return PLATFORM_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerPlatform() { String javaVendor = "jvendor"; String javaVersion = "j1.0"; String osName = "os"; String osVersion = "o1.0"; String osArch = "oarch"; String cores = "2"; _logMessage = BrokerMessages.PLATFORM(javaVendor, javaVersion, osName, osVersion, osArch, cores); List<Object> log = performLog(); String[] expected = {"Platform :", "JVM :", javaVendor, " version: ", " OS : ", osName, " version: ", osVersion, " arch: ", osArch, " cores: ", cores}; validateLogMessage(log, "BRK-1010", expected); }
BrokerMessages { public static LogMessage MAX_MEMORY(Number param1, Number param2) { String rawMessage = _messages.getString("MAX_MEMORY"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return MAX_MEMORY_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private BrokerMessages(); static LogMessage CONFIG(String param1); static LogMessage FAILED_CHILDREN(String param1); static LogMessage FATAL_ERROR(String param1); static LogMessage LISTENING(String param1, Number param2); static LogMessage MANAGEMENT_MODE(String param1, String param2); static LogMessage MAX_MEMORY(Number param1, Number param2); static LogMessage OPERATION(String param1); static LogMessage PLATFORM(String param1, String param2, String param3, String param4, String param5, String param6); static LogMessage PROCESS(String param1); static LogMessage READY(); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1, String param2); static LogMessage STOPPED(); static final String BROKER_LOG_HIERARCHY; static final String CONFIG_LOG_HIERARCHY; static final String FAILED_CHILDREN_LOG_HIERARCHY; static final String FATAL_ERROR_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String MANAGEMENT_MODE_LOG_HIERARCHY; static final String MAX_MEMORY_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PLATFORM_LOG_HIERARCHY; static final String PROCESS_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testBrokerMemory() { long oneGiga = 1024*1024*1024; long twoGiga = oneGiga * 2; _logMessage = BrokerMessages.MAX_MEMORY(oneGiga, twoGiga); List<Object> log = performLog(); NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.US); String[] expected = {"Maximum Memory :", "Heap", numberFormat.format(oneGiga), "bytes", "Direct", numberFormat.format(twoGiga), "bytes" }; validateLogMessage(log, "BRK-1011", expected); }
VirtualHostMessages { public static LogMessage CREATED(String param1) { String rawMessage = _messages.getString("CREATED"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CREATED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private VirtualHostMessages(); static LogMessage CLOSED(String param1); static LogMessage CREATED(String param1); static LogMessage ERRORED(String param1); static LogMessage FILESYSTEM_FULL(Number param1); static LogMessage FILESYSTEM_NOTFULL(Number param1); static LogMessage OPERATION(String param1); static final String VIRTUALHOST_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String ERRORED_LOG_HIERARCHY; static final String FILESYSTEM_FULL_LOG_HIERARCHY; static final String FILESYSTEM_NOTFULL_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testVirtualhostCreated() { String name = "test"; _logMessage = VirtualHostMessages.CREATED(name); List<Object> log = performLog(); String[] expected = {"Created :", name}; validateLogMessage(log, "VHT-1001", expected); }
VirtualHostMessages { public static LogMessage CLOSED(String param1) { String rawMessage = _messages.getString("CLOSED"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CLOSED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private VirtualHostMessages(); static LogMessage CLOSED(String param1); static LogMessage CREATED(String param1); static LogMessage ERRORED(String param1); static LogMessage FILESYSTEM_FULL(Number param1); static LogMessage FILESYSTEM_NOTFULL(Number param1); static LogMessage OPERATION(String param1); static final String VIRTUALHOST_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String ERRORED_LOG_HIERARCHY; static final String FILESYSTEM_FULL_LOG_HIERARCHY; static final String FILESYSTEM_NOTFULL_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testVirtualhostClosed() { String name = "test"; _logMessage = VirtualHostMessages.CLOSED(name); List<Object> log = performLog(); String[] expected = {"Closed :", name}; validateLogMessage(log, "VHT-1002", expected); }
ChannelMessages { public static LogMessage CREATE() { String rawMessage = _messages.getString("CREATE"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CREATE_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ChannelMessages(); static LogMessage CLOSE(); static LogMessage CLOSE_FORCED(Number param1, String param2); static LogMessage CREATE(); static LogMessage DEADLETTERMSG(Number param1, String param2); static LogMessage DISCARDMSG_NOALTEXCH(Number param1, String param2, String param3); static LogMessage DISCARDMSG_NOROUTE(Number param1, String param2); static LogMessage FLOW(String param1); static LogMessage FLOW_CONTROL_IGNORED(); static LogMessage FLOW_ENFORCED(String param1); static LogMessage FLOW_REMOVED(); static LogMessage OPERATION(String param1); static LogMessage PREFETCH_SIZE(Number param1, Number param2); static final String CHANNEL_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String CLOSE_FORCED_LOG_HIERARCHY; static final String CREATE_LOG_HIERARCHY; static final String DEADLETTERMSG_LOG_HIERARCHY; static final String DISCARDMSG_NOALTEXCH_LOG_HIERARCHY; static final String DISCARDMSG_NOROUTE_LOG_HIERARCHY; static final String FLOW_LOG_HIERARCHY; static final String FLOW_CONTROL_IGNORED_LOG_HIERARCHY; static final String FLOW_ENFORCED_LOG_HIERARCHY; static final String FLOW_REMOVED_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PREFETCH_SIZE_LOG_HIERARCHY; }
@Test public void testChannelCreate() { _logMessage = ChannelMessages.CREATE(); List<Object> log = performLog(); String[] expected = {"Create"}; validateLogMessage(log, "CHN-1001", expected); }
AppenderUtils { public static void configureRollingFileAppender(FileLoggerSettings fileLoggerSettings, Context loggerContext, RollingFileAppender<ILoggingEvent> appender) { String fileName = fileLoggerSettings.getFileName(); File file = new File(fileName); if (file.getParentFile() != null) { file.getParentFile().mkdirs(); } validateLogFilePermissions(file); validateMaxFileSize(fileLoggerSettings.getMaxFileSize()); appender.setFile(fileName); appender.setAppend(true); appender.setContext(loggerContext); TriggeringPolicy triggeringPolicy; RollingPolicyBase rollingPolicy; final String maxFileSizeAsString = String.valueOf(fileLoggerSettings.getMaxFileSize()) + "MB"; if(fileLoggerSettings.isRollDaily()) { DailyTriggeringPolicy dailyTriggeringPolicy = new DailyTriggeringPolicy(fileLoggerSettings.isRollOnRestart(), maxFileSizeAsString); dailyTriggeringPolicy.setContext(loggerContext); TimeBasedRollingPolicy<ILoggingEvent> timeBasedRollingPolicy = new TimeBasedRollingPolicy<>(); timeBasedRollingPolicy.setMaxHistory(fileLoggerSettings.getMaxHistory()); timeBasedRollingPolicy.setTimeBasedFileNamingAndTriggeringPolicy(dailyTriggeringPolicy); timeBasedRollingPolicy.setFileNamePattern(fileName + ".%d{yyyy-MM-dd}.%i" + (fileLoggerSettings.isCompressOldFiles() ? ".gz" : "")); rollingPolicy = timeBasedRollingPolicy; triggeringPolicy = dailyTriggeringPolicy; } else { SizeTriggeringPolicy sizeTriggeringPolicy = new SizeTriggeringPolicy(fileLoggerSettings.isRollOnRestart(), maxFileSizeAsString); sizeTriggeringPolicy.setContext(loggerContext); SimpleRollingPolicy simpleRollingPolicy = new SimpleRollingPolicy(fileLoggerSettings.getMaxHistory()); simpleRollingPolicy.setFileNamePattern(fileName + ".%i" + (fileLoggerSettings.isCompressOldFiles() ? ".gz" : "")); rollingPolicy = simpleRollingPolicy; triggeringPolicy = sizeTriggeringPolicy; } rollingPolicy.setContext(loggerContext); RollingPolicyDecorator decorator = new RollingPolicyDecorator(rollingPolicy, fileLoggerSettings.getRolloverListener(), fileLoggerSettings.getExecutorService()); decorator.setParent(appender); appender.setRollingPolicy(decorator); appender.setTriggeringPolicy(triggeringPolicy); decorator.start(); triggeringPolicy.start(); final PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setPattern(fileLoggerSettings.getLayout()); encoder.setContext(loggerContext); encoder.start(); appender.setEncoder(encoder); } static void configureRollingFileAppender(FileLoggerSettings fileLoggerSettings, Context loggerContext, RollingFileAppender<ILoggingEvent> appender); }
@Test public void testCreateRollingFileAppenderDailyRolling() { final RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>(); AppenderUtils.configureRollingFileAppender(_settings, new LoggerContext(), appender); assertEquals("Unexpected appender file name", _testLogFileName, appender.getFile()); RollingPolicy rollingPolicy = appender.getRollingPolicy(); final boolean condition2 = rollingPolicy instanceof RollingPolicyDecorator; assertTrue("Unexpected rolling policy", condition2); rollingPolicy = ((RollingPolicyDecorator)rollingPolicy).getDecorated(); final boolean condition1 = rollingPolicy instanceof TimeBasedRollingPolicy; assertTrue("Unexpected decorated rolling policy", condition1); assertEquals("Unexpected max history", (long) MAX_HISTORY, (long) ((TimeBasedRollingPolicy) rollingPolicy).getMaxHistory()); assertEquals("Unexpected file name pattern", _testLogFileName + ".%d{yyyy-MM-dd}.%i.gz", ((TimeBasedRollingPolicy) rollingPolicy).getFileNamePattern()); assertEquals("Unexpected compression mode", CompressionMode.GZ, rollingPolicy.getCompressionMode()); TriggeringPolicy triggeringPolicy = ((TimeBasedRollingPolicy) rollingPolicy).getTimeBasedFileNamingAndTriggeringPolicy(); final boolean condition = triggeringPolicy instanceof AppenderUtils.DailyTriggeringPolicy; assertTrue("Unexpected triggering policy", condition); assertEquals("Unexpected triggering policy", String.valueOf(MAX_FILE_SIZE) + " MB", ((AppenderUtils.DailyTriggeringPolicy) triggeringPolicy).getMaxFileSize().toString()); assertEquals("Unexpected layout", LAYOUT, ((PatternLayoutEncoder) appender.getEncoder()).getPattern()); } @Test public void testCreateRollingFileAppenderNonDailyRolling() { when(_settings.isRollDaily()).thenReturn(Boolean.FALSE); when(_settings.isCompressOldFiles()).thenReturn(Boolean.FALSE); RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>(); AppenderUtils.configureRollingFileAppender(_settings, new LoggerContext(), appender); assertEquals("Unexpected appender file name", _testLogFileName, appender.getFile()); RollingPolicy rollingPolicy = appender.getRollingPolicy(); final boolean condition2 = rollingPolicy instanceof RollingPolicyDecorator; assertTrue("Unexpected rolling policy", condition2); rollingPolicy = ((RollingPolicyDecorator)rollingPolicy).getDecorated(); final boolean condition1 = rollingPolicy instanceof AppenderUtils.SimpleRollingPolicy; assertTrue("Unexpected decorated rolling policy", condition1); assertEquals("Unexpected max history", (long) MAX_HISTORY, (long) ((AppenderUtils.SimpleRollingPolicy) rollingPolicy).getMaxIndex()); assertEquals("Unexpected file name pattern", _testLogFileName + ".%i", ((AppenderUtils.SimpleRollingPolicy) rollingPolicy).getFileNamePattern()); assertEquals("Unexpected compression mode", CompressionMode.NONE, rollingPolicy.getCompressionMode()); TriggeringPolicy triggeringPolicy = appender.getTriggeringPolicy(); assertEquals("Unexpected triggering policy", String.valueOf(MAX_FILE_SIZE) + " MB", ((AppenderUtils.SizeTriggeringPolicy) triggeringPolicy).getMaxFileSize().toString()); Encoder encoder = appender.getEncoder(); final boolean condition = encoder instanceof PatternLayoutEncoder; assertTrue("Unexpected encoder", condition); assertEquals("Unexpected layout pattern", LAYOUT, ((PatternLayoutEncoder)encoder).getPattern()); }
ChannelMessages { public static LogMessage FLOW(String param1) { String rawMessage = _messages.getString("FLOW"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return FLOW_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ChannelMessages(); static LogMessage CLOSE(); static LogMessage CLOSE_FORCED(Number param1, String param2); static LogMessage CREATE(); static LogMessage DEADLETTERMSG(Number param1, String param2); static LogMessage DISCARDMSG_NOALTEXCH(Number param1, String param2, String param3); static LogMessage DISCARDMSG_NOROUTE(Number param1, String param2); static LogMessage FLOW(String param1); static LogMessage FLOW_CONTROL_IGNORED(); static LogMessage FLOW_ENFORCED(String param1); static LogMessage FLOW_REMOVED(); static LogMessage OPERATION(String param1); static LogMessage PREFETCH_SIZE(Number param1, Number param2); static final String CHANNEL_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String CLOSE_FORCED_LOG_HIERARCHY; static final String CREATE_LOG_HIERARCHY; static final String DEADLETTERMSG_LOG_HIERARCHY; static final String DISCARDMSG_NOALTEXCH_LOG_HIERARCHY; static final String DISCARDMSG_NOROUTE_LOG_HIERARCHY; static final String FLOW_LOG_HIERARCHY; static final String FLOW_CONTROL_IGNORED_LOG_HIERARCHY; static final String FLOW_ENFORCED_LOG_HIERARCHY; static final String FLOW_REMOVED_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PREFETCH_SIZE_LOG_HIERARCHY; }
@Test public void testChannelFlow() { String flow = "ON"; _logMessage = ChannelMessages.FLOW(flow); List<Object> log = performLog(); String[] expected = {"Flow", flow}; validateLogMessage(log, "CHN-1002", expected); }
ChannelMessages { public static LogMessage CLOSE() { String rawMessage = _messages.getString("CLOSE"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CLOSE_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ChannelMessages(); static LogMessage CLOSE(); static LogMessage CLOSE_FORCED(Number param1, String param2); static LogMessage CREATE(); static LogMessage DEADLETTERMSG(Number param1, String param2); static LogMessage DISCARDMSG_NOALTEXCH(Number param1, String param2, String param3); static LogMessage DISCARDMSG_NOROUTE(Number param1, String param2); static LogMessage FLOW(String param1); static LogMessage FLOW_CONTROL_IGNORED(); static LogMessage FLOW_ENFORCED(String param1); static LogMessage FLOW_REMOVED(); static LogMessage OPERATION(String param1); static LogMessage PREFETCH_SIZE(Number param1, Number param2); static final String CHANNEL_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String CLOSE_FORCED_LOG_HIERARCHY; static final String CREATE_LOG_HIERARCHY; static final String DEADLETTERMSG_LOG_HIERARCHY; static final String DISCARDMSG_NOALTEXCH_LOG_HIERARCHY; static final String DISCARDMSG_NOROUTE_LOG_HIERARCHY; static final String FLOW_LOG_HIERARCHY; static final String FLOW_CONTROL_IGNORED_LOG_HIERARCHY; static final String FLOW_ENFORCED_LOG_HIERARCHY; static final String FLOW_REMOVED_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PREFETCH_SIZE_LOG_HIERARCHY; }
@Test public void testChannelClose() { _logMessage = ChannelMessages.CLOSE(); List<Object> log = performLog(); String[] expected = {"Close"}; validateLogMessage(log, "CHN-1003", expected); }
ChannelMessages { public static LogMessage CLOSE_FORCED(Number param1, String param2) { String rawMessage = _messages.getString("CLOSE_FORCED"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CLOSE_FORCED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ChannelMessages(); static LogMessage CLOSE(); static LogMessage CLOSE_FORCED(Number param1, String param2); static LogMessage CREATE(); static LogMessage DEADLETTERMSG(Number param1, String param2); static LogMessage DISCARDMSG_NOALTEXCH(Number param1, String param2, String param3); static LogMessage DISCARDMSG_NOROUTE(Number param1, String param2); static LogMessage FLOW(String param1); static LogMessage FLOW_CONTROL_IGNORED(); static LogMessage FLOW_ENFORCED(String param1); static LogMessage FLOW_REMOVED(); static LogMessage OPERATION(String param1); static LogMessage PREFETCH_SIZE(Number param1, Number param2); static final String CHANNEL_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String CLOSE_FORCED_LOG_HIERARCHY; static final String CREATE_LOG_HIERARCHY; static final String DEADLETTERMSG_LOG_HIERARCHY; static final String DISCARDMSG_NOALTEXCH_LOG_HIERARCHY; static final String DISCARDMSG_NOROUTE_LOG_HIERARCHY; static final String FLOW_LOG_HIERARCHY; static final String FLOW_CONTROL_IGNORED_LOG_HIERARCHY; static final String FLOW_ENFORCED_LOG_HIERARCHY; static final String FLOW_REMOVED_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String PREFETCH_SIZE_LOG_HIERARCHY; }
@Test public void testChannelCloseForced() { _logMessage = ChannelMessages.CLOSE_FORCED(1, "Test"); List<Object> log = performLog(); String[] expected = {"Close : 1 - Test"}; validateLogMessage(log, "CHN-1003", expected); }
ConnectionMessages { public static LogMessage OPEN(String param1, String param2, String param3, String param4, String param5, String param6, boolean opt1, boolean opt2, boolean opt3, boolean opt4) { String rawMessage = _messages.getString("OPEN"); StringBuffer msg = new StringBuffer(); String[] parts = rawMessage.split("\\["); msg.append(parts[0]); int end; if (parts.length > 1) { end = parts[1].indexOf(']'); if (opt1) { msg.append(parts[1].substring(0, end)); } msg.append(parts[1].substring(end + 1)); end = parts[2].indexOf(']'); if (opt2) { msg.append(parts[2].substring(0, end)); } msg.append(parts[2].substring(end + 1)); end = parts[3].indexOf(']'); if (opt3) { msg.append(parts[3].substring(0, end)); } msg.append(parts[3].substring(end + 1)); end = parts[4].indexOf(']'); if (opt4) { msg.append(parts[4].substring(0, end)); } msg.append(parts[4].substring(end + 1)); } rawMessage = msg.toString(); final Object[] messageArguments = {param1, param2, param3, param4, param5, param6}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return OPEN_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ConnectionMessages(); static LogMessage CLIENT_VERSION_LOG(String param1); static LogMessage CLIENT_VERSION_REJECT(String param1); static LogMessage CLOSE(String param1, boolean opt1); static LogMessage DROPPED_CONNECTION(); static LogMessage IDLE_CLOSE(String param1, boolean opt1); static LogMessage IDLE_TXN(Number param1); static LogMessage LARGE_TRANSACTION_WARN(Number param1, Number param2); static LogMessage MODEL_DELETE(); static LogMessage OPEN(String param1, String param2, String param3, String param4, String param5, String param6, boolean opt1, boolean opt2, boolean opt3, boolean opt4); static LogMessage OPEN_TXN(Number param1); static LogMessage OPERATION(String param1); static final String CONNECTION_LOG_HIERARCHY; static final String CLIENT_VERSION_LOG_LOG_HIERARCHY; static final String CLIENT_VERSION_REJECT_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String DROPPED_CONNECTION_LOG_HIERARCHY; static final String IDLE_CLOSE_LOG_HIERARCHY; static final String IDLE_TXN_LOG_HIERARCHY; static final String LARGE_TRANSACTION_WARN_LOG_HIERARCHY; static final String MODEL_DELETE_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String OPEN_TXN_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testConnectionOpen_WithOptional() { String port = "myport"; String local = "127.0.0.1:5672"; String protocolVersion = "0-8"; String clientID = "client"; String clientVersion = "1.2.3_4"; String clientProduct = "myProduct"; _logMessage = ConnectionMessages.OPEN(port, local, protocolVersion, clientID, clientVersion, clientProduct , false, true, true, true); List<Object> log = performLog(); String[] expected = {"Open", ": Destination", "myport(127.0.0.1:5672)", ": Protocol Version :", protocolVersion, ": Client ID", clientID, ": Client Version :", clientVersion, ": Client Product :", clientProduct}; validateLogMessage(log, "CON-1001", expected); } @Test public void testConnectionOpen() { String port = "myport"; String local = "127.0.0.1:5672"; String protocolVersion = "0-8"; _logMessage = ConnectionMessages.OPEN(port, local, protocolVersion, null, null, null , false, false, false, false); List<Object> log = performLog(); String[] expected = {"Open", ": Destination", "myport(127.0.0.1:5672)", ": Protocol Version :", protocolVersion}; validateLogMessage(log, "CON-1001", expected); } @Test public void testSslConnectionOpen() { String port = "myport"; String local = "127.0.0.1:5672"; String protocolVersion = "0-8"; _logMessage = ConnectionMessages.OPEN(port, local, protocolVersion, null, null, null , true, false, false, false); List<Object> log = performLog(); String[] expected = {"Open", ": Destination", "myport(127.0.0.1:5672)", ": Protocol Version :", protocolVersion, ": SSL"}; validateLogMessage(log, "CON-1001", expected); }
ConnectionMessages { public static LogMessage CLOSE(String param1, boolean opt1) { String rawMessage = _messages.getString("CLOSE"); StringBuffer msg = new StringBuffer(); String[] parts = rawMessage.split("\\["); msg.append(parts[0]); int end; if (parts.length > 1) { end = parts[1].indexOf(']'); if (opt1) { msg.append(parts[1].substring(0, end)); } msg.append(parts[1].substring(end + 1)); } rawMessage = msg.toString(); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CLOSE_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ConnectionMessages(); static LogMessage CLIENT_VERSION_LOG(String param1); static LogMessage CLIENT_VERSION_REJECT(String param1); static LogMessage CLOSE(String param1, boolean opt1); static LogMessage DROPPED_CONNECTION(); static LogMessage IDLE_CLOSE(String param1, boolean opt1); static LogMessage IDLE_TXN(Number param1); static LogMessage LARGE_TRANSACTION_WARN(Number param1, Number param2); static LogMessage MODEL_DELETE(); static LogMessage OPEN(String param1, String param2, String param3, String param4, String param5, String param6, boolean opt1, boolean opt2, boolean opt3, boolean opt4); static LogMessage OPEN_TXN(Number param1); static LogMessage OPERATION(String param1); static final String CONNECTION_LOG_HIERARCHY; static final String CLIENT_VERSION_LOG_LOG_HIERARCHY; static final String CLIENT_VERSION_REJECT_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String DROPPED_CONNECTION_LOG_HIERARCHY; static final String IDLE_CLOSE_LOG_HIERARCHY; static final String IDLE_TXN_LOG_HIERARCHY; static final String LARGE_TRANSACTION_WARN_LOG_HIERARCHY; static final String MODEL_DELETE_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String OPEN_TXN_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; }
@Test public void testConnectionClose() { _logMessage = ConnectionMessages.CLOSE(null, false); List<Object> log = performLog(); String[] expected = {"Close"}; validateLogMessage(log, "CON-1002", expected); } @Test public void testConnectionCloseWithCause() { _logMessage = ConnectionMessages.CLOSE("Test", true); List<Object> log = performLog(); String[] expected = {"Close : Test"}; validateLogMessage(log, "CON-1002", expected); }
QueueMessages { public static LogMessage CREATED(String param1, String param2, Number param3, boolean opt1, boolean opt2, boolean opt3, boolean opt4, boolean opt5) { String rawMessage = _messages.getString("CREATED"); StringBuffer msg = new StringBuffer(); String[] parts = rawMessage.split("\\["); msg.append(parts[0]); int end; if (parts.length > 1) { end = parts[1].indexOf(']'); if (opt1) { msg.append(parts[1].substring(0, end)); } msg.append(parts[1].substring(end + 1)); end = parts[2].indexOf(']'); if (opt2) { msg.append(parts[2].substring(0, end)); } msg.append(parts[2].substring(end + 1)); end = parts[3].indexOf(']'); if (opt3) { msg.append(parts[3].substring(0, end)); } msg.append(parts[3].substring(end + 1)); end = parts[4].indexOf(']'); if (opt4) { msg.append(parts[4].substring(0, end)); } msg.append(parts[4].substring(end + 1)); end = parts[5].indexOf(']'); if (opt5) { msg.append(parts[5].substring(0, end)); } msg.append(parts[5].substring(end + 1)); } rawMessage = msg.toString(); final Object[] messageArguments = {param1, param2, param3}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CREATED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private QueueMessages(); static LogMessage CREATED(String param1, String param2, Number param3, boolean opt1, boolean opt2, boolean opt3, boolean opt4, boolean opt5); static LogMessage DELETED(String param1); static LogMessage DROPPED(Number param1, Number param2, Number param3, Number param4, Number param5); static LogMessage MALFORMED_MESSAGE(String param1, String param2); static LogMessage OPERATION(String param1); static LogMessage OVERFULL(Number param1, Number param2, Number param3, Number param4); static LogMessage UNDERFULL(Number param1, Number param2, Number param3, Number param4); static final String QUEUE_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String DELETED_LOG_HIERARCHY; static final String DROPPED_LOG_HIERARCHY; static final String MALFORMED_MESSAGE_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testQueueCreatedALL() { String owner = "guest"; Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid",owner, priority, true, true, true, true, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Durable", "Transient", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDelete() { String owner = "guest"; _logMessage = QueueMessages.CREATED("uuid", owner, null, true, true, false, false, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerPriority() { String owner = "guest"; Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", owner, priority, true, false, false, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDeletePriority() { String owner = "guest"; Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", owner, priority, true, true, false, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDeleteTransient() { String owner = "guest"; _logMessage = QueueMessages.CREATED("uuid", owner, null, true, true, false, true, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Transient"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDeleteTransientPriority() { String owner = "guest"; Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", owner, priority, true, true, false, true, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Transient", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDeleteDurable() { String owner = "guest"; _logMessage = QueueMessages.CREATED("uuid", owner, null, true, true, true, false, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Durable"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedOwnerAutoDeleteDurablePriority() { String owner = "guest"; Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", owner, priority, true, true, true, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Owner:", owner, "AutoDelete", "Durable", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDelete() { _logMessage = QueueMessages.CREATED("uuid", null, null, false, true, false, false, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "AutoDelete"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedPriority() { Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", null, priority, false, false, false, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDeletePriority() { Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", null, priority, false, true, false, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "AutoDelete", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDeleteTransient() { _logMessage = QueueMessages.CREATED("uuid", null, null, false, true, false, true, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "AutoDelete", "Transient"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDeleteTransientPriority() { Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", null, priority, false, true, false, true, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "AutoDelete", "Transient", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDeleteDurable() { _logMessage = QueueMessages.CREATED("uuid", null, null, false, true, true, false, false); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "AutoDelete", "Durable"}; validateLogMessage(log, "QUE-1001", expected); } @Test public void testQueueCreatedAutoDeleteDurablePriority() { Integer priority = 3; _logMessage = QueueMessages.CREATED("uuid", null, priority, false, true, true, false, true); List<Object> log = performLog(); String[] expected = {"Create :", "ID:", "uuid", "AutoDelete", "Durable", "Priority:", String.valueOf(priority)}; validateLogMessage(log, "QUE-1001", expected); }
AppenderUtils { static void validateMaxFileSize(final int maxFileSize) { if (maxFileSize < 1) { throw new IllegalConfigurationException(String.format("Maximum file size must be at least 1. Cannot set to %d.", maxFileSize)); } } static void configureRollingFileAppender(FileLoggerSettings fileLoggerSettings, Context loggerContext, RollingFileAppender<ILoggingEvent> appender); }
@Test public void testMaxFileSizeLimit() throws Exception { try { AppenderUtils.validateMaxFileSize(0); fail("exception not thrown."); } catch (IllegalConfigurationException ice) { } }
QueueMessages { public static LogMessage DELETED(String param1) { String rawMessage = _messages.getString("DELETED"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return DELETED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private QueueMessages(); static LogMessage CREATED(String param1, String param2, Number param3, boolean opt1, boolean opt2, boolean opt3, boolean opt4, boolean opt5); static LogMessage DELETED(String param1); static LogMessage DROPPED(Number param1, Number param2, Number param3, Number param4, Number param5); static LogMessage MALFORMED_MESSAGE(String param1, String param2); static LogMessage OPERATION(String param1); static LogMessage OVERFULL(Number param1, Number param2, Number param3, Number param4); static LogMessage UNDERFULL(Number param1, Number param2, Number param3, Number param4); static final String QUEUE_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String DELETED_LOG_HIERARCHY; static final String DROPPED_LOG_HIERARCHY; static final String MALFORMED_MESSAGE_LOG_HIERARCHY; static final String OPERATION_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testQueueDeleted() { _logMessage = QueueMessages.DELETED("uuid"); List<Object> log = performLog(); String[] expected = {"Deleted", "ID:", "uuid"}; validateLogMessage(log, "QUE-1002", expected); }
ManagementConsoleMessages { public static LogMessage STARTUP(String param1) { String rawMessage = _messages.getString("STARTUP"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return STARTUP_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ManagementConsoleMessages(); static LogMessage CLOSE(String param1); static LogMessage LISTENING(String param1, String param2, Number param3); static LogMessage OPEN(String param1); static LogMessage READY(String param1); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1); static LogMessage STOPPED(String param1); static final String MANAGEMENTCONSOLE_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testManagementStartup() { _logMessage = ManagementConsoleMessages.STARTUP("My"); List<Object> log = performLog(); String[] expected = {"My Management Startup"}; validateLogMessage(log, "MNG-1001", expected); }
ManagementConsoleMessages { public static LogMessage LISTENING(String param1, String param2, Number param3) { String rawMessage = _messages.getString("LISTENING"); final Object[] messageArguments = {param1, param2, param3}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return LISTENING_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ManagementConsoleMessages(); static LogMessage CLOSE(String param1); static LogMessage LISTENING(String param1, String param2, Number param3); static LogMessage OPEN(String param1); static LogMessage READY(String param1); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1); static LogMessage STOPPED(String param1); static final String MANAGEMENTCONSOLE_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testManagementListening() { String management = "HTTP"; Integer port = 8889; _logMessage = ManagementConsoleMessages.LISTENING(management, Transport.TCP.name(), port); List<Object> log = performLog(); String[] expected = {"Starting :", management, ": Listening on ", Transport.TCP.name(), " port", String.valueOf(port)}; validateLogMessage(log, "MNG-1002", expected); }
ManagementConsoleMessages { public static LogMessage SHUTTING_DOWN(String param1, Number param2) { String rawMessage = _messages.getString("SHUTTING_DOWN"); final Object[] messageArguments = {param1, param2}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return SHUTTING_DOWN_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ManagementConsoleMessages(); static LogMessage CLOSE(String param1); static LogMessage LISTENING(String param1, String param2, Number param3); static LogMessage OPEN(String param1); static LogMessage READY(String param1); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1); static LogMessage STOPPED(String param1); static final String MANAGEMENTCONSOLE_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testManagementShuttingDown() { String transport = "HTTP"; Integer port = 8889; _logMessage = ManagementConsoleMessages.SHUTTING_DOWN(transport, port); List<Object> log = performLog(); String[] expected = {"Shutting down :", transport, ": port", String.valueOf(port)}; validateLogMessage(log, "MNG-1003", expected); }
ManagementConsoleMessages { public static LogMessage READY(String param1) { String rawMessage = _messages.getString("READY"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return READY_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ManagementConsoleMessages(); static LogMessage CLOSE(String param1); static LogMessage LISTENING(String param1, String param2, Number param3); static LogMessage OPEN(String param1); static LogMessage READY(String param1); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1); static LogMessage STOPPED(String param1); static final String MANAGEMENTCONSOLE_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testManagementReady() { _logMessage = ManagementConsoleMessages.READY("My"); List<Object> log = performLog(); String[] expected = {"My Management Ready"}; validateLogMessage(log, "MNG-1004", expected); }
ManagementConsoleMessages { public static LogMessage STOPPED(String param1) { String rawMessage = _messages.getString("STOPPED"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return STOPPED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private ManagementConsoleMessages(); static LogMessage CLOSE(String param1); static LogMessage LISTENING(String param1, String param2, Number param3); static LogMessage OPEN(String param1); static LogMessage READY(String param1); static LogMessage SHUTTING_DOWN(String param1, Number param2); static LogMessage STARTUP(String param1); static LogMessage STOPPED(String param1); static final String MANAGEMENTCONSOLE_LOG_HIERARCHY; static final String CLOSE_LOG_HIERARCHY; static final String LISTENING_LOG_HIERARCHY; static final String OPEN_LOG_HIERARCHY; static final String READY_LOG_HIERARCHY; static final String SHUTTING_DOWN_LOG_HIERARCHY; static final String STARTUP_LOG_HIERARCHY; static final String STOPPED_LOG_HIERARCHY; }
@Test public void testManagementStopped() { _logMessage = ManagementConsoleMessages.STOPPED("My"); List<Object> log = performLog(); String[] expected = {"My Management Stopped"}; validateLogMessage(log, "MNG-1005", expected); }
MessageStoreMessages { public static LogMessage CREATED() { String rawMessage = _messages.getString("CREATED"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CREATED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private MessageStoreMessages(); static LogMessage CLOSED(); static LogMessage CREATED(); static LogMessage OVERFULL(); static LogMessage RECOVERED(Number param1); static LogMessage RECOVERY_COMPLETE(); static LogMessage RECOVERY_START(); static LogMessage STORE_LOCATION(String param1); static LogMessage UNDERFULL(); static final String MESSAGESTORE_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String RECOVERED_LOG_HIERARCHY; static final String RECOVERY_COMPLETE_LOG_HIERARCHY; static final String RECOVERY_START_LOG_HIERARCHY; static final String STORE_LOCATION_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testMessageStoreCreated() { _logMessage = MessageStoreMessages.CREATED(); List<Object> log = performLog(); String[] expected = {"Created"}; validateLogMessage(log, "MST-1001", expected); }
QpidLoggerTurboFilter extends TurboFilter { public static void uninstall(LoggerContext context) { context.getTurboFilterList().remove(new QpidLoggerTurboFilter()); } QpidLoggerTurboFilter(); @Override FilterReply decide(final Marker marker, final Logger logger, final Level level, final String format, final Object[] params, final Throwable t); void filterAdded(EffectiveLevelFilter filter); void filterRemoved(EffectiveLevelFilter filter); void filterChanged(EffectiveLevelFilter filter); @Override boolean equals(final Object o); @Override int hashCode(); static QpidLoggerTurboFilter installIfNecessary(LoggerContext loggerContext); static QpidLoggerTurboFilter installIfNecessaryToRootContext(); static void uninstallFromRootContext(); static void uninstall(LoggerContext context); static void filterAdded(EffectiveLevelFilter filter, LoggerContext context); static void filterRemoved(EffectiveLevelFilter filter, LoggerContext context); static void filterAddedToRootContext(EffectiveLevelFilter filter); static void filterRemovedFromRootContext(EffectiveLevelFilter filter); static void filterChangedOnRootContext(final EffectiveLevelFilter filter); }
@Test public void testUninstall() { Logger fooBarLogger = _loggerContext.getLogger("foo.bar"); assertFalse( "Debug should not be enabled when QpidLoggerTurboFilter is installed but no regular filter is set", fooBarLogger.isDebugEnabled()); QpidLoggerTurboFilter.uninstall(_loggerContext); assertTrue("Debug should be enabled as per test logback configuration", fooBarLogger.isDebugEnabled()); }
MessageStoreMessages { public static LogMessage STORE_LOCATION(String param1) { String rawMessage = _messages.getString("STORE_LOCATION"); final Object[] messageArguments = {param1}; MessageFormat formatter = new MessageFormat(rawMessage, _currentLocale); final String message = formatter.format(messageArguments); return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return STORE_LOCATION_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private MessageStoreMessages(); static LogMessage CLOSED(); static LogMessage CREATED(); static LogMessage OVERFULL(); static LogMessage RECOVERED(Number param1); static LogMessage RECOVERY_COMPLETE(); static LogMessage RECOVERY_START(); static LogMessage STORE_LOCATION(String param1); static LogMessage UNDERFULL(); static final String MESSAGESTORE_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String RECOVERED_LOG_HIERARCHY; static final String RECOVERY_COMPLETE_LOG_HIERARCHY; static final String RECOVERY_START_LOG_HIERARCHY; static final String STORE_LOCATION_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testMessageStoreStoreLocation() { String location = "/path/to/the/message/store.files"; _logMessage = MessageStoreMessages.STORE_LOCATION(location); List<Object> log = performLog(); String[] expected = {"Store location :", location}; validateLogMessage(log, "MST-1002", expected); }
MessageStoreMessages { public static LogMessage CLOSED() { String rawMessage = _messages.getString("CLOSED"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return CLOSED_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private MessageStoreMessages(); static LogMessage CLOSED(); static LogMessage CREATED(); static LogMessage OVERFULL(); static LogMessage RECOVERED(Number param1); static LogMessage RECOVERY_COMPLETE(); static LogMessage RECOVERY_START(); static LogMessage STORE_LOCATION(String param1); static LogMessage UNDERFULL(); static final String MESSAGESTORE_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String RECOVERED_LOG_HIERARCHY; static final String RECOVERY_COMPLETE_LOG_HIERARCHY; static final String RECOVERY_START_LOG_HIERARCHY; static final String STORE_LOCATION_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testMessageStoreClosed() { _logMessage = MessageStoreMessages.CLOSED(); List<Object> log = performLog(); String[] expected = {"Closed"}; validateLogMessage(log, "MST-1003", expected); }
MessageStoreMessages { public static LogMessage RECOVERY_START() { String rawMessage = _messages.getString("RECOVERY_START"); final String message = rawMessage; return new LogMessage() { @Override public String toString() { return message; } @Override public String getLogHierarchy() { return RECOVERY_START_LOG_HIERARCHY; } @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final LogMessage that = (LogMessage) o; return getLogHierarchy().equals(that.getLogHierarchy()) && toString().equals(that.toString()); } @Override public int hashCode() { int result = toString().hashCode(); result = 31 * result + getLogHierarchy().hashCode(); return result; } }; } private MessageStoreMessages(); static LogMessage CLOSED(); static LogMessage CREATED(); static LogMessage OVERFULL(); static LogMessage RECOVERED(Number param1); static LogMessage RECOVERY_COMPLETE(); static LogMessage RECOVERY_START(); static LogMessage STORE_LOCATION(String param1); static LogMessage UNDERFULL(); static final String MESSAGESTORE_LOG_HIERARCHY; static final String CLOSED_LOG_HIERARCHY; static final String CREATED_LOG_HIERARCHY; static final String OVERFULL_LOG_HIERARCHY; static final String RECOVERED_LOG_HIERARCHY; static final String RECOVERY_COMPLETE_LOG_HIERARCHY; static final String RECOVERY_START_LOG_HIERARCHY; static final String STORE_LOCATION_LOG_HIERARCHY; static final String UNDERFULL_LOG_HIERARCHY; }
@Test public void testMessageStoreRecoveryStart() { _logMessage = MessageStoreMessages.RECOVERY_START(); List<Object> log = performLog(); String[] expected = {"Recovery Start"}; validateLogMessage(log, "MST-1004", expected); }
TrustStoreMessageSource extends AbstractSystemMessageSource { @Override public <T extends ConsumerTarget<T>> Consumer<T> addConsumer(final T target, final FilterManager filters, final Class<? extends ServerMessage> messageClass, final String consumerName, final EnumSet<ConsumerOption> options, final Integer priority) throws ExistingExclusiveConsumer, ExistingConsumerPreventsExclusive, ConsumerAccessRefused, QueueDeleted { final Consumer<T> consumer = super.addConsumer(target, filters, messageClass, consumerName, options, priority); consumer.send(createMessage()); target.noMessagesAvailable(); return consumer; } TrustStoreMessageSource(final TrustStore<?> trustStore, final VirtualHost<?> virtualHost); @Override Consumer<T> addConsumer(final T target, final FilterManager filters, final Class<? extends ServerMessage> messageClass, final String consumerName, final EnumSet<ConsumerOption> options, final Integer priority); @Override void close(); static String getSourceNameFromTrustStore(final TrustStore<?> trustStore); }
@Test public void testAddConsumer() throws Exception { final EnumSet<ConsumerOption> options = EnumSet.noneOf(ConsumerOption.class); final ConsumerTarget target = mock(ConsumerTarget.class); when(target.allocateCredit(any(ServerMessage.class))).thenReturn(true); MessageInstanceConsumer consumer = _trustStoreMessageSource.addConsumer(target, null, ServerMessage.class, getTestName(), options, 0); final MessageContainer messageContainer = consumer.pullMessage(); assertNotNull("Could not pull message of TrustStore", messageContainer); final ServerMessage message = messageContainer.getMessageInstance().getMessage(); assertCertificates(getCertificatesFromMessage(message)); }
AESKeyFileEncrypterFactory implements ConfigurationSecretEncrypterFactory, ConditionallyAvailable { @Override public ConfigurationSecretEncrypter createEncrypter(final ConfiguredObject<?> object) { String fileLocation; if(object.getContextKeys(false).contains(ENCRYPTER_KEY_FILE)) { fileLocation = object.getContextValue(String.class, ENCRYPTER_KEY_FILE); } else { fileLocation = object.getContextValue(String.class, SystemConfig.QPID_WORK_DIR) + File.separator + DEFAULT_KEYS_SUBDIR_NAME + File.separator + object.getCategoryClass().getSimpleName() + "_" + object.getName() + ".key"; Map<String, String> context = object.getContext(); Map<String, String> modifiedContext = new LinkedHashMap<>(context); modifiedContext.put(ENCRYPTER_KEY_FILE, fileLocation); object.setAttributes(Collections.<String, Object>singletonMap(ConfiguredObject.CONTEXT, modifiedContext)); } File file = new File(fileLocation); if(!file.exists()) { LOGGER.warn("Configuration encryption is enabled, but no configuration secret was found. A new configuration secret will be created at '{}'.", fileLocation); createAndPopulateKeyFile(file); } if(!file.isFile()) { throw new IllegalArgumentException("File '"+fileLocation+"' is not a regular file."); } try { checkFilePermissions(fileLocation, file); if(Files.size(file.toPath()) != AES_KEY_SIZE_BYTES) { throw new IllegalArgumentException("Key file '" + fileLocation + "' contains an incorrect about of data"); } try(FileInputStream inputStream = new FileInputStream(file)) { byte[] key = new byte[AES_KEY_SIZE_BYTES]; int pos = 0; int read; while(pos < key.length && -1 != ( read = inputStream.read(key, pos, key.length - pos))) { pos += read; } if(pos != key.length) { throw new IllegalConfigurationException("Key file '" + fileLocation + "' contained an incorrect about of data"); } SecretKeySpec keySpec = new SecretKeySpec(key, AES_ALGORITHM); return new AESKeyFileEncrypter(keySpec); } } catch (IOException e) { throw new IllegalConfigurationException("Unable to get file permissions: " + e.getMessage(), e); } } @Override ConfigurationSecretEncrypter createEncrypter(final ConfiguredObject<?> object); @Override String getType(); @Override boolean isAvailable(); static final String TYPE; }
@Test public void testCreateKeyInDefaultLocation() throws Exception { if(isStrongEncryptionEnabled() && supportsPosixFileAttributes()) { ConfigurationSecretEncrypter encrypter = _factory.createEncrypter(_broker); KeyFilePathChecker keyFilePathChecker = new KeyFilePathChecker(); doChecks(encrypter, keyFilePathChecker); String pathName = (String) _broker.getContext().get(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE); assertEquals(keyFilePathChecker.getKeyFile().toString(), pathName); } } @Test public void testSettingContextKeyLeadsToFileCreation() throws Exception { if(isStrongEncryptionEnabled() && supportsPosixFileAttributes()) { String filename = UUID.randomUUID().toString() + ".key"; String subdirName = getTestName() + File.separator + "test"; String fileLocation = _tmpDir.toString() + File.separator + subdirName + File.separator + filename; when(_broker.getContextKeys(eq(false))).thenReturn(Collections.singleton(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE)); when(_broker.getContextValue(eq(String.class), eq(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE))).thenReturn(fileLocation); ConfigurationSecretEncrypter encrypter = _factory.createEncrypter(_broker); KeyFilePathChecker keyFilePathChecker = new KeyFilePathChecker(subdirName, filename); doChecks(encrypter, keyFilePathChecker); } } @Test public void testUnableToCreateFileInSpecifiedLocation() throws Exception { if(isStrongEncryptionEnabled()) { String filename = UUID.randomUUID().toString() + ".key"; String subdirName = getTestName() + File.separator + "test"; String fileLocation = _tmpDir.toString() + File.separator + subdirName + File.separator + filename; when(_broker.getContextKeys(eq(false))).thenReturn(Collections.singleton(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE)); when(_broker.getContextValue(eq(String.class), eq(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE))).thenReturn(fileLocation); Files.createDirectories(Paths.get(fileLocation)); try { ConfigurationSecretEncrypter encrypter = _factory.createEncrypter(_broker); fail("should not be able to create a key file where a directory currently is"); } catch (IllegalArgumentException e) { } } } @Test public void testPermissionsAreChecked() throws Exception { if(isStrongEncryptionEnabled() && supportsPosixFileAttributes()) { String filename = UUID.randomUUID().toString() + ".key"; String subdirName = getTestName() + File.separator + "test"; String fileLocation = _tmpDir.toString() + File.separator + subdirName + File.separator + filename; when(_broker.getContextKeys(eq(false))).thenReturn(Collections.singleton(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE)); when(_broker.getContextValue(eq(String.class), eq(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE))).thenReturn(fileLocation); Files.createDirectories(Paths.get(_tmpDir.toString(), subdirName)); File file = new File(fileLocation); file.createNewFile(); Files.setPosixFilePermissions(file.toPath(), EnumSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.GROUP_READ)); try { ConfigurationSecretEncrypter encrypter = _factory.createEncrypter(_broker); fail("should not be able to create a key file where the file is readable"); } catch (IllegalArgumentException e) { } } } @Test public void testInvalidKey() throws Exception { if(isStrongEncryptionEnabled() && supportsPosixFileAttributes()) { String filename = UUID.randomUUID().toString() + ".key"; String subdirName = getTestName() + File.separator + "test"; String fileLocation = _tmpDir.toString() + File.separator + subdirName + File.separator + filename; when(_broker.getContextKeys(eq(false))).thenReturn(Collections.singleton(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE)); when(_broker.getContextValue(eq(String.class), eq(AESKeyFileEncrypterFactory.ENCRYPTER_KEY_FILE))).thenReturn(fileLocation); Files.createDirectories(Paths.get(_tmpDir.toString(), subdirName)); File file = new File(fileLocation); try (FileOutputStream fos = new FileOutputStream(file)) { fos.write("This is not an AES key. It is a string saying it is not an AES key".getBytes( StandardCharsets.US_ASCII)); } Files.setPosixFilePermissions(file.toPath(), EnumSet.of(PosixFilePermission.OWNER_READ)); try { ConfigurationSecretEncrypter encrypter = _factory.createEncrypter(_broker); fail("should not be able to start where the key is not a valid key"); } catch (IllegalArgumentException e) { } } }
AESKeyFileEncrypter implements ConfigurationSecretEncrypter { @Override public String encrypt(final String unencrypted) { byte[] unencryptedBytes = unencrypted.getBytes(StandardCharsets.UTF_8); try { byte[] ivbytes = new byte[AES_INITIALIZATION_VECTOR_LENGTH]; _random.nextBytes(ivbytes); Cipher cipher = Cipher.getInstance(CIPHER_NAME); cipher.init(Cipher.ENCRYPT_MODE, _secretKey, new IvParameterSpec(ivbytes)); byte[] encryptedBytes = readFromCipherStream(unencryptedBytes, cipher); byte[] output = new byte[AES_INITIALIZATION_VECTOR_LENGTH + encryptedBytes.length]; System.arraycopy(ivbytes, 0, output, 0, AES_INITIALIZATION_VECTOR_LENGTH); System.arraycopy(encryptedBytes, 0, output, AES_INITIALIZATION_VECTOR_LENGTH, encryptedBytes.length); return Base64.getEncoder().encodeToString(output); } catch (IOException | InvalidAlgorithmParameterException | InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException e) { throw new IllegalArgumentException("Unable to encrypt secret", e); } } AESKeyFileEncrypter(SecretKey secretKey); @Override String encrypt(final String unencrypted); @Override String decrypt(final String encrypted); }
@Test public void testEncryptingNullFails() throws Exception { if(isStrongEncryptionEnabled()) { try { SecretKeySpec secretKey = createSecretKey(); AESKeyFileEncrypter encrypter = new AESKeyFileEncrypter(secretKey); String encrypted = encrypter.encrypt(null); fail("Attempting to encrypt null should fail"); } catch (NullPointerException e) { } } }
StartupAppender extends AppenderBase<ILoggingEvent> { public void logToConsole() { Context context = getContext(); ConsoleAppender<ILoggingEvent> consoleAppender = new ConsoleAppender<>(); consoleAppender.setContext(context); PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder(); patternLayoutEncoder.setContext(context); patternLayoutEncoder.setPattern("%X{qpid.log.prefix}%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"); patternLayoutEncoder.start(); consoleAppender.addFilter(new Filter<ILoggingEvent>() { @Override public FilterReply decide(final ILoggingEvent event) { return event.getLevel().isGreaterOrEqual(_consoleAppenderAcceptLogLevel) ? FilterReply.ACCEPT : FilterReply.DENY; } }); consoleAppender.setEncoder(patternLayoutEncoder); consoleAppender.start(); replayAccumulatedEvents(consoleAppender); consoleAppender.stop(); } StartupAppender(); synchronized void replayAccumulatedEvents(Appender<ILoggingEvent> appender); void logToConsole(); @Override void stop(); static final String PROPERTY_STARTUP_FAILOVER_CONSOLE_LOG_LEVEL; }
@Test public void testLogToConsole() throws Exception { ILoggingEvent event1 = createMockLoggingEvent("org.apache.qpid.Test", Level.WARN, "Test1", "Test-Thread-1"); _startupAppender.doAppend(event1); ILoggingEvent event2 = createMockLoggingEvent("non.qpid.Test",Level.DEBUG, "Test2", "Test-Thread-2"); _startupAppender.doAppend(event2); ILoggingEvent event3 = createMockLoggingEvent("non.qpid.Test", Level.INFO, "Test3", "Test-Thread-3"); _startupAppender.doAppend(event3); ILoggingEvent event4 = createMockLoggingEvent("org.apache.qpid.Test", Level.DEBUG, "Test4", "Test-Thread-4"); _startupAppender.doAppend(event4); List<String> lines = logToConsoleAndCollectSystemOutputLines(); assertEquals("Unexpected number of log events", (long) 2, (long) lines.size()); assertTrue(lines.get(0).contains("Test1")); assertTrue(lines.get(1).contains("Test3")); }
AESKeyFileEncrypter implements ConfigurationSecretEncrypter { @Override public String decrypt(final String encrypted) { if(!isValidBase64(encrypted)) { throw new IllegalArgumentException("Encrypted value is not valid Base 64 data: '" + encrypted + "'"); } byte[] encryptedBytes = Strings.decodeBase64(encrypted); try { Cipher cipher = Cipher.getInstance(CIPHER_NAME); IvParameterSpec ivParameterSpec = new IvParameterSpec(encryptedBytes, 0, AES_INITIALIZATION_VECTOR_LENGTH); cipher.init(Cipher.DECRYPT_MODE, _secretKey, ivParameterSpec); return new String(readFromCipherStream(encryptedBytes, AES_INITIALIZATION_VECTOR_LENGTH, encryptedBytes.length - AES_INITIALIZATION_VECTOR_LENGTH, cipher), StandardCharsets.UTF_8); } catch (IOException | InvalidAlgorithmParameterException | InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException e) { throw new IllegalArgumentException("Unable to decrypt secret", e); } } AESKeyFileEncrypter(SecretKey secretKey); @Override String encrypt(final String unencrypted); @Override String decrypt(final String encrypted); }
@Test public void testDecryptNonsense() throws Exception { if(isStrongEncryptionEnabled()) { SecretKeySpec secretKey = createSecretKey(); AESKeyFileEncrypter encrypter = new AESKeyFileEncrypter(secretKey); try { encrypter.decrypt(null); fail("Should not decrypt a null value"); } catch (NullPointerException e) { } try { encrypter.decrypt(""); fail("Should not decrypt the empty String"); } catch (IllegalArgumentException e) { } try { encrypter.decrypt("thisisnonsense"); fail("Should not decrypt a small amount of nonsense"); } catch (IllegalArgumentException e) { } try { String answer = encrypter.decrypt("thisisn'tvalidBase64!soitshouldfailwithanIllegalArgumentException"); fail("Should not decrypt a larger amount of nonsense"); } catch (IllegalArgumentException e) { } } }
GroupPrincipal implements QpidPrincipal { @Override public String getName() { return _groupName; } GroupPrincipal(final String groupName, final ConfiguredObject<?> origin); @Override String getName(); boolean addMember(Principal user); boolean removeMember(Principal user); boolean isMember(Principal member); Enumeration<? extends Principal> members(); @Override ConfiguredObject<?> getOrigin(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testGetName() { final GroupPrincipal principal = new GroupPrincipal("group", (GroupProvider) null); assertEquals("group", principal.getName()); }
GroupPrincipal implements QpidPrincipal { public boolean addMember(Principal user) { throw new UnsupportedOperationException(msgException); } GroupPrincipal(final String groupName, final ConfiguredObject<?> origin); @Override String getName(); boolean addMember(Principal user); boolean removeMember(Principal user); boolean isMember(Principal member); Enumeration<? extends Principal> members(); @Override ConfiguredObject<?> getOrigin(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testAddRejected() { final GroupPrincipal principal = new GroupPrincipal("group", (GroupProvider) null); final UsernamePrincipal user = new UsernamePrincipal("name", null); try { principal.addMember(user); fail("Exception not thrown"); } catch (UnsupportedOperationException uso) { } }
GroupPrincipal implements QpidPrincipal { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final GroupPrincipal that = (GroupPrincipal) o; if (!_groupName.equals(that._groupName)) { return false; } return _origin != null ? _origin.equals(that._origin) : that._origin == null; } GroupPrincipal(final String groupName, final ConfiguredObject<?> origin); @Override String getName(); boolean addMember(Principal user); boolean removeMember(Principal user); boolean isMember(Principal member); Enumeration<? extends Principal> members(); @Override ConfiguredObject<?> getOrigin(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testEqualitySameName() { final String string = "string"; final GroupPrincipal principal1 = new GroupPrincipal(string, (GroupProvider) null); final GroupPrincipal principal2 = new GroupPrincipal(string, (GroupProvider) null); assertTrue(principal1.equals(principal2)); } @Test public void testEqualityEqualName() { final GroupPrincipal principal1 = new GroupPrincipal(new String("string"), (GroupProvider) null); final GroupPrincipal principal2 = new GroupPrincipal(new String("string"), (GroupProvider) null); assertTrue(principal1.equals(principal2)); } @Test public void testInequalityDifferentGroupPrincipals() { GroupPrincipal principal1 = new GroupPrincipal("string1", (GroupProvider) null); GroupPrincipal principal2 = new GroupPrincipal("string2", (GroupProvider) null); assertFalse(principal1.equals(principal2)); } @Test public void testInequalityNonGroupPrincipal() { GroupPrincipal principal = new GroupPrincipal("string", (GroupProvider) null); assertFalse(principal.equals(new UsernamePrincipal("string", null))); } @Test public void testInequalityNull() { GroupPrincipal principal = new GroupPrincipal("string", (GroupProvider) null); assertFalse(principal.equals(null)); }
FileGroupDatabase implements GroupDatabase { @Override public Set<String> getAllGroups() { return Collections.unmodifiableSet(_groupToUserMap.keySet()); } FileGroupDatabase(FileBasedGroupProvider<?> groupProvider); @Override Set<String> getAllGroups(); synchronized void setGroupFile(String groupFile); @Override Set<String> getUsersInGroup(String group); @Override synchronized void addUserToGroup(String user, String group); @Override synchronized void removeUserFromGroup(String user, String group); @Override Set<String> getGroupsForUser(String user); @Override synchronized void createGroup(String group); @Override synchronized void removeGroup(String group); }
@Test public void testGetAllGroups() throws Exception { _util.writeAndSetGroupFile("myGroup.users", USER1); Set<String> groups = _fileGroupDatabase.getAllGroups(); assertEquals(1, groups.size()); assertTrue(groups.contains(MY_GROUP)); } @Test public void testGetAllGroupsWhenGroupFileEmpty() { Set<String> groups = _fileGroupDatabase.getAllGroups(); assertTrue(groups.isEmpty()); }
StartupAppender extends AppenderBase<ILoggingEvent> { public synchronized void replayAccumulatedEvents(Appender<ILoggingEvent> appender) { for (ILoggingEvent event: _accumulatedLoggingEvents) { appender.doAppend(event); } } StartupAppender(); synchronized void replayAccumulatedEvents(Appender<ILoggingEvent> appender); void logToConsole(); @Override void stop(); static final String PROPERTY_STARTUP_FAILOVER_CONSOLE_LOG_LEVEL; }
@SuppressWarnings("unchecked") @Test public void testReplayAccumulatedEvents() { ILoggingEvent event1 = createMockLoggingEvent("org.apache.qpid.Test", Level.DEBUG, "Test1", "Test-Thread-1"); _startupAppender.doAppend(event1); ILoggingEvent event2 = createMockLoggingEvent("non.qpid.Test", Level.INFO, "Test2", "Test-Thread-2"); _startupAppender.doAppend(event2); Appender mockAppender = mock(Appender.class); _startupAppender.replayAccumulatedEvents(mockAppender); verify(mockAppender).doAppend(event1); verify(mockAppender).doAppend(event2); }
FileGroupDatabase implements GroupDatabase { public synchronized void setGroupFile(String groupFile) throws IOException { File file = new File(groupFile); if (!file.canRead()) { throw new FileNotFoundException(groupFile + " cannot be found or is not readable"); } readGroupFile(groupFile); } FileGroupDatabase(FileBasedGroupProvider<?> groupProvider); @Override Set<String> getAllGroups(); synchronized void setGroupFile(String groupFile); @Override Set<String> getUsersInGroup(String group); @Override synchronized void addUserToGroup(String user, String group); @Override synchronized void removeUserFromGroup(String user, String group); @Override Set<String> getGroupsForUser(String user); @Override synchronized void createGroup(String group); @Override synchronized void removeGroup(String group); }
@Test public void testMissingGroupFile() throws Exception { try { _fileGroupDatabase.setGroupFile("/not/a/file"); fail("Exception not thrown"); } catch (FileNotFoundException fnfe) { } }
FileGroupDatabase implements GroupDatabase { @Override public Set<String> getUsersInGroup(String group) { if (group == null) { LOGGER.warn("Requested user set for null group. Returning empty set."); return Collections.emptySet(); } Set<String> set = _groupToUserMap.get(keySearch(_groupToUserMap.keySet(), group)); if (set == null) { return Collections.emptySet(); } else { return Collections.unmodifiableSet(set); } } FileGroupDatabase(FileBasedGroupProvider<?> groupProvider); @Override Set<String> getAllGroups(); synchronized void setGroupFile(String groupFile); @Override Set<String> getUsersInGroup(String group); @Override synchronized void addUserToGroup(String user, String group); @Override synchronized void removeUserFromGroup(String user, String group); @Override Set<String> getGroupsForUser(String user); @Override synchronized void createGroup(String group); @Override synchronized void removeGroup(String group); }
@Test public void testGetUsersInGroup() throws Exception { _util.writeAndSetGroupFile("myGroup.users", "user1,user2,user3"); Set<String> users = _fileGroupDatabase.getUsersInGroup(MY_GROUP); assertNotNull(users); assertEquals(3, users.size()); } @Test public void testDuplicateUsersInGroupAreConflated() throws Exception { _util.writeAndSetGroupFile("myGroup.users", "user1,user1,user3,user1"); Set<String> users = _fileGroupDatabase.getUsersInGroup(MY_GROUP); assertNotNull(users); assertEquals(2, users.size()); } @Test public void testGetUsersWithEmptyGroup() throws Exception { _util.writeAndSetGroupFile("myGroup.users", ""); Set<String> users = _fileGroupDatabase.getUsersInGroup(MY_GROUP); assertNotNull(users); assertTrue(users.isEmpty()); } @Test public void testGetUsersInNonExistentGroup() throws Exception { _util.writeAndSetGroupFile("myGroup.users", "user1,user2,user3"); Set<String> users = _fileGroupDatabase.getUsersInGroup("groupDoesntExist"); assertNotNull(users); assertTrue(users.isEmpty()); } @Test public void testGetUsersInNullGroup() throws Exception { _util.writeAndSetGroupFile(); assertTrue(_fileGroupDatabase.getUsersInGroup(null).isEmpty()); }
FileGroupDatabase implements GroupDatabase { @Override public Set<String> getGroupsForUser(String user) { if (user == null) { LOGGER.warn("Requested group set for null user. Returning empty set."); return Collections.emptySet(); } Set<String> groups = _userToGroupMap.get(keySearch(_userToGroupMap.keySet(), user)); if (groups == null) { return Collections.emptySet(); } else { return Collections.unmodifiableSet(groups); } } FileGroupDatabase(FileBasedGroupProvider<?> groupProvider); @Override Set<String> getAllGroups(); synchronized void setGroupFile(String groupFile); @Override Set<String> getUsersInGroup(String group); @Override synchronized void addUserToGroup(String user, String group); @Override synchronized void removeUserFromGroup(String user, String group); @Override Set<String> getGroupsForUser(String user); @Override synchronized void createGroup(String group); @Override synchronized void removeGroup(String group); }
@Test public void testGetGroupPrincipalsForUserWhenUserBelongsToOneGroup() throws Exception { _util.writeAndSetGroupFile("myGroup.users", "user1,user2"); Set<String> groups = _fileGroupDatabase.getGroupsForUser(USER1); assertEquals(1, groups.size()); assertTrue(groups.contains(MY_GROUP)); } @Test public void testGetGroupPrincipalsForUserWhenUserBelongsToTwoGroup() throws Exception { _util.writeAndSetGroupFile("myGroup1.users", "user1,user2", "myGroup2.users", "user1,user3"); Set<String> groups = _fileGroupDatabase.getGroupsForUser(USER1); assertEquals(2, groups.size()); assertTrue(groups.contains(MY_GROUP1)); assertTrue(groups.contains(MY_GROUP2)); } @Test public void testGetGroupPrincipalsForUserWhenUserNotKnown() throws Exception { _util.writeAndSetGroupFile("myGroup.users", "user1,user2"); Set<String> groups = _fileGroupDatabase.getGroupsForUser(USER3); assertTrue(groups.isEmpty()); } @Test public void testGetGroupPrincipalsForNullUser() throws Exception { _util.writeAndSetGroupFile(); assertTrue(_fileGroupDatabase.getGroupsForUser(null).isEmpty()); }
VirtualHostLogEventExcludingFilter extends Filter<ILoggingEvent> implements LogBackLogInclusionRule { @Override public FilterReply decide(ILoggingEvent event) { if (!_brokerLogger.isVirtualHostLogEventExcluded() || !subjectContainsVirtualHostPrincipal()) { return FilterReply.NEUTRAL; } return FilterReply.DENY; } VirtualHostLogEventExcludingFilter(BrokerLogger<?> brokerLogger); @Override Filter<ILoggingEvent> asFilter(); @Override String getName(); @Override FilterReply decide(ILoggingEvent event); }
@Test public void testDecideOnVirtualHostLogEventNotExcludedAndNullSubject() throws Exception { FilterReply reply = _filter.decide(_loggingEvent); assertEquals(" BrokerLogger#virtualHostLogEventExcluded=false and subject=null", FilterReply.NEUTRAL, reply); assertNull("Subject should not be set in test environment", Subject.getSubject(AccessController.getContext())); } @Test public void testDecideOnVirtualHostLogEventExcludedAndNullSubject() throws Exception { when(_brokerLogger.isVirtualHostLogEventExcluded()).thenReturn(true); FilterReply reply = _filter.decide(_loggingEvent); assertEquals(" BrokerLogger#virtualHostLogEventExcluded=true and subject=null", FilterReply.NEUTRAL, reply); assertNull("Subject should not be set in test environment", Subject.getSubject(AccessController.getContext())); }
SimpleAuthenticationManager extends AbstractAuthenticationManager<SimpleAuthenticationManager> implements PasswordCredentialManagingAuthenticationProvider<SimpleAuthenticationManager> { @Override public List<String> getMechanisms() { return Collections.unmodifiableList(Arrays.asList(PLAIN_MECHANISM, CRAM_MD5_MECHANISM, SCRAM_SHA1_MECHANISM, SCRAM_SHA256_MECHANISM)); } SimpleAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); void addUser(String username, String password); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(String username, String password); @Override boolean createUser(final String username, final String password, final Map<String, String> attributes); @Override void deleteUser(final String username); @Override void setPassword(final String username, final String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testGetMechanisms() { List<String> mechanisms = _authenticationManager.getMechanisms(); assertEquals("Unexpected number of mechanisms", (long) 4, (long) mechanisms.size()); assertTrue("PLAIN was not present: " + mechanisms, mechanisms.contains("PLAIN")); assertTrue("CRAM-MD5 was not present: " + mechanisms, mechanisms.contains("CRAM-MD5")); assertTrue("SCRAM-SHA-1 was not present: " + mechanisms, mechanisms.contains("SCRAM-SHA-1")); assertTrue("SCRAM-SHA-256 was not present: " + mechanisms, mechanisms.contains("SCRAM-SHA-256")); }
SimpleAuthenticationManager extends AbstractAuthenticationManager<SimpleAuthenticationManager> implements PasswordCredentialManagingAuthenticationProvider<SimpleAuthenticationManager> { @Override public SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace) { if (PlainNegotiator.MECHANISM.equals(mechanism)) { return new PlainNegotiator(this); } else if (CramMd5Negotiator.MECHANISM.equals(mechanism)) { return new CramMd5Negotiator(this, saslSettings.getLocalFQDN(), getPasswordSource()); } else if (ScramSHA1AuthenticationManager.MECHANISM.equals(mechanism)) { return new ScramNegotiator(this, _scramSha1Adapter, ScramSHA1AuthenticationManager.MECHANISM); } else if (ScramSHA256AuthenticationManager.MECHANISM.equals(mechanism)) { return new ScramNegotiator(this, _scramSha256Adapter, ScramSHA256AuthenticationManager.MECHANISM); } else { return null; } } SimpleAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); void addUser(String username, String password); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(String username, String password); @Override boolean createUser(final String username, final String password, final Map<String, String> attributes); @Override void deleteUser(final String username); @Override void setPassword(final String username, final String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testCreateSaslNegotiatorForUnsupportedMechanisms() throws Exception { String[] unsupported = new String[] { "EXTERNAL", "CRAM-MD5-HEX", "CRAM-MD5-HASHED", "ANONYMOUS", "GSSAPI"}; for (int i = 0; i < unsupported.length; i++) { String mechanism = unsupported[i]; SaslNegotiator negotiator = _authenticationManager.createSaslNegotiator(mechanism, null, null); assertNull("Mechanism " + mechanism + " should not be supported by SimpleAuthenticationManager", negotiator); } }
SimpleAuthenticationManager extends AbstractAuthenticationManager<SimpleAuthenticationManager> implements PasswordCredentialManagingAuthenticationProvider<SimpleAuthenticationManager> { @Override public AuthenticationResult authenticate(String username, String password) { if (_users.containsKey(username)) { String userPassword = _users.get(username); if (userPassword.equals(password)) { return new AuthenticationResult(new UsernamePrincipal(username, this)); } } return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR); } SimpleAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); void addUser(String username, String password); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(String username, String password); @Override boolean createUser(final String username, final String password, final Map<String, String> attributes); @Override void deleteUser(final String username); @Override void setPassword(final String username, final String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testAuthenticateValidCredentials() { AuthenticationResult result = _authenticationManager.authenticate(TEST_USER, TEST_PASSWORD); assertEquals("Unexpected authentication result", AuthenticationStatus.SUCCESS, result.getStatus()); assertAuthenticated(result); } @Test public void testAuthenticateInvalidPassword() { AuthenticationResult result = _authenticationManager.authenticate(TEST_USER, "invalid"); assertUnauthenticated(result); } @Test public void testAuthenticateInvalidUserName() { AuthenticationResult result = _authenticationManager.authenticate("invalid", TEST_PASSWORD); assertUnauthenticated(result); }
AnonymousAuthenticationManager extends AbstractAuthenticationManager<AnonymousAuthenticationManager> { @Override public List<String> getMechanisms() { return Collections.singletonList(MECHANISM_NAME); } @ManagedObjectFactoryConstructor protected AnonymousAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); Principal getAnonymousPrincipal(); AuthenticationResult getAnonymousAuthenticationResult(); static final String PROVIDER_TYPE; static final String MECHANISM_NAME; static final String ANONYMOUS_USERNAME; }
@Test public void testGetMechanisms() throws Exception { assertEquals(Collections.singletonList("ANONYMOUS"), _manager.getMechanisms()); }
AnonymousAuthenticationManager extends AbstractAuthenticationManager<AnonymousAuthenticationManager> { @Override public SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace) { if(MECHANISM_NAME.equals(mechanism)) { return new AnonymousNegotiator(_anonymousAuthenticationResult); } else { return null; } } @ManagedObjectFactoryConstructor protected AnonymousAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); Principal getAnonymousPrincipal(); AuthenticationResult getAnonymousAuthenticationResult(); static final String PROVIDER_TYPE; static final String MECHANISM_NAME; static final String ANONYMOUS_USERNAME; }
@Test public void testCreateSaslNegotiator() throws Exception { SaslNegotiator negotiator = _manager.createSaslNegotiator("ANONYMOUS", null, null); assertNotNull("Could not create SASL negotiator for mechanism 'ANONYMOUS'", negotiator); negotiator = _manager.createSaslNegotiator("PLAIN", null, null); assertNull("Should not be able to create SASL negotiator for mechanism 'PLAIN'", negotiator); }
SpnegoAuthenticator { public AuthenticationResult authenticate(String authorizationHeader) { if (authorizationHeader == null) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("'Authorization' header is not set"); } return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR); } else { if (!hasNegotiatePrefix(authorizationHeader)) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("'Authorization' header value does not start with '{}'", NEGOTIATE_PREFIX); } return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR); } else { final String negotiateToken = authorizationHeader.substring(NEGOTIATE_PREFIX.length()); final byte[] decodedNegotiateHeader; try { decodedNegotiateHeader = Base64.getDecoder().decode(negotiateToken); } catch (RuntimeException e) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Ticket decoding failed", e); } return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR); } if (decodedNegotiateHeader.length == 0) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Empty ticket"); } return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR); } else { return authenticate(decodedNegotiateHeader); } } } } SpnegoAuthenticator(final KerberosAuthenticationManager kerberosProvider); AuthenticationResult authenticate(String authorizationHeader); AuthenticationResult authenticate(byte[] negotiateToken); static final String REQUEST_AUTH_HEADER_NAME; static final String RESPONSE_AUTH_HEADER_NAME; static final String RESPONSE_AUTH_HEADER_VALUE_NEGOTIATE; static final String AUTH_TYPE; }
@Test public void testAuthenticate() throws Exception { final String token = Base64.getEncoder().encodeToString(buildToken(SERVICE_PRINCIPAL_NAME)); final String authenticationHeader = SpnegoAuthenticator.NEGOTIATE_PREFIX + token; final AuthenticationResult result = _spnegoAuthenticator.authenticate(authenticationHeader); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.SUCCESS, result.getStatus()); final Principal principal = result.getMainPrincipal(); assertTrue(principal instanceof TokenCarryingPrincipal); assertEquals(KerberosUtilities.CLIENT_PRINCIPAL_NAME, principal.getName()); final Map<String, String> tokens = ((TokenCarryingPrincipal)principal).getTokens(); assertNotNull(tokens); assertTrue(tokens.containsKey(SpnegoAuthenticator.RESPONSE_AUTH_HEADER_NAME)); } @Test public void testAuthenticateNoAuthenticationHeader() { final AuthenticationResult result = _spnegoAuthenticator.authenticate((String) null); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); } @Test public void testAuthenticateNoNegotiatePrefix() throws Exception { final String token = Base64.getEncoder().encodeToString(buildToken(SERVICE_PRINCIPAL_NAME)); final AuthenticationResult result = _spnegoAuthenticator.authenticate(token); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); } @Test public void testAuthenticateEmptyToken() { final AuthenticationResult result = _spnegoAuthenticator.authenticate(SpnegoAuthenticator.NEGOTIATE_PREFIX + ""); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); } @Test public void testAuthenticateInvalidToken() { final AuthenticationResult result = _spnegoAuthenticator.authenticate(SpnegoAuthenticator.NEGOTIATE_PREFIX + "Zm9v"); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); } @Test public void testAuthenticateWrongConfigName() throws Exception { when(_kerberosAuthenticationManager.getSpnegoLoginConfigScope()).thenReturn("foo"); final String token = Base64.getEncoder().encodeToString(buildToken(SERVICE_PRINCIPAL_NAME)); final String authenticationHeader = SpnegoAuthenticator.NEGOTIATE_PREFIX + token; final AuthenticationResult result = _spnegoAuthenticator.authenticate(authenticationHeader); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); } @Test public void testAuthenticateWrongServer() throws Exception { final String token = Base64.getEncoder().encodeToString(buildToken(ANOTHER_SERVICE)); final String authenticationHeader = SpnegoAuthenticator.NEGOTIATE_PREFIX + token; final AuthenticationResult result = _spnegoAuthenticator.authenticate(authenticationHeader); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.ERROR, result.getStatus()); }
LDAPSSLSocketFactoryGenerator { public static Class<? extends AbstractLDAPSSLSocketFactory> createSubClass(String simpleName, final SSLSocketFactory sslSocketFactory) { final String fqcn = TARGET_PACKAGE_NAME + "." + simpleName; final byte[] classBytes = createSubClassByteCode(fqcn); try { final ClassLoader classLoader = new LDAPSSLSocketFactoryAwareDelegatingClassloader(fqcn, classBytes, sslSocketFactory); Class<? extends AbstractLDAPSSLSocketFactory> clazz = (Class<? extends AbstractLDAPSSLSocketFactory>) classLoader.loadClass(fqcn); return clazz; } catch (ClassNotFoundException cnfe) { throw new IllegalArgumentException("Could not resolve dynamically generated class " + fqcn, cnfe); } } static Class<? extends AbstractLDAPSSLSocketFactory> createSubClass(String simpleName, final SSLSocketFactory sslSocketFactory); }
@Test public void testPackageAndClassName() throws Exception { Class<? extends SocketFactory> socketFactoryClass = LDAPSSLSocketFactoryGenerator.createSubClass("MyNewClass", _sslSocketFactory); assertEquals("MyNewClass", socketFactoryClass.getSimpleName()); assertEquals(TARGET_PACKAGE_NAME, socketFactoryClass.getPackage().getName()); } @Test public void testLoadingWithClassForName() throws Exception { Class<? extends AbstractLDAPSSLSocketFactory> socketFactoryClass = LDAPSSLSocketFactoryGenerator.createSubClass("MyNewClass", _sslSocketFactory); String fqcn = socketFactoryClass.getName(); try { Class.forName(fqcn); fail("Class loading by name should not have been successful"); } catch (ClassNotFoundException cnfe) { } final ClassLoader sfClassloader = socketFactoryClass.getClassLoader(); Class<?> loaded = Class.forName(fqcn, true, sfClassloader); assertEquals(socketFactoryClass, loaded); } @Test public void testClassloaderDelegatesToParent() throws Exception { ClassLoader classLoader = LDAPSSLSocketFactoryGenerator.createSubClass("MyNewClass", _sslSocketFactory).getClassLoader(); assertEquals(String.class, classLoader.loadClass("java.lang.String")); assertEquals(TestClassForLoading.class, classLoader.loadClass(TestClassForLoading.class.getName())); } @Test public void testGetDefaultCreatesInstance() throws Exception { Class<? extends AbstractLDAPSSLSocketFactory> socketFactoryClass = LDAPSSLSocketFactoryGenerator.createSubClass("MyNewClass", _sslSocketFactory); AbstractLDAPSSLSocketFactory socketFactory = invokeGetDefaultMethod(socketFactoryClass); final boolean condition = socketFactory instanceof AbstractLDAPSSLSocketFactory; assertTrue(condition); assertEquals("MyNewClass", socketFactory.getClass().getSimpleName()); }
OAuth2AuthenticationProviderImpl extends AbstractAuthenticationManager<OAuth2AuthenticationProviderImpl> implements OAuth2AuthenticationProvider<OAuth2AuthenticationProviderImpl> { @Override public SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace) { if(OAuth2Negotiator.MECHANISM.equals(mechanism)) { return new OAuth2Negotiator(this, addressSpace); } else { return null; } } @ManagedObjectFactoryConstructor protected OAuth2AuthenticationProviderImpl(final Map<String, Object> attributes, final Container<?> container); @Override void onValidate(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAuthorizationCode(final String authorizationCode, final String redirectUri, NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAccessToken(final String accessToken, final NamedAddressSpace addressSpace); @Override URI getAuthorizationEndpointURI(); @Override URI getAuthorizationEndpointURI(NamedAddressSpace addressSpace); @Override URI getTokenEndpointURI(); @Override URI getTokenEndpointURI(NamedAddressSpace addressSpace); @Override URI getIdentityResolverEndpointURI(); @Override URI getIdentityResolverEndpointURI(NamedAddressSpace addressSpace); @Override URI getPostLogoutURI(); @Override boolean getTokenEndpointNeedsAuth(); @Override String getIdentityResolverType(); @Override String getClientId(); @Override String getClientSecret(); @Override TrustStore getTrustStore(); @Override String getScope(); @Override URI getDefaultAuthorizationEndpointURI(); @Override URI getDefaultTokenEndpointURI(); @Override URI getDefaultIdentityResolverEndpointURI(); @Override String getDefaultScope(); @Override List<String> getTlsProtocolAllowList(); @Override List<String> getTlsProtocolDenyList(); @Override List<String> getTlsCipherSuiteAllowList(); @Override List<String> getTlsCipherSuiteDenyList(); @Override int getConnectTimeout(); @Override int getReadTimeout(); @SuppressWarnings("unused") static Collection<String> validIdentityResolvers(); }
@Test public void testAuthenticateViaSasl() throws Exception { _server.setEndpoints(Collections.singletonMap(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, createMockIdentityResolverEndpoint())); final SaslNegotiator negotiator = _authProvider.createSaslNegotiator(OAuth2Negotiator.MECHANISM, null, null); AuthenticationResult authenticationResult = negotiator.handleResponse(("auth=Bearer " + TEST_VALID_ACCESS_TOKEN + "\1\1").getBytes(UTF8)); assertSuccess(authenticationResult); } @Test public void testFailAuthenticateViaSasl() throws Exception { OAuth2MockEndpoint mockIdentityResolverEndpoint = createMockIdentityResolverEndpoint(); mockIdentityResolverEndpoint.putExpectedParameter("token", TEST_INVALID_ACCESS_TOKEN); mockIdentityResolverEndpoint.setResponse(400, "{\"error\":\"invalid_token\"}"); _server.setEndpoints(Collections.singletonMap(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, mockIdentityResolverEndpoint)); final SaslNegotiator negotiator = _authProvider.createSaslNegotiator(OAuth2Negotiator.MECHANISM, null, null); AuthenticationResult authenticationResult = negotiator.handleResponse(("auth=Bearer " + TEST_INVALID_ACCESS_TOKEN + "\1\1").getBytes(UTF8)); assertFailure(authenticationResult, "invalid_token"); }
RolloverWatcher implements RollingPolicyDecorator.RolloverListener { @Override public void onRollover(Path baseFolder, String[] relativeFileNames) { _rolledFiles = Collections.unmodifiableCollection(Arrays.asList(relativeFileNames)); _baseFolder = baseFolder; } RolloverWatcher(final String activeFileName); @Override void onRollover(Path baseFolder, String[] relativeFileNames); @Override void onNoRolloverDetected(final Path baseFolder, final String[] relativeFileNames); PathContent getFileContent(String fileName); Collection<String> getRolledFiles(); List<LogFileDetails> getLogFileDetails(); String getContentType(String fileName); ZippedContent getFilesAsZippedContent(Set<String> fileNames); ZippedContent getAllFilesAsZippedContent(); }
@Test public void testOnRollover() throws Exception { String[] files = {"test1", "test2"}; _rolloverWatcher.onRollover(_baseFolder.toPath(), files); assertEquals("Unexpected rolled files. Expected " + Arrays.toString(files) + " but got " + _rolloverWatcher.getRolledFiles(), new HashSet<>(Arrays.asList(files)), new HashSet<>(_rolloverWatcher.getRolledFiles())); }
OAuth2AuthenticationProviderImpl extends AbstractAuthenticationManager<OAuth2AuthenticationProviderImpl> implements OAuth2AuthenticationProvider<OAuth2AuthenticationProviderImpl> { @Override public AuthenticationResult authenticateViaAuthorizationCode(final String authorizationCode, final String redirectUri, NamedAddressSpace addressSpace) { URL tokenEndpoint; HttpURLConnection connection; byte[] body; try { tokenEndpoint = getTokenEndpointURI(addressSpace).toURL(); ConnectionBuilder connectionBuilder = new ConnectionBuilder(tokenEndpoint); connectionBuilder.setConnectTimeout(_connectTimeout).setReadTimeout(_readTimeout); if (getTrustStore() != null) { try { connectionBuilder.setTrustMangers(getTrustStore().getTrustManagers()); } catch (GeneralSecurityException e) { throw new ServerScopedRuntimeException("Cannot initialise TLS", e); } } connectionBuilder.setTlsProtocolAllowList(getTlsProtocolAllowList()) .setTlsProtocolDenyList(getTlsProtocolDenyList()) .setTlsCipherSuiteAllowList(getTlsCipherSuiteAllowList()) .setTlsCipherSuiteDenyList(getTlsCipherSuiteDenyList()); LOGGER.debug("About to call token endpoint '{}'", tokenEndpoint); connection = connectionBuilder.build(); connection.setDoOutput(true); connection.setRequestProperty("Accept-Charset", UTF_8.name()); connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=" + UTF_8.name()); connection.setRequestProperty("Accept", "application/json"); Map<String, String> requestBody = new HashMap<>(); String clientSecret = getClientSecret() == null ? "" : getClientSecret(); if (getTokenEndpointNeedsAuth()) { String encoded = Base64.getEncoder().encodeToString((getClientId() + ":" + clientSecret).getBytes(UTF_8)); connection.setRequestProperty("Authorization", "Basic " + encoded); } else { requestBody.put("client_id", getClientId()); if (!"".equals(clientSecret)) { requestBody.put("client_secret", clientSecret); } } requestBody.put("code", authorizationCode); requestBody.put("redirect_uri", redirectUri); requestBody.put("grant_type", "authorization_code"); requestBody.put("response_type", "token"); body = OAuth2Utils.buildRequestQuery(requestBody).getBytes(UTF_8); connection.connect(); try (OutputStream output = connection.getOutputStream()) { output.write(body); } try (InputStream input = OAuth2Utils.getResponseStream(connection)) { final int responseCode = connection.getResponseCode(); LOGGER.debug("Call to token endpoint '{}' complete, response code : {}", tokenEndpoint, responseCode); Map<String, Object> responseMap = _objectMapper.readValue(input, Map.class); if (responseCode != 200 || responseMap.containsKey("error")) { IllegalStateException e = new IllegalStateException(String.format("Token endpoint failed, response code %d, error '%s', description '%s'", responseCode, responseMap.get("error"), responseMap.get("error_description"))); LOGGER.error(e.getMessage()); return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, e); } Object accessTokenObject = responseMap.get("access_token"); if (accessTokenObject == null) { IllegalStateException e = new IllegalStateException("Token endpoint response did not include 'access_token'"); LOGGER.error("Unexpected token endpoint response", e); return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, e); } String accessToken = String.valueOf(accessTokenObject); return authenticateViaAccessToken(accessToken, addressSpace); } catch (JsonProcessingException e) { IllegalStateException ise = new IllegalStateException(String.format("Token endpoint '%s' did not return json", tokenEndpoint), e); LOGGER.error("Unexpected token endpoint response", e); return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, ise); } } catch (IOException e) { LOGGER.error("Call to token endpoint failed", e); return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, e); } } @ManagedObjectFactoryConstructor protected OAuth2AuthenticationProviderImpl(final Map<String, Object> attributes, final Container<?> container); @Override void onValidate(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAuthorizationCode(final String authorizationCode, final String redirectUri, NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAccessToken(final String accessToken, final NamedAddressSpace addressSpace); @Override URI getAuthorizationEndpointURI(); @Override URI getAuthorizationEndpointURI(NamedAddressSpace addressSpace); @Override URI getTokenEndpointURI(); @Override URI getTokenEndpointURI(NamedAddressSpace addressSpace); @Override URI getIdentityResolverEndpointURI(); @Override URI getIdentityResolverEndpointURI(NamedAddressSpace addressSpace); @Override URI getPostLogoutURI(); @Override boolean getTokenEndpointNeedsAuth(); @Override String getIdentityResolverType(); @Override String getClientId(); @Override String getClientSecret(); @Override TrustStore getTrustStore(); @Override String getScope(); @Override URI getDefaultAuthorizationEndpointURI(); @Override URI getDefaultTokenEndpointURI(); @Override URI getDefaultIdentityResolverEndpointURI(); @Override String getDefaultScope(); @Override List<String> getTlsProtocolAllowList(); @Override List<String> getTlsProtocolDenyList(); @Override List<String> getTlsCipherSuiteAllowList(); @Override List<String> getTlsCipherSuiteDenyList(); @Override int getConnectTimeout(); @Override int getReadTimeout(); @SuppressWarnings("unused") static Collection<String> validIdentityResolvers(); }
@Test public void testAuthenticateViaAuthorizationCode() throws Exception { Map<String, OAuth2MockEndpoint> mockEndpoints = new HashMap<>(); mockEndpoints.put(TEST_TOKEN_ENDPOINT_PATH, createMockTokenEndpoint()); mockEndpoints.put(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, createMockIdentityResolverEndpoint()); _server.setEndpoints(mockEndpoints); final NamedAddressSpace mockAddressSpace = mock(NamedAddressSpace.class); when(mockAddressSpace.getName()).thenReturn("mock"); AuthenticationResult authenticationResult = _authProvider.authenticateViaAuthorizationCode(TEST_VALID_AUTHORIZATION_CODE, TEST_REDIRECT_URI, mockAddressSpace); assertSuccess(authenticationResult); } @Test public void testFailAuthenticateViaInvalidAuthorizationCode() throws Exception { Map<String, OAuth2MockEndpoint> mockEndpoints = new HashMap<>(); final OAuth2MockEndpoint mockTokenEndpoint = createMockTokenEndpoint(); mockTokenEndpoint.putExpectedParameter("code", TEST_INVALID_AUTHORIZATION_CODE); mockTokenEndpoint.setResponse(400, "{\"error\":\"invalid_grant\",\"error_description\":\"authorization grant is not valid\"}"); mockEndpoints.put(TEST_TOKEN_ENDPOINT_PATH, mockTokenEndpoint); mockEndpoints.put(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, createMockIdentityResolverEndpoint()); _server.setEndpoints(mockEndpoints); final NamedAddressSpace mockAddressSpace = mock(NamedAddressSpace.class); when(mockAddressSpace.getName()).thenReturn("mock"); AuthenticationResult authenticationResult = _authProvider.authenticateViaAuthorizationCode(TEST_INVALID_AUTHORIZATION_CODE, TEST_REDIRECT_URI, mockAddressSpace); assertFailure(authenticationResult, "invalid_grant"); }
OAuth2AuthenticationProviderImpl extends AbstractAuthenticationManager<OAuth2AuthenticationProviderImpl> implements OAuth2AuthenticationProvider<OAuth2AuthenticationProviderImpl> { @Override public AuthenticationResult authenticateViaAccessToken(final String accessToken, final NamedAddressSpace addressSpace) { return _authenticationResultCacher.getOrLoad(new String[]{accessToken}, () -> { try { final Principal userPrincipal = _identityResolverService.getUserPrincipal(OAuth2AuthenticationProviderImpl.this, accessToken, addressSpace); OAuth2UserPrincipal oauthUserPrincipal = new OAuth2UserPrincipal(userPrincipal.getName(), accessToken, OAuth2AuthenticationProviderImpl.this); return new AuthenticationResult(oauthUserPrincipal); } catch (IOException | IdentityResolverException e) { LOGGER.error("Call to identity resolver failed", e); return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, e); } }); } @ManagedObjectFactoryConstructor protected OAuth2AuthenticationProviderImpl(final Map<String, Object> attributes, final Container<?> container); @Override void onValidate(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAuthorizationCode(final String authorizationCode, final String redirectUri, NamedAddressSpace addressSpace); @Override AuthenticationResult authenticateViaAccessToken(final String accessToken, final NamedAddressSpace addressSpace); @Override URI getAuthorizationEndpointURI(); @Override URI getAuthorizationEndpointURI(NamedAddressSpace addressSpace); @Override URI getTokenEndpointURI(); @Override URI getTokenEndpointURI(NamedAddressSpace addressSpace); @Override URI getIdentityResolverEndpointURI(); @Override URI getIdentityResolverEndpointURI(NamedAddressSpace addressSpace); @Override URI getPostLogoutURI(); @Override boolean getTokenEndpointNeedsAuth(); @Override String getIdentityResolverType(); @Override String getClientId(); @Override String getClientSecret(); @Override TrustStore getTrustStore(); @Override String getScope(); @Override URI getDefaultAuthorizationEndpointURI(); @Override URI getDefaultTokenEndpointURI(); @Override URI getDefaultIdentityResolverEndpointURI(); @Override String getDefaultScope(); @Override List<String> getTlsProtocolAllowList(); @Override List<String> getTlsProtocolDenyList(); @Override List<String> getTlsCipherSuiteAllowList(); @Override List<String> getTlsCipherSuiteDenyList(); @Override int getConnectTimeout(); @Override int getReadTimeout(); @SuppressWarnings("unused") static Collection<String> validIdentityResolvers(); }
@Test public void testAuthenticateViaAccessToken() throws Exception { _server.setEndpoints(Collections.singletonMap(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, createMockIdentityResolverEndpoint())); AuthenticationResult authenticationResult = _authProvider.authenticateViaAccessToken(TEST_VALID_ACCESS_TOKEN, null); assertSuccess(authenticationResult); } @Test public void testFailAuthenticateViaInvalidAccessToken() throws Exception { OAuth2MockEndpoint mockIdentityResolverEndpoint = createMockIdentityResolverEndpoint(); mockIdentityResolverEndpoint.putExpectedParameter("token", TEST_INVALID_ACCESS_TOKEN); mockIdentityResolverEndpoint.setResponse(400, "{\"error\":\"invalid_token\"}"); _server.setEndpoints(Collections.singletonMap(TEST_IDENTITY_RESOLVER_ENDPOINT_PATH, mockIdentityResolverEndpoint)); AuthenticationResult authenticationResult = _authProvider.authenticateViaAccessToken(TEST_INVALID_ACCESS_TOKEN, null); assertFailure(authenticationResult, "invalid_token"); }
KerberosAuthenticationManager extends AbstractAuthenticationManager<KerberosAuthenticationManager> { @Override public SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace) { if(GSSAPI_MECHANISM.equals(mechanism)) { final String serverName = _serverName == null ? saslSettings.getLocalFQDN(): _serverName; return new KerberosNegotiator(this, serverName); } else { return null; } } @ManagedObjectFactoryConstructor protected KerberosAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); AuthenticationResult authenticate(String authorizationHeader); String getSpnegoLoginConfigScope(); boolean isStripRealmFromPrincipalName(); static final String PROVIDER_TYPE; static final String GSSAPI_MECHANISM; }
@Test public void testCreateSaslNegotiator() throws Exception { final SaslSettings saslSettings = mock(SaslSettings.class); when(saslSettings.getLocalFQDN()).thenReturn(HOST_NAME); final SaslNegotiator negotiator = _kerberosAuthenticationProvider.createSaslNegotiator(GSSAPI_MECHANISM, saslSettings, null); assertNotNull("Could not create SASL negotiator", negotiator); try { final AuthenticationResult result = authenticate(negotiator); assertEquals(AuthenticationResult.AuthenticationStatus.SUCCESS, result.getStatus()); assertEquals(new KerberosPrincipal(CLIENT_PRINCIPAL_FULL_NAME).getName(), result.getMainPrincipal().getName()); } finally { negotiator.dispose(); } }
KerberosAuthenticationManager extends AbstractAuthenticationManager<KerberosAuthenticationManager> { public AuthenticationResult authenticate(String authorizationHeader) { return _authenticator.authenticate(authorizationHeader); } @ManagedObjectFactoryConstructor protected KerberosAuthenticationManager(final Map<String, Object> attributes, final Container<?> container); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); AuthenticationResult authenticate(String authorizationHeader); String getSpnegoLoginConfigScope(); boolean isStripRealmFromPrincipalName(); static final String PROVIDER_TYPE; static final String GSSAPI_MECHANISM; }
@Test public void testAuthenticateUsingNegotiationToken() throws Exception { byte[] negotiationTokenBytes = UTILS.buildToken(CLIENT_PRINCIPAL_NAME, _clientKeyTabFile, SERVICE_PRINCIPAL_NAME); final String token = Base64.getEncoder().encodeToString(negotiationTokenBytes); final String authenticationHeader = SpnegoAuthenticator.NEGOTIATE_PREFIX + token; final AuthenticationResult result = _kerberosAuthenticationProvider.authenticate(authenticationHeader); assertNotNull(result); assertEquals(AuthenticationResult.AuthenticationStatus.SUCCESS, result.getStatus()); }
PrincipalDatabaseAuthenticationManager extends AbstractAuthenticationManager<T> implements ExternalFileBasedAuthenticationManager<T> { public void initialise() { try { _principalDatabase.open(new File(_path)); } catch (FileNotFoundException e) { throw new IllegalConfigurationException("Exception opening password database: " + e.getMessage(), e); } catch (IOException e) { throw new IllegalConfigurationException("Cannot use password database at :" + _path, e); } } protected PrincipalDatabaseAuthenticationManager(final Map<String, Object> attributes, final Container<?> broker); @Override String getPath(); void initialise(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(final String username, final String password); PrincipalDatabase getPrincipalDatabase(); @Override @StateTransition(currentState = {State.UNINITIALIZED,State.ERRORED}, desiredState = State.ACTIVE) ListenableFuture<Void> activate(); @Override boolean createUser(String username, String password, Map<String, String> attributes); @Override void deleteUser(String username); @Override void setPassword(String username, String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testInitialiseWhenPasswordFileNotFound() throws Exception { PasswordCredentialManagingAuthenticationProvider mockAuthProvider = mock(PasswordCredentialManagingAuthenticationProvider.class); when(mockAuthProvider.getContextValue(Integer.class, AbstractScramAuthenticationManager.QPID_AUTHMANAGER_SCRAM_ITERATION_COUNT)).thenReturn(4096); _principalDatabase = new PlainPasswordFilePrincipalDatabase(mockAuthProvider); setupManager(true); try { _manager.initialise(); fail("Initialisiation should fail when users file does not exist"); } catch (IllegalConfigurationException e) { final boolean condition = e.getCause() instanceof FileNotFoundException; assertTrue(condition); } }
PrincipalDatabaseAuthenticationManager extends AbstractAuthenticationManager<T> implements ExternalFileBasedAuthenticationManager<T> { @Override public SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace) { return _principalDatabase.createSaslNegotiator(mechanism, saslSettings); } protected PrincipalDatabaseAuthenticationManager(final Map<String, Object> attributes, final Container<?> broker); @Override String getPath(); void initialise(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(final String username, final String password); PrincipalDatabase getPrincipalDatabase(); @Override @StateTransition(currentState = {State.UNINITIALIZED,State.ERRORED}, desiredState = State.ACTIVE) ListenableFuture<Void> activate(); @Override boolean createUser(String username, String password, Map<String, String> attributes); @Override void deleteUser(String username); @Override void setPassword(String username, String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testSaslMechanismCreation() throws Exception { setupMocks(); SaslSettings saslSettings = mock(SaslSettings.class); SaslNegotiator saslNegotiator = _manager.createSaslNegotiator(MOCK_MECH_NAME, saslSettings, null); assertNotNull(saslNegotiator); }
PrincipalDatabaseAuthenticationManager extends AbstractAuthenticationManager<T> implements ExternalFileBasedAuthenticationManager<T> { @Override public AuthenticationResult authenticate(final String username, final String password) { try { if (_principalDatabase.verifyPassword(username, password.toCharArray())) { return new AuthenticationResult(new UsernamePrincipal(username, this)); } else { return new AuthenticationResult(AuthenticationStatus.ERROR); } } catch (AccountNotFoundException e) { return new AuthenticationResult(AuthenticationStatus.ERROR); } } protected PrincipalDatabaseAuthenticationManager(final Map<String, Object> attributes, final Container<?> broker); @Override String getPath(); void initialise(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(final String username, final String password); PrincipalDatabase getPrincipalDatabase(); @Override @StateTransition(currentState = {State.UNINITIALIZED,State.ERRORED}, desiredState = State.ACTIVE) ListenableFuture<Void> activate(); @Override boolean createUser(String username, String password, Map<String, String> attributes); @Override void deleteUser(String username); @Override void setPassword(String username, String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testNonSaslAuthenticationSuccess() throws Exception { setupMocks(); when(_principalDatabase.verifyPassword("guest", "guest".toCharArray())).thenReturn(true); AuthenticationResult result = _manager.authenticate("guest", "guest"); UsernamePrincipal expectedPrincipal = new UsernamePrincipal("guest", _manager); assertOnlyContainsWrapped(expectedPrincipal, result.getPrincipals()); assertEquals(AuthenticationStatus.SUCCESS, result.getStatus()); } @Test public void testNonSaslAuthenticationErrored() throws Exception { setupMocks(); when(_principalDatabase.verifyPassword("guest", "wrongpassword".toCharArray())).thenReturn(false); AuthenticationResult result = _manager.authenticate("guest", "wrongpassword"); assertEquals("Principals was not expected size", (long) 0, (long) result.getPrincipals().size()); assertEquals(AuthenticationStatus.ERROR, result.getStatus()); }
RolloverWatcher implements RollingPolicyDecorator.RolloverListener { public PathContent getFileContent(String fileName) { if (fileName == null) { throw new IllegalArgumentException("File name cannot be null"); } Path path = getPath(fileName); return new PathContent(path, getContentType(fileName)); } RolloverWatcher(final String activeFileName); @Override void onRollover(Path baseFolder, String[] relativeFileNames); @Override void onNoRolloverDetected(final Path baseFolder, final String[] relativeFileNames); PathContent getFileContent(String fileName); Collection<String> getRolledFiles(); List<LogFileDetails> getLogFileDetails(); String getContentType(String fileName); ZippedContent getFilesAsZippedContent(Set<String> fileNames); ZippedContent getAllFilesAsZippedContent(); }
@Test public void testGetTypedForNullFile() throws Exception { try { _rolloverWatcher.getFileContent(null); fail("IllegalArgumentException is expected for null file name"); } catch (IllegalArgumentException e) { } }
PrincipalDatabaseAuthenticationManager extends AbstractAuthenticationManager<T> implements ExternalFileBasedAuthenticationManager<T> { @Override protected void onCreate() { super.onCreate(); File passwordFile = new File(_path); if (!passwordFile.exists()) { try { Path path = new FileHelper().createNewFile(passwordFile, getContextValue(String.class, SystemConfig.POSIX_FILE_PERMISSIONS)); if (!Files.exists(path)) { throw new IllegalConfigurationException(String.format("Cannot create password file at '%s'", _path)); } } catch (IOException e) { throw new IllegalConfigurationException(String.format("Cannot create password file at '%s'", _path), e); } } } protected PrincipalDatabaseAuthenticationManager(final Map<String, Object> attributes, final Container<?> broker); @Override String getPath(); void initialise(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(final String username, final String password); PrincipalDatabase getPrincipalDatabase(); @Override @StateTransition(currentState = {State.UNINITIALIZED,State.ERRORED}, desiredState = State.ACTIVE) ListenableFuture<Void> activate(); @Override boolean createUser(String username, String password, Map<String, String> attributes); @Override void deleteUser(String username); @Override void setPassword(String username, String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testOnCreate() throws Exception { setupMocks(); assertTrue("Password file was not created", new File(_passwordFileLocation).exists()); }
PrincipalDatabaseAuthenticationManager extends AbstractAuthenticationManager<T> implements ExternalFileBasedAuthenticationManager<T> { @Override protected ListenableFuture<Void> onDelete() { return doAfterAlways(closeChildren(), () -> { File file = new File(_path); if (file.exists() && file.isFile()) { file.delete(); } }); } protected PrincipalDatabaseAuthenticationManager(final Map<String, Object> attributes, final Container<?> broker); @Override String getPath(); void initialise(); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings, final NamedAddressSpace addressSpace); @Override AuthenticationResult authenticate(final String username, final String password); PrincipalDatabase getPrincipalDatabase(); @Override @StateTransition(currentState = {State.UNINITIALIZED,State.ERRORED}, desiredState = State.ACTIVE) ListenableFuture<Void> activate(); @Override boolean createUser(String username, String password, Map<String, String> attributes); @Override void deleteUser(String username); @Override void setPassword(String username, String password); @Override Map<String, Map<String, String>> getUsers(); @Override void reload(); }
@Test public void testOnDelete() throws Exception { setupMocks(); assertTrue("Password file was not created", new File(_passwordFileLocation).exists()); _manager.delete(); assertFalse("Password file was not deleted", new File(_passwordFileLocation).exists()); }
AuthenticationResultCacher { public AuthenticationResult getOrLoad(final String[] credentials, final Callable<AuthenticationResult> loader) { try { if (_authenticationCache == null) { return loader.call(); } else { String credentialDigest = digestCredentials(credentials); return _authenticationCache.get(credentialDigest, new Callable<AuthenticationResult>() { @Override public AuthenticationResult call() throws Exception { return loader.call(); } }); } } catch (ExecutionException e) { throw new RuntimeException("Unexpected checked Exception while authenticating", e.getCause()); } catch (UncheckedExecutionException e) { throw new RuntimeException("Unexpected Exception while authenticating", e.getCause()); } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new RuntimeException("Unexpected checked Exception while authenticating", e); } } AuthenticationResultCacher(int cacheSize, long expirationTime, int iterationCount); AuthenticationResult getOrLoad(final String[] credentials, final Callable<AuthenticationResult> loader); }
@Test public void testCacheHit() throws Exception { Subject.doAs(_subject, new PrivilegedAction<Void>() { @Override public Void run() { AuthenticationResult result; result = _authenticationResultCacher.getOrLoad(new String[]{"credentials"}, _loader); assertEquals("Unexpected AuthenticationResult", _successfulAuthenticationResult, result); assertEquals("Unexpected number of loads before cache hit", (long) 1, (long) _loadCallCount); result = _authenticationResultCacher.getOrLoad(new String[]{"credentials"}, _loader); assertEquals("Unexpected AuthenticationResult", _successfulAuthenticationResult, result); assertEquals("Unexpected number of loads after cache hit", (long) 1, (long) _loadCallCount); return null; } }); } @Test public void testCacheMissDifferentCredentials() throws Exception { Subject.doAs(_subject, new PrivilegedAction<Void>() { @Override public Void run() { AuthenticationResult result; result = _authenticationResultCacher.getOrLoad(new String[]{"credentials"}, _loader); assertEquals("Unexpected AuthenticationResult", _successfulAuthenticationResult, result); assertEquals("Unexpected number of loads before cache hit", (long) 1, (long) _loadCallCount); result = _authenticationResultCacher.getOrLoad(new String[]{"other credentials"}, _loader); assertEquals("Unexpected AuthenticationResult", _successfulAuthenticationResult, result); assertEquals("Unexpected number of loads before cache hit", (long) 2, (long) _loadCallCount); return null; } }); }
AuthenticatedPrincipal implements QpidPrincipal { public static AuthenticatedPrincipal getAuthenticatedPrincipalFromSubject(final Subject authSubject) { return getAuthenticatedPrincipalFromSubject(authSubject, false); } AuthenticatedPrincipal(Principal wrappedPrincipal); static AuthenticatedPrincipal getCurrentUser(); @Override ConfiguredObject<?> getOrigin(); @Override String getName(); @Override int hashCode(); @Override boolean equals(Object obj); static AuthenticatedPrincipal getOptionalAuthenticatedPrincipalFromSubject(final Subject authSubject); static AuthenticatedPrincipal getAuthenticatedPrincipalFromSubject(final Subject authSubject); @Override String toString(); }
@Test public void testGetAuthenticatedPrincipalFromSubject() { final Subject subject = createSubjectContainingAuthenticatedPrincipal(); final AuthenticatedPrincipal actual = AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(subject); assertSame(_authenticatedPrincipal, actual); } @Test public void testAuthenticatedPrincipalNotInSubject() { try { AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(new Subject()); fail("Exception not thrown"); } catch (IllegalArgumentException iae) { } } @Test public void testTooManyAuthenticatedPrincipalsInSubject() { final Subject subject = new Subject(); subject.getPrincipals().add(new AuthenticatedPrincipal(new UsernamePrincipal("name1", null))); subject.getPrincipals().add(new AuthenticatedPrincipal(new UsernamePrincipal("name2", null))); try { AuthenticatedPrincipal.getAuthenticatedPrincipalFromSubject(subject); fail("Exception not thrown"); } catch (IllegalArgumentException iae) { } }
AuthenticatedPrincipal implements QpidPrincipal { public static AuthenticatedPrincipal getOptionalAuthenticatedPrincipalFromSubject(final Subject authSubject) { return getAuthenticatedPrincipalFromSubject(authSubject, true); } AuthenticatedPrincipal(Principal wrappedPrincipal); static AuthenticatedPrincipal getCurrentUser(); @Override ConfiguredObject<?> getOrigin(); @Override String getName(); @Override int hashCode(); @Override boolean equals(Object obj); static AuthenticatedPrincipal getOptionalAuthenticatedPrincipalFromSubject(final Subject authSubject); static AuthenticatedPrincipal getAuthenticatedPrincipalFromSubject(final Subject authSubject); @Override String toString(); }
@Test public void testGetOptionalAuthenticatedPrincipalFromSubject() { final Subject subject = createSubjectContainingAuthenticatedPrincipal(); final AuthenticatedPrincipal actual = AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subject); assertSame(_authenticatedPrincipal, actual); } @Test public void testGetOptionalAuthenticatedPrincipalFromSubjectReturnsNullIfMissing() { Subject subjectWithNoPrincipals = new Subject(); assertNull(AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subjectWithNoPrincipals)); Subject subjectWithoutAuthenticatedPrincipal = new Subject(); subjectWithoutAuthenticatedPrincipal.getPrincipals().add(new UsernamePrincipal("name1", null)); assertNull("Should return null for a subject containing a principal that isn't an AuthenticatedPrincipal", AuthenticatedPrincipal.getOptionalAuthenticatedPrincipalFromSubject(subjectWithoutAuthenticatedPrincipal)); }
AuthenticatedPrincipal implements QpidPrincipal { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof AuthenticatedPrincipal)) { return false; } AuthenticatedPrincipal other = (AuthenticatedPrincipal) obj; return _wrappedPrincipal.equals(other._wrappedPrincipal); } AuthenticatedPrincipal(Principal wrappedPrincipal); static AuthenticatedPrincipal getCurrentUser(); @Override ConfiguredObject<?> getOrigin(); @Override String getName(); @Override int hashCode(); @Override boolean equals(Object obj); static AuthenticatedPrincipal getOptionalAuthenticatedPrincipalFromSubject(final Subject authSubject); static AuthenticatedPrincipal getAuthenticatedPrincipalFromSubject(final Subject authSubject); @Override String toString(); }
@Test public void testEqualsWithDifferentUsernames() { AuthenticatedPrincipal user1principal1 = new AuthenticatedPrincipal(new UsernamePrincipal("user1", null)); AuthenticatedPrincipal user1principal2 = new AuthenticatedPrincipal(new UsernamePrincipal("user2", null)); assertFalse(user1principal1.equals(user1principal2)); assertFalse(user1principal2.equals(user1principal1)); } @Test public void testEqualsWithDissimilarObjects() { UsernamePrincipal wrappedPrincipal = new UsernamePrincipal("user1", null); AuthenticatedPrincipal authenticatedPrincipal = new AuthenticatedPrincipal(wrappedPrincipal); assertFalse(authenticatedPrincipal.equals(wrappedPrincipal)); assertFalse(wrappedPrincipal.equals(authenticatedPrincipal)); }
RolloverWatcher implements RollingPolicyDecorator.RolloverListener { public String getContentType(String fileName) { String fileNameLower = fileName.toLowerCase(); if (fileNameLower.endsWith(".gz")) { return "application/x-gzip"; } else if (fileNameLower.endsWith(".zip")) { return "application/x-zip"; } else { return "text/plain"; } } RolloverWatcher(final String activeFileName); @Override void onRollover(Path baseFolder, String[] relativeFileNames); @Override void onNoRolloverDetected(final Path baseFolder, final String[] relativeFileNames); PathContent getFileContent(String fileName); Collection<String> getRolledFiles(); List<LogFileDetails> getLogFileDetails(); String getContentType(String fileName); ZippedContent getFilesAsZippedContent(Set<String> fileNames); ZippedContent getAllFilesAsZippedContent(); }
@Test public void testGetContentType() throws Exception { assertEquals("Unexpected content type for log file", "text/plain", _rolloverWatcher.getContentType("test.log")); assertEquals("Unexpected content type for gzip file", "application/x-gzip", _rolloverWatcher.getContentType("test.gz")); assertEquals("Unexpected content type for zip file", "application/x-zip", _rolloverWatcher.getContentType("test.zip")); }
PlainPasswordFilePrincipalDatabase extends AbstractPasswordFilePrincipalDatabase<PlainUser> { @Override public boolean verifyPassword(String principal, char[] password) throws AccountNotFoundException { char[] pwd = lookupPassword(principal); if (pwd == null) { throw new AccountNotFoundException("Unable to lookup the specified users password"); } return compareCharArray(pwd, password); } PlainPasswordFilePrincipalDatabase(PasswordCredentialManagingAuthenticationProvider<?> authenticationProvider); @Override boolean verifyPassword(String principal, char[] password); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings); }
@Test public void testVerifyPassword() throws IOException, AccountNotFoundException { createUserPrincipal(); assertFalse(_database.verifyPassword(TEST_USERNAME, new char[]{})); assertFalse(_database.verifyPassword(TEST_USERNAME, "massword".toCharArray())); assertTrue(_database.verifyPassword(TEST_USERNAME, TEST_PASSWORD_CHARS)); try { _database.verifyPassword("made.up.username", TEST_PASSWORD_CHARS); fail("Should not have been able to verify this non-existant users password."); } catch (AccountNotFoundException e) { } } @Test public void testUpdatePassword() throws IOException, AccountNotFoundException { createUserPrincipal(); char[] newPwd = "newpassword".toCharArray(); _database.updatePassword(_principal, newPwd); assertFalse(_database.verifyPassword(TEST_USERNAME, TEST_PASSWORD_CHARS)); assertTrue(_database.verifyPassword(TEST_USERNAME, newPwd)); }
Base64MD5PasswordFilePrincipalDatabase extends AbstractPasswordFilePrincipalDatabase<HashedUser> { @Override public boolean verifyPassword(String principal, char[] password) throws AccountNotFoundException { char[] pwd = lookupPassword(principal); if (pwd == null) { throw new AccountNotFoundException("Unable to lookup the specified users password"); } byte[] byteArray = new byte[password.length]; int index = 0; for (char c : password) { byteArray[index++] = (byte) c; } byte[] md5byteArray; try { md5byteArray = HashedUser.getMD5(byteArray); } catch (Exception e1) { getLogger().warn("Unable to hash password for user '{}' for comparison", principal); return false; } char[] hashedPassword = new char[md5byteArray.length]; index = 0; for (byte c : md5byteArray) { hashedPassword[index++] = (char) c; } return compareCharArray(pwd, hashedPassword); } Base64MD5PasswordFilePrincipalDatabase(final PasswordCredentialManagingAuthenticationProvider<?> authenticationProvider); @Override boolean verifyPassword(String principal, char[] password); @Override List<String> getMechanisms(); @Override SaslNegotiator createSaslNegotiator(final String mechanism, final SaslSettings saslSettings); }
@Test public void testVerifyPassword() throws IOException, AccountNotFoundException { testCreateUserPrincipal(); assertFalse(_database.verifyPassword(PRINCIPAL_USERNAME, new char[]{})); assertFalse(_database.verifyPassword(PRINCIPAL_USERNAME, (PASSWORD + "z").toCharArray())); assertTrue(_database.verifyPassword(PRINCIPAL_USERNAME, PASSWORD.toCharArray())); try { _database.verifyPassword("made.up.username", PASSWORD.toCharArray()); fail("Should not have been able to verify this nonexistent users password."); } catch (AccountNotFoundException e) { } } @Test public void testUpdatePassword() throws IOException, AccountNotFoundException { testCreateUserPrincipal(); char[] newPwd = "newpassword".toCharArray(); _database.updatePassword(PRINCIPAL, newPwd); assertFalse(_database.verifyPassword(PRINCIPAL_USERNAME, PASSWORD.toCharArray())); assertTrue(_database.verifyPassword(PRINCIPAL_USERNAME, newPwd)); }
UsernamePrincipal implements QpidPrincipal { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final UsernamePrincipal that = (UsernamePrincipal) o; if (!_name.equals(that._name)) { return false; } if (_authenticationProvider == null || that._authenticationProvider == null) { return _authenticationProvider == null && that._authenticationProvider == null; } return (_authenticationProvider.getType().equals(that._authenticationProvider.getType()) && _authenticationProvider.getName().equals(that._authenticationProvider.getName())); } UsernamePrincipal(String name, AuthenticationProvider<?> authenticationProvider); @Override String getName(); @Override String toString(); @Override AuthenticationProvider<?> getOrigin(); @Override boolean equals(final Object o); @Override int hashCode(); }
@Test public void testEqualitySameObject() { final UsernamePrincipal principal = new UsernamePrincipal("string", null); assertTrue(principal.equals(principal)); } @Test public void testEqualitySameName() { final String string = "string"; final UsernamePrincipal principal1 = new UsernamePrincipal(string, null); final UsernamePrincipal principal2 = new UsernamePrincipal(string, null); assertTrue(principal1.equals(principal2)); } @Test public void testEqualityEqualName() { final UsernamePrincipal principal1 = new UsernamePrincipal(new String("string"), null); final UsernamePrincipal principal2 = new UsernamePrincipal(new String("string"), null); assertTrue(principal1.equals(principal2)); } @Test public void testInequalityDifferentUserPrincipals() { UsernamePrincipal principal1 = new UsernamePrincipal("string1", null); UsernamePrincipal principal2 = new UsernamePrincipal("string2", null); assertFalse(principal1.equals(principal2)); } @Test public void testInequalityNonUserPrincipal() { UsernamePrincipal principal = new UsernamePrincipal("string", null); assertFalse(principal.equals(new String("string"))); } @Test public void testInequalityNull() { UsernamePrincipal principal = new UsernamePrincipal("string", null); assertFalse(principal.equals(null)); }
RolloverWatcher implements RollingPolicyDecorator.RolloverListener { public List<LogFileDetails> getLogFileDetails() { List<LogFileDetails> results = new ArrayList<>(); results.add(getFileDetails(_activeFilePath)); List<String> rolledFiles = new ArrayList<>(_rolledFiles); for (String fileName : rolledFiles) { Path file = _baseFolder.resolve(fileName); LogFileDetails details = getFileDetails(file); results.add(details); } Collections.sort(results, LAST_MODIFIED_COMPARATOR); return results; } RolloverWatcher(final String activeFileName); @Override void onRollover(Path baseFolder, String[] relativeFileNames); @Override void onNoRolloverDetected(final Path baseFolder, final String[] relativeFileNames); PathContent getFileContent(String fileName); Collection<String> getRolledFiles(); List<LogFileDetails> getLogFileDetails(); String getContentType(String fileName); ZippedContent getFilesAsZippedContent(Set<String> fileNames); ZippedContent getAllFilesAsZippedContent(); }
@Test public void testGetLogFileDetails() throws Exception { String[] files = createTestRolledFilesAndNotifyWatcher(); List<LogFileDetails> logFileDetails = _rolloverWatcher.getLogFileDetails(); final int expectedNumberOfEntries = files.length + 1; assertEquals("getLogFileDetails returned unexpected number of entries", (long) expectedNumberOfEntries, (long) logFileDetails.size()); List<String> expectedFiles = new ArrayList<>(Arrays.asList(files)); expectedFiles.add(_activeFile.getName()); for (String expectedFileName : expectedFiles) { boolean found = false; for (LogFileDetails details : logFileDetails) { if (details.getName().equals(expectedFileName)) { found = true; final File file = new File(_baseFolder, expectedFileName); assertEquals("FileDetail for \"" + expectedFileName + "\" has unexpected lastModified time", file.lastModified(), details.getLastModified()); assertEquals("FileDetail for \"" + expectedFileName + "\" has unexpected size", file.length(), details.getSize()); break; } } assertTrue("File \"" + expectedFileName + "\" expected but not found in logFileDetails", found); } }
OAuth2Negotiator implements SaslNegotiator { @Override public AuthenticationResult handleResponse(final byte[] response) { if (_state == State.COMPLETE) { return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, new IllegalStateException("Multiple Authentications not permitted.")); } else if (_state == State.INITIAL && (response == null || response.length == 0)) { _state = State.CHALLENGE_SENT; return new AuthenticationResult(new byte[0], AuthenticationResult.AuthenticationStatus.CONTINUE); } _state = State.COMPLETE; if (response == null || response.length == 0) { return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, new IllegalArgumentException("Invalid OAuth2 client response.")); } Map<String, String> responsePairs = splitResponse(response); String auth = responsePairs.get("auth"); if (auth != null) { if (auth.startsWith(BEARER_PREFIX)) { return _authenticationProvider.authenticateViaAccessToken(auth.substring(BEARER_PREFIX.length()), _addressSpace); } else { return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, new IllegalArgumentException("The 'auth' part of response does not not begin with the expected prefix")); } } else { return new AuthenticationResult(AuthenticationResult.AuthenticationStatus.ERROR, new IllegalArgumentException("The mandatory 'auth' part of the response was absent.")); } } OAuth2Negotiator(OAuth2AuthenticationProvider<?> authenticationProvider, final NamedAddressSpace addressSpace); @Override AuthenticationResult handleResponse(final byte[] response); @Override void dispose(); @Override String getAttemptedAuthenticationId(); static final String MECHANISM; }
@Test public void testHandleResponse_ResponseAuthAbsent() throws Exception { AuthenticationResult actualResult = _negotiator.handleResponse(RESPONSE_WITH_NO_TOKEN); assertEquals("Unexpected result status", AuthenticationResult.AuthenticationStatus.ERROR, actualResult.getStatus()); assertNull("Unexpected result principal", actualResult.getMainPrincipal()); } @Test public void testHandleResponse_ResponseAuthMalformed() throws Exception { AuthenticationResult actualResult = _negotiator.handleResponse(RESPONSE_WITH_MALFORMED_AUTH); assertEquals("Unexpected result status", AuthenticationResult.AuthenticationStatus.ERROR, actualResult.getStatus()); assertNull("Unexpected result principal", actualResult.getMainPrincipal()); } @Test public void testHandleNoInitialResponse() throws Exception { final AuthenticationResult result = _negotiator.handleResponse(new byte[0]); assertEquals("Unexpected authentication status", AuthenticationResult.AuthenticationStatus.CONTINUE, result.getStatus()); assertArrayEquals("Unexpected authentication challenge", new byte[0], result.getChallenge()); } @Test public void testHandleNoInitialResponseNull() throws Exception { final AuthenticationResult result = _negotiator.handleResponse(null); assertEquals("Unexpected authentication status", AuthenticationResult.AuthenticationStatus.CONTINUE, result.getStatus()); assertArrayEquals("Unexpected authentication challenge", new byte[0], result.getChallenge()); }