1 files changed, 241 insertions, 0 deletions
diff --git a/java/management/client/src/test/java/org/apache/qpid/management/domain/services/BrokerMessageListenerTest.java b/java/management/client/src/test/java/org/apache/qpid/management/domain/services/BrokerMessageListenerTest.java
new file mode 100644
index 0000000000..805c039a6f
--- /dev/null
+++ b/java/management/client/src/test/java/org/apache/qpid/management/domain/services/BrokerMessageListenerTest.java
@@ -0,0 +1,241 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+package org.apache.qpid.management.domain.services;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.api.Message;
+import org.apache.qpid.management.TestConstants;
+import org.apache.qpid.management.domain.handler.base.IMessageHandler;
+import org.apache.qpid.management.domain.model.DomainModel;
+import org.apache.qpid.nclient.util.ByteBufferMessage;
+import org.apache.qpid.transport.codec.Decoder;
+
+/**
+ * Test case for Broker Message Listener.
+ * 
+ * @author Andrea Gazzarini
+ */
+public class BrokerMessageListenerTest extends TestCase
+{
+    // An empty message handler user for test.
+    private IMessageHandler _emptyMessageHandler = new IMessageHandler() 
+    {
+        public void process (Decoder decoder, int sequenceNumber)
+        {
+        }
+        public void setDomainModel (DomainModel domainModel) 
+        {
+        }
+    };
+
+    // Another empty message handler user for test.
+    private IMessageHandler _anotherEmptyMessageHandler = new IMessageHandler() 
+    {
+        public void process (Decoder decoder, int sequenceNumber)
+        {
+        }
+        public void setDomainModel (DomainModel domainModel)
+        {
+        }
+    };
+
+    private Map<Character,IMessageHandler> _handlers = new HashMap<Character, IMessageHandler>();
+    private BrokerMessageListener _listener;
+    private final char opcode1 = 'x';
+    private final char opcode2 = 'y';
+    
+    
+    @Override
+    protected void setUp () throws Exception
+    {
+        DomainModel domainModel = new DomainModel(TestConstants.BROKER_ID);
+        _listener = new BrokerMessageListener(domainModel);
+        
+        _handlers.put(opcode1, _emptyMessageHandler);
+        _handlers.put(opcode2, _anotherEmptyMessageHandler);
+    }
+    
+    /**
+     * Tests the installation of message handlers on a broker message listener.
+     * 
+     * <br>precondition : no message handler has been installed on message listener.
+     * <br>postcondition : two message handlers are installed on message listener.
+     */
+    public void testSetHandlersOK() 
+    {
+        assertTrue(
+                "No handler has yet been installed so how is it possible that the handlers map is not empty?",
+                _listener._handlers.isEmpty());
+        
+        _listener.setHandlers(_handlers);
+        
+        assertEquals("Now we should have two handlers configured.",2,_listener._handlers.size());
+        assertSame(_listener._handlers.get(opcode1),_emptyMessageHandler);
+        assertSame(_listener._handlers.get(opcode2),_anotherEmptyMessageHandler);
+    }
+    
+    /**
+     * Tests the installation of message handlers on a broker message listener. 
+     * Specifically it tries to install three message handlers and one of them is throwing an exception at installation time.
+     * 
+     * <br>precondition : no message handler has been installed on message listener.
+     * <br>postcondition : two message handlers are installed on message listener. (the one that thrown exception has been
+     * discarded).
+     */
+    public void testSetHandlerOK() 
+    {
+        IMessageHandler wrongMessageHandler = new IMessageHandler()
+        {
+
+            public void process (Decoder decoder, int sequenceNumber)
+            {
+            }
+
+            public void setDomainModel (DomainModel domainModel)
+            {
+                throw new RuntimeException();
+            }  
+        };
+        
+        char opcodeForWrongHandler = 'k';
+        
+        assertTrue(
+                "No handler has yet been installed so how is it possible that the handlers map is not empty?",
+                _listener._handlers.isEmpty());
+        
+        _handlers.put(opcodeForWrongHandler,wrongMessageHandler);
+
+        _listener.setHandlers(_handlers);
+        
+        assertEquals("Now we should have two handlers configured.",2,_listener._handlers.size());
+        assertSame(_listener._handlers.get(opcode1),_emptyMessageHandler);
+        assertSame(_listener._handlers.get(opcode2),_anotherEmptyMessageHandler);
+        assertNull(_listener._handlers.get(opcodeForWrongHandler));
+    }
+    
+    /**
+     * Tests the execution of the onMessage() method when a message with a bad magic number is received.
+     * 
+     * <br>precondition : a message with a bad magic number is received.
+     * <br>postcondition : the processing of the incoming message is skipped and therefore no handler will be called.
+     */
+    public void testOnMessageKO_withBadMagicNumber() throws IOException 
+    {    
+        IMessageHandler neverCallMe = new IMessageHandler()
+        {
+
+            public void process (Decoder decoder, int sequenceNumber)
+            {
+                fail("This test shouldn't never arrive at this point...");
+            }
+
+            public void setDomainModel (DomainModel domainModel)
+            {
+            }  
+        };
+        
+        String opcodeForNeverCallMeHandler = "w";
+        
+        _handlers.put('w',neverCallMe);
+        _listener.setHandlers(_handlers);
+        
+        Message message = new ByteBufferMessage();
+        message.appendData( ("AMG"+opcodeForNeverCallMeHandler).getBytes());
+        
+        _listener.onMessage(message);
+    }
+    
+    /**
+     * Tests the execution of the onMessage() method when the incoming message is a compound message.
+     * 
+     * <br>precondition : the incoming message is a compound message.
+     * <br>postcondition : each tokenized message is forwarded to the appropriate handler.
+     */
+    public void testOnMessageOK_WithCompoundMessage() throws Exception 
+    {
+    	final Map<Character,IMessageHandler> handlersMap = new HashMap<Character,IMessageHandler>();
+    	char [] opcodes = {'a','b','c','d','e'};
+    	
+    	class MockMessageHandler implements IMessageHandler
+        {
+    		private final char _opcode;
+    		
+    		public MockMessageHandler(char opcode) 
+    		{
+    			this._opcode = opcode;
+			}
+    		
+            public void process (Decoder decoder, int sequenceNumber)
+            {
+            	handlersMap.remove(_opcode);
+            }
+
+            public void setDomainModel (DomainModel domainModel)
+            {
+            	// Do nothing here. It's just a mock handler.
+            }      	
+        };
+    	
+    	for (char opcode : opcodes) 
+    	{
+        	handlersMap.put(opcode, new MockMessageHandler(opcode));			
+		}
+    	        
+    	// Removes previously injected handlers (i.e. x & y)
+    	_listener._handlers.clear();
+        _listener.setHandlers(handlersMap);
+        
+        Message compoundMessage = createCompoundMessage(opcodes);
+        _listener.onMessage(compoundMessage);
+        
+        assertTrue(handlersMap.isEmpty());
+    }
+
+    // Creates a (non valid) compound message.
+	private Message createCompoundMessage(char[] opcodes) throws IOException {
+		byte [] compoundMessageData = new byte [12 * opcodes.length];
+		Random randomizer = new Random();
+		int position = 0;
+		
+		for (char opcode : opcodes) {
+			System.arraycopy(MessageTokenizer.MAGIC_NUMBER_BYTES, 0, compoundMessageData, position, MessageTokenizer.MAGIC_NUMBER_BYTES.length);
+			position+=MessageTokenizer.MAGIC_NUMBER_BYTES.length;
+			
+			compoundMessageData[position++] = (byte)opcode;
+			
+			for (int c = 4; c < 12; c++) 
+			{
+				byte aByte = (byte)randomizer.nextInt(127);
+				compoundMessageData[position++] = aByte;
+			}
+		}
+						
+		Message compoundMessage = new ByteBufferMessage();
+		compoundMessage.appendData(compoundMessageData);
+		return compoundMessage;
+	}
+}