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

import java.util.Date;

import org.apache.camel.builder.ExpressionBuilder;
import org.apache.camel.impl.DefaultExchange;

/**
 * @version 
 */
public class CamelExceptionsTest extends ContextTestSupport {

    public void testExpectedBodyTypeException() {
        Exchange exchange = new DefaultExchange(context);

        ExpectedBodyTypeException e = new ExpectedBodyTypeException(exchange, Integer.class);
        assertSame(exchange, e.getExchange());
        assertEquals(Integer.class, e.getExpectedBodyType());
    }

    public void testExpressionEvaluationException() {
        Expression exp = ExpressionBuilder.constantExpression("foo");
        Exchange exchange = new DefaultExchange(context);

        ExpressionEvaluationException e = new ExpressionEvaluationException(exp, exchange, new IllegalArgumentException("Damn"));
        assertSame(exchange, e.getExchange());
        assertSame(exp, e.getExpression());
        assertNotNull(e.getCause());
    }

    public void testFailedToCreateConsumerException() {
        Endpoint endpoint = context.getEndpoint("seda:foo");
        FailedToCreateConsumerException e = new FailedToCreateConsumerException(endpoint, new IllegalArgumentException("Damn"));

        assertEquals(endpoint.getEndpointUri(), e.getUri());
        assertNotNull(e.getCause());
    }

    public void testFailedToCreateProducerException() {
        Endpoint endpoint = context.getEndpoint("seda:foo");
        FailedToCreateProducerException e = new FailedToCreateProducerException(endpoint, new IllegalArgumentException("Damn"));

        assertEquals(endpoint.getEndpointUri(), e.getUri());
        assertNotNull(e.getCause());
    }

    public void testInvalidPayloadRuntimeException() {
        Exchange exchange = new DefaultExchange(context);

        InvalidPayloadRuntimeException e = new InvalidPayloadRuntimeException(exchange, Integer.class);
        assertSame(exchange, e.getExchange());
        assertEquals(Integer.class, e.getType());

        InvalidPayloadRuntimeException e2 = new InvalidPayloadRuntimeException(exchange, Integer.class, exchange.getIn());
        assertSame(exchange, e2.getExchange());
        assertEquals(Integer.class, e2.getType());

        InvalidPayloadRuntimeException e3 = new InvalidPayloadRuntimeException(exchange, Integer.class, exchange.getIn(), new IllegalArgumentException("Damn"));
        assertSame(exchange, e3.getExchange());
        assertEquals(Integer.class, e3.getType());
    }

    public void testRuntimeTransformException() {
        RuntimeTransformException e = new RuntimeTransformException("Forced");
        assertEquals("Forced", e.getMessage());
        assertNull(e.getCause());

        RuntimeTransformException e2 = new RuntimeTransformException("Forced", new IllegalAccessException("Damn"));
        assertEquals("Forced", e2.getMessage());
        assertNotNull(e2.getCause());

        RuntimeTransformException e3 = new RuntimeTransformException(new IllegalAccessException("Damn"));
        assertEquals("java.lang.IllegalAccessException: Damn", e3.getMessage());
        assertNotNull(e3.getCause());
    }
    
    public void testRuntimeExpressionException() {
        RuntimeExpressionException e = new RuntimeExpressionException("Forced");
        assertEquals("Forced", e.getMessage());
        assertNull(e.getCause());

        RuntimeExpressionException e2 = new RuntimeExpressionException("Forced", new IllegalAccessException("Damn"));
        assertEquals("Forced", e2.getMessage());
        assertNotNull(e2.getCause());

        RuntimeExpressionException e3 = new RuntimeExpressionException(new IllegalAccessException("Damn"));
        assertEquals("java.lang.IllegalAccessException: Damn", e3.getMessage());
        assertNotNull(e3.getCause());
    }

    public void testRollbackExchangeException() {
        Exchange exchange = new DefaultExchange(context);

        RollbackExchangeException e = new RollbackExchangeException(exchange, new IllegalAccessException("Damn"));
        assertNotNull(e.getMessage());
        assertSame(exchange, e.getExchange());

        RollbackExchangeException e2 = new RollbackExchangeException("Forced", exchange, new IllegalAccessException("Damn"));
        assertNotNull(e2.getMessage());
        assertSame(exchange, e2.getExchange());
    }

    public void testValidationException() {
        Exchange exchange = new DefaultExchange(context);

        ValidationException e = new ValidationException(exchange, "Forced");
        assertNotNull(e.getMessage());
        assertSame(exchange, e.getExchange());

        ValidationException e2 = new ValidationException("Forced", exchange, new IllegalAccessException("Damn"));
        assertNotNull(e2.getMessage());
        assertSame(exchange, e2.getExchange());
    }

    public void testNoSuchBeanException() {
        NoSuchBeanException e = new NoSuchBeanException("foo");
        assertEquals("foo", e.getName());
        assertNull(e.getCause());

        NoSuchBeanException e2 = new NoSuchBeanException("foo", new IllegalArgumentException("Damn"));
        assertEquals("foo", e2.getName());
        assertNotNull(e2.getCause());
    }

    public void testCamelExecutionException() {
        Exchange exchange = new DefaultExchange(context);

        CamelExecutionException e = new CamelExecutionException("Forced", exchange);
        assertNotNull(e.getMessage());
        assertSame(exchange, e.getExchange());
        assertNull(e.getCause());

        CamelExecutionException e2 = new CamelExecutionException("Forced", exchange, new IllegalArgumentException("Damn"));
        assertNotNull(e2.getMessage());
        assertSame(exchange, e2.getExchange());
        assertNotNull(e2.getCause());
    }

    public void testCamelException() {
        CamelException e = new CamelException();
        assertNull(e.getCause());

        CamelException e2 = new CamelException("Forced");
        assertNull(e2.getCause());
        assertEquals("Forced", e2.getMessage());
        
        CamelException e3 = new CamelException("Forced", new IllegalArgumentException("Damn"));
        assertNotNull(e3.getCause());
        assertEquals("Forced", e3.getMessage());

        CamelException e4 = new CamelException(new IllegalArgumentException("Damn"));
        assertNotNull(e4.getCause());
        assertNotNull(e4.getMessage());
    }

    public void testServiceStatus() {
        assertTrue(ServiceStatus.Started.isStarted());
        assertFalse(ServiceStatus.Starting.isStarted());
        assertFalse(ServiceStatus.Starting.isStoppable());
        assertFalse(ServiceStatus.Stopped.isStarted());
        assertFalse(ServiceStatus.Stopping.isStarted());

        assertTrue(ServiceStatus.Stopped.isStopped());
        assertFalse(ServiceStatus.Starting.isStopped());
        assertFalse(ServiceStatus.Started.isStopped());
        assertFalse(ServiceStatus.Stopping.isStopped());

        assertTrue(ServiceStatus.Stopped.isStartable());
        assertFalse(ServiceStatus.Started.isStartable());
        assertFalse(ServiceStatus.Starting.isStartable());
        assertFalse(ServiceStatus.Stopping.isStartable());

        assertTrue(ServiceStatus.Started.isStoppable());
        assertFalse(ServiceStatus.Starting.isStoppable());
        assertFalse(ServiceStatus.Stopped.isStoppable());
        assertFalse(ServiceStatus.Stopping.isStoppable());
    }

    public void testRuntimeExchangeException() {
        Exchange exchange = new DefaultExchange(context);

        RuntimeExchangeException e = new RuntimeExchangeException("Forced", exchange);
        assertNotNull(e.getMessage());
        assertSame(exchange, e.getExchange());

        RuntimeExchangeException e2 = new RuntimeExchangeException("Forced", null);
        assertNotNull(e2.getMessage());
        assertNull(e2.getExchange());
    }

    public void testExchangePattern() {
        assertTrue(ExchangePattern.InOnly.isInCapable());
        assertTrue(ExchangePattern.InOptionalOut.isInCapable());
        assertTrue(ExchangePattern.InOut.isInCapable());
        assertFalse(ExchangePattern.RobustOutOnly.isInCapable());

        assertFalse(ExchangePattern.InOnly.isFaultCapable());
        assertTrue(ExchangePattern.InOptionalOut.isFaultCapable());
        assertTrue(ExchangePattern.InOut.isFaultCapable());

        assertFalse(ExchangePattern.InOnly.isOutCapable());
        assertTrue(ExchangePattern.InOptionalOut.isOutCapable());
        assertTrue(ExchangePattern.InOut.isOutCapable());

        assertEquals(ExchangePattern.InOnly, ExchangePattern.asEnum("InOnly"));
        assertEquals(ExchangePattern.InOut, ExchangePattern.asEnum("InOut"));

        try {
            ExchangePattern.asEnum("foo");
            fail("Should have thrown an exception");
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    public void testInvalidPayloadException() {
        Exchange exchange = new DefaultExchange(context);

        InvalidPayloadException e = new InvalidPayloadException(exchange, Integer.class);
        assertSame(exchange, e.getExchange());
        assertEquals(Integer.class, e.getType());
    }

    public void testExchangeTimedOutException() {
        Exchange exchange = new DefaultExchange(context);

        ExchangeTimedOutException e = new ExchangeTimedOutException(exchange, 5000);
        assertSame(exchange, e.getExchange());
        assertEquals(5000, e.getTimeout());
    }

    public void testExpressionIllegalSyntaxException() {
        ExpressionIllegalSyntaxException e = new ExpressionIllegalSyntaxException("foo");
        assertEquals("foo", e.getExpression());
    }

    public void testNoFactoryAvailableException() {
        NoFactoryAvailableException e = new NoFactoryAvailableException("killer", new IllegalArgumentException("Damn"));
        assertNotNull(e.getCause());
        assertEquals("killer", e.getUri());
    }

    public void testCamelExchangeException() {
        Exchange exchange = new DefaultExchange(context);

        CamelExchangeException e = new CamelExchangeException("Forced", exchange);
        assertNotNull(e.getMessage());
        assertSame(exchange, e.getExchange());
    }

    public void testNoSuchHeaderException() {
        Exchange exchange = new DefaultExchange(context);

        NoSuchHeaderException e = new NoSuchHeaderException(exchange, "foo", Integer.class);
        assertEquals(Integer.class, e.getType());
        assertEquals("foo", e.getHeaderName());
        assertSame(exchange, e.getExchange());
    }
    
    public void testNoSuchPropertyException() {
        Exchange exchange = new DefaultExchange(context);

        NoSuchPropertyException e = new NoSuchPropertyException(exchange, "foo", Integer.class);
        assertEquals(Integer.class, e.getType());
        assertEquals("foo", e.getPropertyName());
        assertSame(exchange, e.getExchange());
    }

    public void testRuntimeCamelException() {
        RuntimeCamelException e = new RuntimeCamelException();
        assertNull(e.getMessage());
        assertNull(e.getCause());
    }

    public void testFailedToStartRouteException() {
        FailedToStartRouteException e = new FailedToStartRouteException(new IllegalArgumentException("Forced"));
        assertNotNull(e.getMessage());
        assertIsInstanceOf(IllegalArgumentException.class, e.getCause());
    }

    public void testNoTypeConversionAvailableException() {
        NoTypeConversionAvailableException e = new NoTypeConversionAvailableException("foo", Date.class);
        assertEquals("foo", e.getValue());
        assertEquals(Date.class, e.getToType());
        assertEquals(String.class, e.getFromType());

        NoTypeConversionAvailableException e2 = new NoTypeConversionAvailableException(null, Date.class);
        assertNull(e2.getValue());
        assertEquals(Date.class, e2.getToType());
        assertNull(null, e2.getFromType());
    }

    public void testResolveEndpointFailedException() {
        ResolveEndpointFailedException e = new ResolveEndpointFailedException("foo:bar");
        assertEquals("foo:bar", e.getUri());
    }

}