JMSPluginUtilsTest.java

/**
 * Copyright (c) 2009-2011 VMware, Inc. All Rights Reserved.
 *
 * Licensed 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 com.springsource.insight.plugin.jms;

import static com.springsource.insight.plugin.jms.JMSPluginUtils.CORRELATION_ID;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.DELIVERY_MODE;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.EXPIRATION;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_CONTENT;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_CONTENT_MAP;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_HEADERS;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_ID;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_PROPERTIES;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.MESSAGE_TYPE;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.NAME;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.PRIORITY;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.REDELIVERED;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.TYPE;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.addDestinationDetailsToMapIfNeeded;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.extractMessageHeaders;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.extractMessageProperties;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.extractMessageTypeAttributes;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.getDeliveryMode;
import static com.springsource.insight.plugin.jms.JMSPluginUtils.getMessage;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.jms.BytesMessage;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.StreamMessage;
import javax.jms.TextMessage;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.Test;

import com.springsource.insight.collection.test.AbstractCollectionTestSupport;
import com.springsource.insight.intercept.operation.Operation;
import com.springsource.insight.intercept.operation.OperationMap;
import com.springsource.insight.util.MathUtil;

public class JMSPluginUtilsTest extends AbstractCollectionTestSupport {
    public JMSPluginUtilsTest() {
        super();
    }

    @Test
    public void testAddDestinationDetailsToMapIfNeeded() throws JMSException {
        Queue queue = mock(Queue.class);
        when(queue.getQueueName()).thenReturn("mock-queue");

        Operation op = new Operation();
        OperationMap map = op.createMap("test-map");

        addDestinationDetailsToMapIfNeeded(queue, map, null, Collections.<String>emptyList(), "test");

        String type = map.get("test" + TYPE, String.class);
        String name = map.get("test" + NAME, String.class);

        assertNotNull(type);
        assertNotNull(name);

        assertEquals(type, DestinationType.Queue.name());
        assertEquals(name, "mock-queue");

        queue = null;
        op = new Operation();
        map = op.createMap("test-map");

        addDestinationDetailsToMapIfNeeded(queue, map, null, Collections.<String>emptyList(), "test");
        type = map.get("test" + TYPE, String.class);
        name = map.get("test" + NAME, String.class);

        assertNull(type);
        assertNull(name);
    }

    @Test
    public void testExtractMessageAttributes() throws JMSException {
        Message message = mock(Message.class);

        final Map<String, Object> mockMap = mockAttributes(message);

        Operation op = new Operation();
        extractMessageProperties(op, message, null, Collections.<String>emptyList());
        assertAttributes(mockMap, op);
    }

    static OperationMap assertAttributes(final Map<String, ?> mockMap, Operation op) {
        OperationMap opMap = op.get(MESSAGE_PROPERTIES, OperationMap.class);
        assertNotNull("Missing " + MESSAGE_PROPERTIES + " map", opMap);

        for (String key : mockMap.keySet()) {
            Object mockValue = mockMap.get(key);
            if (mockValue instanceof Number) {
                Number opValue = opMap.get(key, Number.class);
                assertNotNull("Missing number value for key=" + key, opValue);
                if (MathUtil.isIntegralNumber(opValue)) {
                    assertEquals("Mismatched integral value for key=" + key, ((Number) mockValue).longValue(), opValue.longValue());
                } else {
                    assertEquals("Mismatched integral value for key=" + key, ((Number) mockValue).doubleValue(), opValue.doubleValue(), 0.0001d);
                }
            } else {
                assertEquals("Mismatched value for key=" + key, mockValue, opMap.get(key));
            }
        }

        return opMap;
    }

    static Map<String, Object> mockAttributes(Message message) throws JMSException {
        final Map<String, Object> mockMap = new HashMap<String, Object>();
        mockMap.put("test-string", "test-value");
        mockMap.put("test-int", Integer.valueOf(1));
        mockMap.put("host", "jms-host");
        mockMap.put("port", Integer.valueOf(8070));

        when(message.getPropertyNames()).thenReturn(new Enumeration<String>() {
            Iterator<String> iter = mockMap.keySet().iterator();

            public boolean hasMoreElements() {
                return iter.hasNext();
            }

            public String nextElement() {
                return iter.next();
            }
        });

        when(message.getObjectProperty(argThat(new BaseMatcher<String>() {
            public boolean matches(Object val) {
                return "test-string".equals(val);
            }

            public void describeTo(Description desc) {
                // do nothing
            }
        }))).thenReturn(mockMap.get("test-string"));

        when(message.getObjectProperty(argThat(new BaseMatcher<String>() {
            public boolean matches(Object val) {
                return "test-int".equals(val);
            }

            public void describeTo(Description desc) {
                // do nothing
            }
        }))).thenReturn(mockMap.get("test-int"));

        when(message.getObjectProperty(argThat(new BaseMatcher<String>() {
            public boolean matches(Object val) {
                return "port".equals(val);
            }

            public void describeTo(Description desc) {
                // do nothing
            }
        }))).thenReturn(mockMap.get("port"));

        when(message.getObjectProperty(argThat(new BaseMatcher<String>() {
            public boolean matches(Object val) {
                return "host".equals(val);
            }

            public void describeTo(Description desc) {
                // do nothing
            }
        }))).thenReturn(mockMap.get("host"));
        return mockMap;
    }

    @Test
    public void testExtractMessageHeaders() throws JMSException {
        Message message = mock(Message.class);

        mockHeaders(message);

        Operation op = new Operation();

        extractMessageHeaders(op, message, null, Collections.<String>emptyList());
        assertHeaders(message, op);
    }

    static OperationMap assertHeaders(Message message, Operation op) throws JMSException {
        OperationMap opMap = op.get(MESSAGE_HEADERS, OperationMap.class);
        assertNotNull("Missing " + MESSAGE_HEADERS + " map", opMap);

        assertEquals(CORRELATION_ID, message.getJMSCorrelationID(), opMap.get(CORRELATION_ID, String.class));
        assertEquals(DELIVERY_MODE, getDeliveryMode(message.getJMSDeliveryMode()).getLabel(), opMap.get(DELIVERY_MODE, String.class));
        assertEquals(EXPIRATION, message.getJMSExpiration(), opMap.getLong(EXPIRATION, (-1L)));
        assertEquals(MESSAGE_ID, message.getJMSMessageID(), opMap.get(MESSAGE_ID, String.class));
        assertEquals(PRIORITY, message.getJMSPriority(), opMap.getInt(PRIORITY, (-1)));
        assertEquals(REDELIVERED, Boolean.valueOf(message.getJMSRedelivered()), opMap.get(REDELIVERED, Boolean.class));

        return opMap;
    }

    @SuppressWarnings("boxing")
    static void mockHeaders(Message message) throws JMSException {
        when(message.getJMSCorrelationID()).thenReturn("1");
        when(message.getJMSDeliveryMode()).thenReturn(DeliveryMode.PERSISTENT);
        when(message.getJMSExpiration()).thenReturn(0L);
        when(message.getJMSMessageID()).thenReturn("2");
        when(message.getJMSPriority()).thenReturn(3);
        when(message.getJMSRedelivered()).thenReturn(true);
    }

    @Test
    public void testExtractMapMessageTypeAttributes() throws JMSException {
        MapMessage mapMessage = mock(MapMessage.class);

        final Map<String, String> mockMap = new HashMap<String, String>();
        mockMap.put("test-key", "test-value");

        when(mapMessage.getMapNames()).thenReturn(new Enumeration<String>() {
            Iterator<String> iter = mockMap.keySet().iterator();

            public boolean hasMoreElements() {
                return iter.hasNext();
            }

            public String nextElement() {
                return iter.next();
            }
        });

        when(mapMessage.getObject(argThat(new BaseMatcher<String>() {
            public boolean matches(Object val) {
                return "test-key".equals(val);
            }

            public void describeTo(Description desc) {
                // do nothing
            }
        }))).thenReturn(mockMap.get("test-key"));

        Operation op = new Operation();

        extractMessageTypeAttributes(op, mapMessage);

        String type = op.get(MESSAGE_TYPE, String.class);
        OperationMap contentMap = op.get(MESSAGE_CONTENT_MAP, OperationMap.class);

        assertNotNull(contentMap);
        assertEquals(mockMap.size(), contentMap.size());
        assertEquals(mockMap.get("test-key"), contentMap.get("test-key"));
        assertEquals(MessageType.MapMessage.name(), type);
        assertNull(op.get(MESSAGE_CONTENT));
    }

    @Test
    public void testExtractTextMessageTypeAttributes() throws JMSException {
        TextMessage txtMessage = mock(TextMessage.class);
        when(txtMessage.getText()).thenReturn("test-text");

        Operation op = new Operation();

        extractMessageTypeAttributes(op, txtMessage);

        String type = op.get(MESSAGE_TYPE, String.class);
        String content = op.get(MESSAGE_CONTENT, String.class);

        assertEquals(MessageType.TextMessage.name(), type);
        assertEquals("test-text", content);
        assertNull(op.get(MESSAGE_CONTENT_MAP));
    }

    @Test
    public void testExtractBytesMessageTypeAttributes() throws JMSException {
        BytesMessage bytesMessage = mock(BytesMessage.class);

        Operation op = new Operation();

        extractMessageTypeAttributes(op, bytesMessage);

        String type = op.get(MESSAGE_TYPE, String.class);

        assertEquals(MessageType.BytesMessage.name(), type);
        assertNull(op.get(MESSAGE_CONTENT));
        assertNull(op.get(MESSAGE_CONTENT_MAP));
    }

    @Test
    public void testExtractObjectMessageTypeAttributes() throws JMSException {
        ObjectMessage objectMessage = mock(ObjectMessage.class);

        Operation op = new Operation();

        extractMessageTypeAttributes(op, objectMessage);

        String type = op.get(MESSAGE_TYPE, String.class);

        assertEquals(MessageType.ObjectMessage.name(), type);
        assertNull(op.get(MESSAGE_CONTENT));
        assertNull(op.get(MESSAGE_CONTENT_MAP));
    }

    @Test
    public void testExtractStreamMessageTypeAttributes() throws JMSException {
        StreamMessage objectMessage = mock(StreamMessage.class);

        Operation op = new Operation();

        extractMessageTypeAttributes(op, objectMessage);

        String type = op.get(MESSAGE_TYPE, String.class);

        assertEquals(MessageType.StreamMessage.name(), type);
        assertNull(op.get(MESSAGE_CONTENT));
        assertNull(op.get(MESSAGE_CONTENT_MAP));
    }

    @Test
    public void testGetDeliveryMode() {
        int deliveryMode = DeliveryMode.NON_PERSISTENT;

        DeliveryModeType type = getDeliveryMode(deliveryMode);
        assertEquals(DeliveryModeType.NON_PERSISTENT, type);

        deliveryMode = DeliveryMode.PERSISTENT;

        type = getDeliveryMode(deliveryMode);
        assertEquals(DeliveryModeType.PERSISTENT, type);

        deliveryMode = -1;

        type = getDeliveryMode(deliveryMode);
        assertEquals(DeliveryModeType.UNKNOWN, type);
    }

    @Test
    public void testGetMessage() {
        Message message = mock(Message.class);

        Object[] args = new Object[]{message};

        Message fromUtil = getMessage(args);

        assertSame(message, fromUtil);
    }
}