-#include <boost/function.hpp>

-#include "Swiften/Parser/XMPPParser.h"

-#include "Swiften/Parser/XMPPParserClient.h"

-#include "Swiften/Serializer/XMPPSerializer.h"

-#include "Swiften/StreamStack/TLSLayerFactory.h"

-#include "Swiften/StreamStack/TLSLayer.h"

-#include "Swiften/StreamStack/StreamStack.h"

-#include "Swiften/StreamStack/WhitespacePingLayer.h"

-#include "Swiften/Elements/ProtocolHeader.h"

-#include "Swiften/Elements/Element.h"

-#include "Swiften/Elements/ErrorPayload.h"

-#include "Swiften/Elements/IQ.h"

-#include "Swiften/Elements/ResourceBind.h"

-#include "Swiften/Elements/StartSession.h"

-#include "Swiften/Elements/StartTLSRequest.h"

-#include "Swiften/Elements/StartTLSFailure.h"

-#include "Swiften/Elements/TLSProceed.h"

-#include "Swiften/Elements/Message.h"

-#include "Swiften/EventLoop/MainEventLoop.h"

-#include "Swiften/EventLoop/DummyEventLoop.h"

-#include "Swiften/Network/Connection.h"

-#include "Swiften/Network/ConnectionFactory.h"

-#include "Swiften/Client/ClientSession.h"

-#include "Swiften/TLS/PKCS12Certificate.h"

-#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

-#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

- CPPUNIT_TEST(testConstructor);

- CPPUNIT_TEST(testDisconnect);

- /*

- CPPUNIT_TEST(testStart_XMLError);

- CPPUNIT_TEST(testStartTLS_NoTLSSupport);

- CPPUNIT_TEST(testStartTLS_ErrorAfterConnect);

- ClientSessionTest() {}

-

- eventLoop_ = new DummyEventLoop();

- connection_ = boost::shared_ptr<MockConnection>(new MockConnection());

- tlsLayerFactory_ = new MockTLSLayerFactory();

- sessionStarted_ = false;

- needCredentials_ = false;

- void tearDown() {

- delete tlsLayerFactory_;

- delete eventLoop_;

- void testConstructor() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- CPPUNIT_ASSERT_EQUAL(ClientSession::Initial, session->getState());

- void testDisconnect() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- /*

- session->startSession();

- processEvents();

- session->finishSession();

- processEvents();

- boost::shared_ptr<WhitespacePingLayer> whitespacePingLayer = session->getWhitespacePingLayer();

- CPPUNIT_ASSERT(whitespacePingLayer);

- */

- //CPPUNIT_ASSERT(!whitespacePingLayer->isActive());

-/*

- void testStart_Error() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- session->startSession();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForStreamStart, session->getState());

- getMockServer()->setError();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

- CPPUNIT_ASSERT_EQUAL(ClientSession::ConnectionReadError, *session->getError());

- void testStart_XMLError() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- session->startSession();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForStreamStart, session->getState());

- getMockServer()->sendInvalidXML();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

- CPPUNIT_ASSERT_EQUAL(ClientSession::XMLError, *session->getError());

- }

- void testStartTLS_NoTLSSupport() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- tlsLayerFactory_->setTLSSupported(false);

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- getMockServer()->sendStreamFeaturesWithStartTLS();

- session->startSession();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

- }

- void testStartTLS() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- getMockServer()->sendStreamFeaturesWithStartTLS();

- getMockServer()->expectStartTLS();

- // FIXME: Test 'encrypting' state

- getMockServer()->sendTLSProceed();

- session->startSession();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Encrypting, session->getState());

- CPPUNIT_ASSERT(session->getTLSLayer());

- CPPUNIT_ASSERT(session->getTLSLayer()->isConnecting());

- getMockServer()->resetParser();

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- session->getTLSLayer()->setConnected();

- // FIXME: Test 'WatingForStreamStart' state

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Negotiating, session->getState());

- }

- void testStartTLS_ServerError() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- getMockServer()->sendStreamFeaturesWithStartTLS();

- getMockServer()->expectStartTLS();

- getMockServer()->sendTLSFailure();

- session->startSession();

- processEvents();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

- CPPUNIT_ASSERT_EQUAL(ClientSession::TLSError, *session->getError());

- }

- void testStartTLS_ConnectError() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- getMockServer()->sendStreamFeaturesWithStartTLS();

- getMockServer()->expectStartTLS();

- getMockServer()->sendTLSProceed();

- session->startSession();

- processEvents();

- session->getTLSLayer()->setError();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

- CPPUNIT_ASSERT_EQUAL(ClientSession::TLSError, *session->getError());

- }

- void testStartTLS_ErrorAfterConnect() {

- boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- getMockServer()->sendStreamFeaturesWithStartTLS();

- getMockServer()->expectStartTLS();

- getMockServer()->sendTLSProceed();

- session->startSession();

- processEvents();

- getMockServer()->resetParser();

- getMockServer()->expectStreamStart();

- getMockServer()->sendStreamStart();

- session->getTLSLayer()->setConnected();

- processEvents();

- session->getTLSLayer()->setError();

- CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

- CPPUNIT_ASSERT_EQUAL(ClientSession::TLSError, *session->getError());

- }

-

- private:

- struct MockConnection;

-

- boost::shared_ptr<MockConnection> getMockServer() const {

- return connection_;

- }

-

- void processEvents() {

- eventLoop_->processEvents();

- getMockServer()->assertNoMoreExpectations();

- }

-

- void setSessionStarted() {

- sessionStarted_ = true;

- }

-

- void setNeedCredentials() {

- needCredentials_ = true;

- }

-

- void addReceivedElement(boost::shared_ptr<Element> element) {

- receivedElements_.push_back(element);

- }

-

- private:

- struct MockConnection : public Connection, public XMPPParserClient {

- struct Event {

- enum Direction { In, Out };

- enum Type { StreamStartEvent, StreamEndEvent, ElementEvent };

-

- Event(

- Direction direction,

- Type type,

- boost::shared_ptr<Element> element = boost::shared_ptr<Element>()) :

- direction(direction), type(type), element(element) {}

-

- Direction direction;

- Type type;

- boost::shared_ptr<Element> element;

- };

-

- MockConnection() :

- resetParser_(false),

- domain_("foo.com"),

- parser_(0),

- serializer_(&payloadSerializers_) {

- parser_ = new XMPPParser(this, &payloadParserFactories_);

- }

-

- ~MockConnection() {

- delete parser_;

- }

-

- void disconnect() { }

-

- void listen() {

- assert(false);

- }

-

- void connect(const HostAddressPort&) { assert(false); }

- void connect(const String&) { assert(false); }

-

- void setError() {

- MainEventLoop::postEvent(boost::bind(boost::ref(onDisconnected), Connection::ReadError));

- }

-

- void write(const ByteArray& data) {

- CPPUNIT_ASSERT(parser_->parse(data.toString()));

- if (resetParser_) {

- resetParser();

- resetParser_ = false;

- }

- }

-

- void resetParser() {

- delete parser_;

- parser_ = new XMPPParser(this, &payloadParserFactories_);

- }

-

- void handleStreamStart(const ProtocolHeader& header) {

- CPPUNIT_ASSERT_EQUAL(domain_, header.getTo());

- handleEvent(Event::StreamStartEvent);

- }

-

- void handleElement(boost::shared_ptr<Swift::Element> element) {

- handleEvent(Event::ElementEvent, element);

- }

-

- void handleStreamEnd() {

- handleEvent(Event::StreamEndEvent);

- }

-

- void handleEvent(Event::Type type, boost::shared_ptr<Element> element = boost::shared_ptr<Element>()) {

- CPPUNIT_ASSERT(!events_.empty());

- CPPUNIT_ASSERT_EQUAL(events_[0].direction, Event::In);

- CPPUNIT_ASSERT_EQUAL(events_[0].type, type);

- if (type == Event::ElementEvent) {

- CPPUNIT_ASSERT_EQUAL(serializer_.serializeElement(events_[0].element), serializer_.serializeElement(element));

- }

- events_.pop_front();

-

- while (!events_.empty() && events_[0].direction == Event::Out) {

- sendData(serializeEvent(events_[0]));

- events_.pop_front();

- }

-

- if (!events_.empty() && events_[0].type == Event::StreamStartEvent) {

- resetParser_ = true;

- }

- }

-

- String serializeEvent(const Event& event) {

- switch (event.type) {

- case Event::StreamStartEvent:

- {

- ProtocolHeader header;

- header.setTo(domain_);

- return serializer_.serializeHeader(header);

- }

- case Event::ElementEvent:

- return serializer_.serializeElement(event.element);

- case Event::StreamEndEvent:

- return serializer_.serializeFooter();

- }

- assert(false);

- return "";

- }

-

- void assertNoMoreExpectations() {

- foreach (const Event& event, events_) {

- std::cout << "Unprocessed event: " << serializeEvent(event) << std::endl;

- }

- CPPUNIT_ASSERT(events_.empty());

- }

-

- void sendData(const ByteArray& data) {

- MainEventLoop::postEvent(boost::bind(boost::ref(onDataRead), data));

- }

-

- void expectStreamStart() {

- events_.push_back(Event(Event::In, Event::StreamStartEvent));

- }

-

- void expectStartTLS() {

- events_.push_back(Event(Event::In, Event::ElementEvent, boost::shared_ptr<StartTLSRequest>(new StartTLSRequest())));

- }

-

- void expectAuth(const String& user, const String& password) {

- String s = String("") + '\0' + user + '\0' + password;

- events_.push_back(Event(Event::In, Event::ElementEvent, boost::shared_ptr<AuthRequest>(new AuthRequest("PLAIN", ByteArray(s.getUTF8Data(), s.getUTF8Size())))));

- }

-

- void expectResourceBind(const String& resource, const String& id) {

- boost::shared_ptr<ResourceBind> sessionStart(new ResourceBind());

- sessionStart->setResource(resource);

- events_.push_back(Event(Event::In, Event::ElementEvent, IQ::createRequest(IQ::Set, JID(), id, sessionStart)));

- }

-

- void expectSessionStart(const String& id) {

- events_.push_back(Event(Event::In, Event::ElementEvent, IQ::createRequest(IQ::Set, JID(), id, boost::shared_ptr<StartSession>(new StartSession()))));

- }

-

- void expectMessage() {

- events_.push_back(Event(Event::In, Event::ElementEvent, boost::shared_ptr<Message>(new Message())));

- }

-

- void sendInvalidXML() {

- sendData("<invalid xml/>");

- }

-

- void sendStreamStart() {

- events_.push_back(Event(Event::Out, Event::StreamStartEvent));

- }

-

- void sendStreamFeatures() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithStartTLS() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->setHasStartTLS();

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithAuthentication() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->addAuthenticationMechanism("PLAIN");

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithUnsupportedAuthentication() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->addAuthenticationMechanism("MY-UNSUPPORTED-MECH");

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithResourceBind() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->setHasResourceBind();

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithSession() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->setHasSession();

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendStreamFeaturesWithResourceBindAndSession() {

- boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

- streamFeatures->setHasResourceBind();

- streamFeatures->setHasSession();

- events_.push_back(Event(Event::Out, Event::ElementEvent, streamFeatures));

- }

-

- void sendMessage() {

- events_.push_back(Event(Event::Out, Event::ElementEvent, boost::shared_ptr<Message>(new Message())));

- }

-

- void sendTLSProceed() {

- events_.push_back(Event(Event::Out, Event::ElementEvent, boost::shared_ptr<TLSProceed>(new TLSProceed())));

- }

-

- void sendTLSFailure() {

- events_.push_back(Event(Event::Out, Event::ElementEvent, boost::shared_ptr<StartTLSFailure>(new StartTLSFailure())));

- }

-

- void sendAuthSuccess() {

- events_.push_back(Event(Event::Out, Event::ElementEvent, boost::shared_ptr<AuthSuccess>(new AuthSuccess())));

- }

-

- void sendAuthFailure() {

- events_.push_back(Event(Event::Out, Event::ElementEvent, boost::shared_ptr<AuthFailure>(new AuthFailure())));

- }

-

- void sendResourceBindResponse(const String& jid, const String& id) {

- boost::shared_ptr<ResourceBind> sessionStart(new ResourceBind());

- sessionStart->setJID(JID(jid));

- events_.push_back(Event(Event::Out, Event::ElementEvent, IQ::createResult(JID(), id, sessionStart)));

- }

-

- void sendError(const String& id) {

- events_.push_back(Event(Event::Out, Event::ElementEvent, IQ::createError(JID(), id, Swift::Error::NotAllowed, Swift::Error::Cancel)));

- }

-

- void sendSessionStartResponse(const String& id) {

- events_.push_back(Event(Event::Out, Event::ElementEvent, IQ::createResult(JID(), id, boost::shared_ptr<StartSession>(new StartSession()))));

- }

-

- bool resetParser_;

- String domain_;

- XMPPParser* parser_;

- XMPPSerializer serializer_;

- std::deque<Event> events_;

- };

-

- */

-

- private:

- void processEvents() {

- eventLoop_->processEvents();

- }

-

-

- private:

- struct MockConnection : public Connection, public XMPPParserClient {

- MockConnection() :

- resetParser_(false),

- serializer_(&payloadSerializers_) {

- parser_ = new XMPPParser(this, &payloadParserFactories_);

- }

-

- ~MockConnection() {

- delete parser_;

- }

-

- void handleStreamStart(const ProtocolHeader& header) {

- }

-

- void handleElement(boost::shared_ptr<Swift::Element> element) {

- }

-

- void handleStreamEnd() {

- }

-

- void disconnect() { }

- void listen() { assert(false); }

- void connect(const HostAddressPort&) { CPPUNIT_ASSERT(false); }

- void connect(const String&) { CPPUNIT_ASSERT(false); }

-

- void write(const ByteArray& data) {

- CPPUNIT_ASSERT(parser_->parse(data.toString()));

- if (resetParser_) {

- resetParser();

- resetParser_ = false;

- }

- }

-

- void resetParser() {

- delete parser_;

- parser_ = new XMPPParser(this, &payloadParserFactories_);

- }

-

- FullPayloadParserFactoryCollection payloadParserFactories_;

- FullPayloadSerializerCollection payloadSerializers_;

- bool resetParser_;

- XMPPParser* parser_;

- XMPPSerializer serializer_;

- };

-

- struct MockTLSLayer : public TLSLayer {

- MockTLSLayer() : connecting_(false) {}

-

- bool setClientCertificate(const PKCS12Certificate&) { return true; }

- void writeData(const ByteArray& data) { onWriteData(data); }

- void handleDataRead(const ByteArray& data) { onDataRead(data); }

- void setConnected() { onConnected(); }

- void setError() { onError(); }

- void connect() { connecting_ = true; }

- bool isConnecting() { return connecting_; }

-

- bool connecting_;

- };

-

- struct MockTLSLayerFactory : public TLSLayerFactory {

- MockTLSLayerFactory() : haveTLS_(true) {}

-

- void setTLSSupported(bool b) { haveTLS_ = b; }

-

- virtual bool canCreate() const { return haveTLS_; }

-

- virtual boost::shared_ptr<TLSLayer> createTLSLayer() {

- CPPUNIT_ASSERT(haveTLS_);

- boost::shared_ptr<MockTLSLayer> result(new MockTLSLayer());

- layers_.push_back(result);

- return result;

- }

-

- std::vector< boost::shared_ptr<MockTLSLayer> > layers_;

- bool haveTLS_;

- };

-

- struct MockSession : public ClientSession {

- MockSession(

- const JID& jid,

- boost::shared_ptr<Connection> connection,

- TLSLayerFactory* tlsLayerFactory,

- PayloadParserFactoryCollection* payloadParserFactories,

- PayloadSerializerCollection* payloadSerializers) :

- ClientSession(jid, connection, tlsLayerFactory, payloadParserFactories, payloadSerializers) {}

-

- boost::shared_ptr<MockTLSLayer> getTLSLayer() const {

- return getStreamStack()->getLayer<MockTLSLayer>();

- }

-

- boost::shared_ptr<WhitespacePingLayer> getWhitespacePingLayer() const {

- return getStreamStack()->getLayer<WhitespacePingLayer>();

- }

- };

-

- boost::shared_ptr<MockSession> createSession(const String& jid) {

- return boost::shared_ptr<MockSession>(new MockSession(JID(jid), connection_, tlsLayerFactory_, &payloadParserFactories_, &payloadSerializers_));

- }

-

- private:

- FullPayloadParserFactoryCollection payloadParserFactories_;

- FullPayloadSerializerCollection payloadSerializers_;

- DummyEventLoop* eventLoop_;

- boost::shared_ptr<MockConnection> connection_;

- MockTLSLayerFactory* tlsLayerFactory_;

- bool sessionStarted_;

- bool needCredentials_;

- std::vector< boost::shared_ptr<Element> > receivedElements_;

- /*

- typedef std::vector< boost::function<void ()> > EventQueue;

- EventQueue events_;*/

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(ClientSessionTest);