path: root/trunk/qpid/java/management/client/src/test/java/org/apache/qpid/management/domain/model/QpidEventTest.java

/*
 *
 * 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.model;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.ObjectName;
import javax.management.ReflectionException;

import junit.framework.TestCase;

import org.apache.qpid.management.TestConstants;
import org.apache.qpid.management.configuration.ConfigurationException;
import org.apache.qpid.management.configuration.Configurator;
import org.apache.qpid.management.domain.model.QpidEvent.QManManagedEvent;

/**
 * Test case for qpid class entity.
 * 
 * @author Andrea Gazzarini
 */
public class QpidEventTest extends TestCase
{
    private QpidEvent _event;
    private QpidPackage _qpidPackage;
    
    @Override
    protected void setUp () throws Exception
    {
        _qpidPackage = new QpidPackage(TestConstants.QPID_PACKAGE_NAME,TestConstants.DOMAIN_MODEL);
        _event = new QpidEvent(TestConstants.BIND_EVENT_NAME,TestConstants.HASH,_qpidPackage);
    }
        
    /**
     * Tests the execution of the createEventInstance() method.
     * Basically it tests the addition of a new event instance.
     * 
     * <br>precondition: event deifinition has no object instances.
     * <br>precondition : event definition contains the new object instance.
     */
    public void testCreateEventInstance() 
    {            
        assertTrue(
                "A just created event should be empty. I mean there shouldn't be event instances inside.", 
        		_event.hasNoInstances());

        QManManagedEvent instance = createEventInstance();
        
        assertFalse (
                "Now a new instance should be there...",
                _event.hasNoInstances());
        
        assertEquals(TestConstants.TEST_RAW_DATA,instance._rawEventData);
        assertEquals(TestConstants.NOW,instance._timestamp);
        assertEquals(TestConstants.SEVERITY, instance._severity);
    }
    
    /**
     * Tests the internal state change of an event definition.
     */
    public void testStateChange() throws UnableToBuildFeatureException
    {
    	// Let's override this class because this is not an online tests and therefore
    	// QMan is not supposed to be up.
    	_event = new QpidEvent(TestConstants.BIND_EVENT_NAME,TestConstants.HASH,_qpidPackage)
    	{
    		@Override
    		void requestSchema() throws Exception {
    			// Do Nothing.
    		}
    		
    		@Override
    		void setSchema(List<Map<String, Object>> argumentDefinitions)throws UnableToBuildFeatureException {
    			_state = _schemaInjected;
    		}
    	};
    	
    	assertSame(
    			"Initial state doesn't match.",
    			_event._schemaNotRequested,
    			_event._state);
    	
    	_event.addEventData(TestConstants.TEST_RAW_DATA, TestConstants.NOW, TestConstants.SEVERITY);
    	
    	assertSame(
    			"Request schema has been requested but not yet injected. The current state is not indicating that!",
    			_event._schemaRequestedButNotYetInjected,
    			_event._state);
    	
    	_event.setSchema(TestConstants.EMPTY_ARGUMENTS_SCHEMA);
    	
    	assertSame(
    			"Request schema has been injected. The current state is not indicating that!",
    			_event._schemaInjected,
    			_event._state);    	
    }
    
    /**
     * Tests the injection of a valid schema on a QpidEvent.
     * 
     * <br>precondition : a valid arguments is injected on the qpid event.
     * <br>postcondition : event definition is built successfully.
     */
    public void testSchemaInjectionOK() throws UnableToBuildFeatureException, ConfigurationException, InstanceNotFoundException, MBeanException, ReflectionException
    {
    	_event = new QpidEvent(TestConstants.BIND_EVENT_NAME,TestConstants.HASH,_qpidPackage)
    	{
    		@Override
    		void requestSchema() throws Exception 
    		{
    			// DO NOTHING : QMan is not running and therefore the schema will be manually injected.
    		}
    		
    		@Override
    		void updateEventInstanceWithData(QManManagedEvent instance) 
    		{
    			// DO NOTHING : otherwise we should supply a valid raw data to be converted. ;-)
    		}
    	};
    	
       Configurator configurator = new Configurator();
        configurator.configure();

        List<Map<String,Object>> arguments = new ArrayList<Map<String, Object>>();
        arguments.add(createArgument(TestConstants.AGE_ATTRIBUTE_NAME, TestConstants.AGE_ATTRIBUTE_DESCRIPTION));
        arguments.add(createArgument(TestConstants.SURNAME_ATTRIBUTE_NAME, TestConstants.SURNAME_ATTRIBUTE_DESCRIPTION));
        
        // Incoming data : that will fire the schema request and a state change from schema-not-requested to schema-requested-but-not-injected
        _event.addEventData(TestConstants.TEST_RAW_DATA, TestConstants.NOW, TestConstants.SEVERITY);
        
        // I must be sure that what is obvious for me it's obvious for QMan... :)
        assertSame(
    			"Request schema has been requested but not yet injected. The current state is not indicating that!",
    			_event._schemaRequestedButNotYetInjected,
    			_event._state);
        
        // Inject schema
        _event.setSchema(arguments);

        // Arguments must be 2 + 2 (severity)
        assertEquals(2,_event._arguments.size());
        
        QpidProperty argument = _event._arguments.get(TestConstants.AGE_ATTRIBUTE_NAME);
        assertEquals(TestConstants.AGE_ATTRIBUTE_NAME,argument.getName());
        assertEquals(AccessMode.RO,argument.getAccessMode());
        assertEquals(TestConstants.AGE_ATTRIBUTE_DESCRIPTION,argument.getDescription());
        assertEquals(Short.class,argument.getJavaType());
        assertFalse(argument.isOptional());
        
        argument = _event._arguments.get(TestConstants.SURNAME_ATTRIBUTE_NAME);
        assertEquals(TestConstants.SURNAME_ATTRIBUTE_NAME,argument.getName());
        assertEquals(AccessMode.RO,argument.getAccessMode());
        assertEquals(TestConstants.SURNAME_ATTRIBUTE_DESCRIPTION,argument.getDescription());
        assertEquals(Short.class,argument.getJavaType());
        assertFalse(argument.isOptional());
        
        assertEquals(1,_event._eventInstances.size());
        
        JmxService service = new JmxService();
        Set<ObjectName> objectNames = service.getEventMBeans();
        
        assertEquals(1,objectNames.size());
    }    
    
    /**
     * Tests the behaviour of the event class when a schema request can't be made.
     * 
     * <br>precondition : event must be in "schema-not-requested" state when incoming data arrives.
     * <br>postcondition : no exception is thrown and no state transition happens.
     */
    public void testStateChange_withRequestSchemaFailure()
    {
    	_event = new QpidEvent(TestConstants.BIND_EVENT_NAME,TestConstants.HASH,_qpidPackage)
    	{
    		@Override
    		void requestSchema() throws Exception {
    			throw new Exception();
    		}
    		
    		@Override
    		void setSchema(List<Map<String, Object>> argumentDefinitions)throws UnableToBuildFeatureException {
    			_state = _schemaInjected;
    		}
    	};
    	
    	assertSame(
    			"Initial state must be schema-not-requested.",
    			_event._schemaNotRequested,
    			_event._state);
    	
    	_event.addEventData(TestConstants.TEST_RAW_DATA, TestConstants.NOW, TestConstants.SEVERITY);
    	
    	assertSame(
    			"Current state must be still schema-not-requested.",
    			_event._schemaNotRequested,
    			_event._state);
    }
    
    /**
     * Tests the behaviour of the event class when a schema injection fails.
     * 
     * <br>precondition : event must be in "schema-not-requested" state when incoming data arrives.
     * <br>postcondition : an exception is thrown and no state transition happens.
     */
    public void testStateChange_withSchemaInjectionFailure()
    {
    	_event = new QpidEvent(TestConstants.BIND_EVENT_NAME,TestConstants.HASH,_qpidPackage)
    	{
    		@Override
    		void requestSchema() throws Exception {
    			// DO NOTHING.
    		}
    		
    		@Override
    		void setSchema(List<Map<String, Object>> argumentDefinitions)throws UnableToBuildFeatureException {
    			throw new UnableToBuildFeatureException("");
    		}
    	};
    	
    	assertSame(
    			"Initial state must be schema-not-requested.",
    			_event._schemaNotRequested,
    			_event._state);
    	
    	_event.addEventData(TestConstants.TEST_RAW_DATA, TestConstants.NOW, TestConstants.SEVERITY);
    	
      	assertSame(
    			"Request schema has been requested but not yet injected. The current state is not indicating that!",
    			_event._schemaRequestedButNotYetInjected,
    			_event._state);
      	
      	try {
			_event.setSchema(TestConstants.EMPTY_ARGUMENTS_SCHEMA);
			fail("If we are here something was wrong becuase the setSchema() of this event is throwing an exception...");
		} catch (UnableToBuildFeatureException expected) {
	      	assertSame(
	    			"Request schema has been requested but not yet injected. The current state is not indicating that!",
	    			_event._schemaRequestedButNotYetInjected,
	    			_event._state);
		}
    }    

    /**
     * Factory method for qpid managed event instances.
     * 
     * @return a new QpidManagedEvent with test data inside.
     */
    private QManManagedEvent createEventInstance()
    {
    	return  _event.createEventInstance(
        		TestConstants.TEST_RAW_DATA, 
        		TestConstants.NOW,
        		TestConstants.SEVERITY);
    }
    
    /**
     * Factory method for event argument.
     * 
     * @return a new argument metadata.
     */
    private Map<String,Object> createArgument(String name,String desc)
    {
    	 Map <String,Object> argument = new HashMap<String, Object>();
         argument.put(QpidFeatureBuilder.Attribute.name.name(),name);
         argument.put(QpidFeatureBuilder.Attribute.desc.name(), desc);
         argument.put(QpidFeatureBuilder.Attribute.type.name(), TestConstants._1);       
         return argument;
    }
}