RC9/qpid/java/systests/src/old_test/java/org/apache/qpid/server/protocol/TestProtocolInitiation.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.server.protocol;

import org.apache.qpid.codec.AMQDecoder;
import org.apache.qpid.codec.AMQEncoder;
import org.apache.qpid.framing.*;
import org.apache.mina.common.ByteBuffer;
import org.apache.mina.common.WriteFuture;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.support.SimpleProtocolDecoderOutput;

import junit.framework.TestCase;

/**
 * This test suite tests the handling of protocol initiation frames and related issues.
 */
public class TestProtocolInitiation extends TestCase implements ProtocolVersionList
{
    private AMQPFastProtocolHandler _protocolHandler;

    private MockIoSession _mockIoSession;

    /**
     * We need to use the object encoder mechanism so to allow us to retrieve the
     * output (a bytebuffer) we define our own encoder output class. The encoder
     * writes the encoded data to this class, from where we can retrieve it during
     * the test run.
     */
    private class TestProtocolEncoderOutput implements ProtocolEncoderOutput
    {
        public ByteBuffer result;

        public void write(ByteBuffer buf)
        {
            result = buf;
        }

        public void mergeAll()
        {
            throw new UnsupportedOperationException();
        }

        public WriteFuture flush()
        {
            throw new UnsupportedOperationException();
        }
    }

    private class TestProtocolDecoderOutput implements ProtocolDecoderOutput
    {
        public Object result;

        public void write(Object buf)
        {
            result = buf;
        }

        public void flush()
        {
            throw new UnsupportedOperationException();
        }
    }

    protected void setUp() throws Exception
    {
        super.setUp();
        _mockIoSession = new MockIoSession();
        _protocolHandler = new AMQPFastProtocolHandler(null, null);
    }


    /**
     * Tests that the AMQDecoder handles invalid protocol classes
     * @throws Exception
     */
    public void testDecoderValidateProtocolClass() throws Exception
    {
        try
        {
            ProtocolInitiation pi = createValidProtocolInitiation();
            pi.protocolClass = 2;
            decodePI(pi);
            fail("expected exception did not occur");
        }
        catch (AMQProtocolClassException m)
        {
            // ok
        }
        catch (Exception e)
        {
            fail("expected AMQProtocolClassException, got " + e);
        }
    }

    /**
     * Tests that the AMQDecoder handles invalid protocol instance numbers
     * @throws Exception
     */
    public void testDecoderValidatesProtocolInstance() throws Exception
    {
        try
        {
            ProtocolInitiation pi = createValidProtocolInitiation();
            pi.protocolInstance = 2;
            decodePI(pi);
            fail("expected exception did not occur");
        }
        catch (AMQProtocolInstanceException m)
        {
            // ok
        }
        catch (Exception e)
        {
            fail("expected AMQProtocolInstanceException, got " + e);
        }
    }

    /**
     * Tests that the AMQDecoder handles invalid protocol major
     * @throws Exception
     */
    public void testDecoderValidatesProtocolMajor() throws Exception
    {
        try
        {
            ProtocolInitiation pi = createValidProtocolInitiation();
            pi.protocolMajor = 2;
            decodePI(pi);
            fail("expected exception did not occur");
        }
        catch (AMQProtocolVersionException m)
        {
            // ok
        }
        catch (Exception e)
        {
            fail("expected AMQProtocolVersionException, got " + e);
        }
    }

    /**
     * Tests that the AMQDecoder handles invalid protocol minor
     * @throws Exception
     */
    public void testDecoderValidatesProtocolMinor() throws Exception
    {
        try
        {
            ProtocolInitiation pi = createValidProtocolInitiation();
            pi.protocolMinor = 99;
            decodePI(pi);
            fail("expected exception did not occur");
        }
        catch (AMQProtocolVersionException m)
        {
            // ok
        }
        catch (Exception e)
        {
            fail("expected AMQProtocolVersionException, got " + e);
        }
    }

    /**
     * Tests that the AMQDecoder accepts a valid PI
     * @throws Exception
     */
    public void testDecoderValidatesHeader() throws Exception
    {
        try
        {
            ProtocolInitiation pi = createValidProtocolInitiation();
            pi.header = new char[] {'P', 'Q', 'M', 'A' };
            decodePI(pi);
            fail("expected exception did not occur");
        }
        catch (AMQProtocolHeaderException m)
        {
            // ok
        }
        catch (Exception e)
        {
            fail("expected AMQProtocolHeaderException, got " + e);
        }
    }

    /**
     * Test that a valid header is passed by the decoder.
     * @throws Exception
     */
    public void testDecoderAcceptsValidHeader() throws Exception
    {
        ProtocolInitiation pi = createValidProtocolInitiation();
        decodePI(pi);
    }

    /**
     * This test checks that an invalid protocol header results in the
     * connection being closed.
     */
    public void testInvalidProtocolHeaderClosesConnection() throws Exception
    {
        AMQProtocolHeaderException pe = new AMQProtocolHeaderException("Test");
        _protocolHandler.exceptionCaught(_mockIoSession, pe);
        assertNotNull(_mockIoSession.getLastWrittenObject());
        Object piResponse = _mockIoSession.getLastWrittenObject();
        assertEquals(piResponse.getClass(), ProtocolInitiation.class);
        ProtocolInitiation pi = (ProtocolInitiation) piResponse;
        assertEquals("Protocol Initiation sent out was not the broker's expected header", pi,
                            createValidProtocolInitiation());
        assertTrue("Session has not been closed", _mockIoSession.isClosing());
    }

    private ProtocolInitiation createValidProtocolInitiation()
    {
        /* Find last protocol version in protocol version list. Make sure last protocol version
        listed in the build file (build-module.xml) is the latest version which will be used
        here. */
        int i = pv.length - 1;
        return new ProtocolInitiation(pv[i][PROTOCOL_MAJOR], pv[i][PROTOCOL_MINOR]);
    }

    /**
     * Helper that encodes a protocol initiation and attempts to decode it
     * @param pi
     * @throws Exception
     */
    private void decodePI(ProtocolInitiation pi) throws Exception
    {
        // we need to do this test at the level of the decoder since we initially only expect PI frames
        // so the protocol handler is not set up to know whether it should be expecting a PI frame or
        // a different type of frame
        AMQDecoder decoder = new AMQDecoder(true);
        AMQEncoder encoder = new AMQEncoder();
        TestProtocolEncoderOutput peo = new TestProtocolEncoderOutput();
        encoder.encode(_mockIoSession, pi, peo);
        TestProtocolDecoderOutput pdo = new TestProtocolDecoderOutput();
        decoder.decode(_mockIoSession, peo.result, pdo);
        ((ProtocolInitiation) pdo.result).checkVersion(this);
    }

    public static junit.framework.Test suite()
    {
        return new junit.framework.TestSuite(TestProtocolInitiation.class);
    }
}