DataSerializerTest.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "../DataSerializer.h"
#include "../BodyEnd.h"
#include "generated/BodyReaderMock.h"
#include "generated/BodyWriterMock.h"
#include "generated/DataSerializerDriver.h"
#include "generated/ProtocolMock.h"
#include "Imports.cpp"

namespace Protocols {
namespace Http {
namespace Testing {


class DataSerializerTest : public CppUnit::TestFixture
{
    CPPUNIT_TEST_SUITE (DataSerializerTest);
    CPPUNIT_TEST (testReadHeaderFails);
    CPPUNIT_TEST (testReadHeader);
    CPPUNIT_TEST (testReadHeaderLfLfTerminated);
    CPPUNIT_TEST (testReadBodyOfOneChunk);
    CPPUNIT_TEST (testReadTwoMessages);
    CPPUNIT_TEST (testReadMessageWithInterrupts);
    CPPUNIT_TEST (testWriteHeaderFails);
    CPPUNIT_TEST (testWriteHeaderOK);
    CPPUNIT_TEST (testWriteBodyOfOneChunk);
    CPPUNIT_TEST (testWriteBodyOfMultipleChunksWithDelays);
    CPPUNIT_TEST (writeTwoMessages);
    CPPUNIT_TEST_SUITE_END();

    auto_ptr <TransportMock>            transport;
    auto_ptr <ProtocolMock>             protocol;
    auto_ptr <BodyReaderMock>           bodyReader;
    auto_ptr <BodyWriterMock>           bodyWriter;
    auto_ptr <DataSerializer>           serializerReal;
    auto_ptr <DataSerializerDriver>     serializer;

    HeaderBase                          header;
    BodyEnd                             bodyEnd;
    QList <Data>                        chunks;

public:
    void setUp()
    {
        transport.reset (new TransportMock);
        protocol.reset (new ProtocolMock);
        bodyReader.reset (new BodyReaderMock);
        bodyWriter.reset (new BodyWriterMock);
        serializerReal.reset (new DataSerializer (*protocol));
        serializer.reset (new DataSerializerDriver (*serializerReal));

        header = HeaderBase();
        header.setFieldValue ("Transfer-Encoding", "identity");
        header.setFieldValue ("Content-Length", "10");
        bodyEnd = BodyEnd();
        bodyEnd.setFieldValue ("Content-MD5", "Q2hlY2sgSW50ZWdyaXR5IQ==");
        chunks = QList <Data>();
    }

    void tearDown()
    {
        serializer.reset();
        serializerReal.reset();
        bodyWriter.reset();
        bodyReader.reset();
        protocol.reset();
        transport.reset();
    }


    void refReadHeaderFails()
    {
        Data readHeader;
        call (serializer->read (readHeader, *transport))
            .willCall (transport->readTo ("\r\n\r\n"))
            .willReturn (QByteArray())
            .willCall (transport->readTo ("\n\n"))
            .willReturn (QByteArray())
        .willReturn (false);

        willBeEqual (readHeader, Data());
    }

    void refReadHeaderOK (const Header &header)
    {
        Data readHeader;
        call (serializer->read (readHeader, *transport))
            .willCall (transport->readTo ("\r\n\r\n"))
            .willReturn (header->toRawBytes())
            .willCall (protocol->createHeader (header->toRawBytes()))
            .willReturn (header)
            .willCall (protocol->createBodyReader (header))
            .willReturn (*bodyReader)
        .willReturn (true);

        willBeEqual (readHeader, Data (header));
    }

    void refReadLfTerminatedHeaderOK (const Header &header)
    {
        QByteArray rawHeader = header->toRawBytes().replace ("\r\n", "\n");
        Data readHeader;
        call (serializer->read (readHeader, *transport))
            .willCall (transport->readTo ("\r\n\r\n"))
            .willReturn (QByteArray())
            .willCall (transport->readTo ("\n\n"))
            .willReturn (rawHeader)
            .willCall (protocol->createHeader (rawHeader))
            .willReturn (header)
            .willCall (protocol->createBodyReader (header))
            .willReturn (*bodyReader)
        .willReturn (true);

        willBeEqual (readHeader, Data (header));
    }

    void refReadBodyChunk (const Data &chunk)
    {
        Data readBodyChunk;
        call (serializer->read (readBodyChunk, *transport))
            .willCall (bodyReader->read (*transport))
            .willReturn (chunk)
        .willReturn (true);

        willBeEqual (chunk, readBodyChunk);
    }

    void refReadBodyChunkFails()
    {
        Data readBodyChunk;
        call (serializer->read (readBodyChunk, *transport))
            .willCall (bodyReader->read (*transport))
            .willReturn (Data())
        .willReturn (false);

        willBeEqual (Data(), readBodyChunk);
    }

    void refReadBodyEnd()
    {
        Data readBodyChunk;
        call (serializer->read (readBodyChunk, *transport))
            .willCall (bodyReader->read (*transport))
            .willReturn (bodyEnd)
            .willCall (protocol->destroyBodyReader (*bodyReader))
            .returns()
        .willReturn (true);

        willBeEqual (Data (bodyEnd), readBodyChunk);
    }

    void stateReadingHeader()
    {
        refReadHeaderFails();
    }

    void stateReadingBody (const Header &header)
    {
        refReadHeaderOK (header);
    }

    void postStateReadingHeader()
    {
        refReadHeaderFails();
    }

    void postStateReadingBody()
    {
        refReadBodyChunkFails();
    }

    void scenarioReadHeaderFails()
    {
        stateReadingHeader();
        refReadHeaderFails();
        postStateReadingHeader();
    }

    void scenarioReadHeaderOK (const Header &header, bool lfTerminated = false)
    {
        stateReadingHeader();
        if (!lfTerminated)
            refReadHeaderOK (header);
        else
            refReadLfTerminatedHeaderOK (header);
        postStateReadingBody();
    }

    void scenarioReadBody (const Header &header,
                           const QList <Data> &bodyChunks)
    {
        stateReadingBody (header);

        foreach (Data bodyChunk, bodyChunks) {
            if (bodyChunk != Data())
                refReadBodyChunk (bodyChunk);
            else
                refReadBodyChunkFails();
        }
        refReadBodyEnd();

        postStateReadingHeader();
    }

    void testReadHeaderFails()
    {
        scenarioReadHeaderFails();
    }

    void testReadHeader()
    {
        scenarioReadHeaderOK (header);
    }

    void testReadHeaderLfLfTerminated()
    {
        scenarioReadHeaderOK (header, true);
    }

    void testReadBodyOfOneChunk()
    {
        chunks += RawData (QByteArray (40, '1'));
        scenarioReadBody (header, chunks);
    }

    void testReadTwoMessages()
    {
        testReadBodyOfOneChunk();
        testReadBodyOfOneChunk();
    }

    void testReadMessageWithInterrupts()
    {
        chunks += RawData (QByteArray (40, '1'));
        chunks += Data(); // The interruption of body chunks.
        chunks += RawData (QByteArray (10, '2'));
        scenarioReadBody (header, chunks);
    }

    void refWriteHeaderSucceeds (const Header &header)
    {
        call (serializer->write (header, *transport))
            .willCall (transport->write (header->toRawBytes()))
            .willReturn (true)
            .willCall (protocol->createBodyWriter (header))
            .willReturn (*bodyWriter)
        .willReturn (true);
    }

    void refWriteHeaderFails (const Header &header)
    {
        call (serializer->write (header, *transport))
            .willCall (transport->write (header->toRawBytes()))
            .willReturn (false)
        .willReturn (false);
    }

    void refWriteBodyChunk (const Data &chunk, bool willSucceed)
    {
        call (serializer->write (chunk, *transport))
            .willCall (bodyWriter->write (chunk, *transport))
            .willReturn (willSucceed)
        .willReturn (willSucceed);
    }

    void stateWritingHeader()
    {
        refWriteHeaderFails (Header());
    }

    void stateWritingBody (const Header &header)
    {
        refWriteHeaderSucceeds (header);
    }

    void postStateWritingHeader()
    {
        refWriteHeaderFails (Header());
    }

    void postStateWritingBody()
    {
        refWriteBodyChunk (RawData(), true);
    }


    void scenarioWriteHeaderFails (const Header &header)
    {
        stateWritingHeader();
        refWriteHeaderFails (header);
        postStateWritingHeader();
    }


    void scenarioWriteHeaderOK (const Header &header)
    {
        stateWritingHeader();
        refWriteHeaderSucceeds (header);
        postStateWritingBody();
    }


    void scenarioWriteBody (const Header &header, const QList <Data> &chunks)
    {
        stateWritingBody (header);

        foreach (Data chunk, chunks) {
            refWriteBodyChunk (chunk, false); // Optional in reality...
            refWriteBodyChunk (chunk, true);
        }
        refWriteBodyChunk (bodyEnd, false); // Optional in reality...
        call (serializer->write (bodyEnd, *transport))
            .willCall (bodyWriter->write (bodyEnd, *transport))
            .willReturn (true)
            .willCall (protocol->destroyBodyWriter (*bodyWriter))
            .returns()
        .willReturn (true);

        postStateWritingHeader();
    }

    void testWriteHeaderFails()
    {
        scenarioWriteHeaderFails (header);
    }

    void testWriteHeaderOK()
    {
        scenarioWriteHeaderOK (header);
    }

    void testWriteBodyOfOneChunk()
    {
        chunks += RawData (QByteArray (20, '2'));
        scenarioWriteBody (header, chunks);
    }

    void testWriteBodyOfMultipleChunksWithDelays()
    {
        chunks += RawData (QByteArray (20, '1'));
        chunks += Data();
        chunks += RawData (QByteArray (20, '3'));
        scenarioWriteBody (header, chunks);
    }

    void writeTwoMessages()
    {
        testWriteBodyOfMultipleChunksWithDelays();
        testWriteBodyOfMultipleChunksWithDelays();
    }
};

CPPUNIT_TEST_SUITE_REGISTRATION (DataSerializerTest);

} // namespace Testing
} // namespace Http
} // namespace Protocols

Copyright © 2006 Peter Dimov.
Powered by Doxygen.