+ CPPUNIT_TEST_SUITE(ComponentConnectorTest);

+ CPPUNIT_TEST(testConnect);

+ CPPUNIT_TEST(testConnect_FirstAddressHostFails);

+ CPPUNIT_TEST(testConnect_NoHosts);

+ CPPUNIT_TEST(testConnect_TimeoutDuringResolve);

+ CPPUNIT_TEST(testConnect_TimeoutDuringConnect);

+ CPPUNIT_TEST(testConnect_NoTimeout);

+ CPPUNIT_TEST(testStop_Timeout);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ host1 = HostAddress("1.1.1.1");

+ host2 = HostAddress("2.2.2.2");

+ eventLoop = new DummyEventLoop();

+ resolver = new StaticDomainNameResolver(eventLoop);

+ connectionFactory = new MockConnectionFactory(eventLoop);

+ timerFactory = new DummyTimerFactory();

+ }

+

+ void tearDown() {

+ delete timerFactory;

+ delete connectionFactory;

+ delete resolver;

+ delete eventLoop;

+ }

+

+ void testConnect() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+ resolver->addAddress("foo.com", host1);

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(HostAddressPort(host1, 1234) == *(connections[0]->hostAddressPort));

+ }

+

+ void testConnect_FirstAddressHostFails() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+ resolver->addAddress("foo.com", host1);

+ resolver->addAddress("foo.com", host2);

+ connectionFactory->failingPorts.push_back(HostAddressPort(host1, 1234));

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(HostAddressPort(host2, 1234) == *(connections[0]->hostAddressPort));

+ }

+

+ void testConnect_NoHosts() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+

+ void testConnect_TimeoutDuringResolve() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+

+ testling->setTimeoutMilliseconds(10);

+ resolver->setIsResponsive(false);

+

+ testling->start();

+ eventLoop->processEvents();

+ timerFactory->setTime(10);

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ void testConnect_TimeoutDuringConnect() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+ testling->setTimeoutMilliseconds(10);

+ resolver->addAddress("foo.com", host1);

+ connectionFactory->isResponsive = false;

+

+ testling->start();

+ eventLoop->processEvents();

+ timerFactory->setTime(10);

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ void testConnect_NoTimeout() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+ testling->setTimeoutMilliseconds(10);

+ resolver->addAddress("foo.com", host1);

+

+ testling->start();

+ eventLoop->processEvents();

+ timerFactory->setTime(10);

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ }

+

+ void testStop_Timeout() {

+ ComponentConnector::ref testling(createConnector("foo.com", 1234));

+ testling->setTimeoutMilliseconds(10);

+ resolver->addAddress("foo.com", host1);

+

+ testling->start();

+ testling->stop();

+

+ eventLoop->processEvents();

+ timerFactory->setTime(10);

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(!connections[0]);

+ }

+

+ private:

+ ComponentConnector::ref createConnector(const std::string& hostname, int port) {

+ ComponentConnector::ref connector = ComponentConnector::create(hostname, port, resolver, connectionFactory, timerFactory);

+ connector->onConnectFinished.connect(boost::bind(&ComponentConnectorTest::handleConnectorFinished, this, _1));

+ return connector;

+ }

+

+ void handleConnectorFinished(boost::shared_ptr<Connection> connection) {

+ boost::shared_ptr<MockConnection> c(boost::dynamic_pointer_cast<MockConnection>(connection));

+ if (connection) {

+ assert(c);

+ }

+ connections.push_back(c);

+ }

+

+ struct MockConnection : public Connection {

+ public:

+ MockConnection(const std::vector<HostAddressPort>& failingPorts, bool isResponsive, EventLoop* eventLoop) : eventLoop(eventLoop), failingPorts(failingPorts), isResponsive(isResponsive) {}

+

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

+ void connect(const HostAddressPort& address) {

+ hostAddressPort = address;

+ if (isResponsive) {

+ bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

+ eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), fail));

+ }

+ }

+

+ void disconnect() { assert(false); }

+ void write(const SafeByteArray&) { assert(false); }

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+ HostAddressPort getRemoteAddress() const { return HostAddressPort(); }

+

+ EventLoop* eventLoop;

+ boost::optional<HostAddressPort> hostAddressPort;

+ std::vector<HostAddressPort> failingPorts;

+ bool isResponsive;

+ };

+

+ struct MockConnectionFactory : public ConnectionFactory {

+ MockConnectionFactory(EventLoop* eventLoop) : eventLoop(eventLoop), isResponsive(true) {

+ }

+

+ boost::shared_ptr<Connection> createConnection() {

+ return boost::shared_ptr<Connection>(new MockConnection(failingPorts, isResponsive, eventLoop));

+ }

+

+ EventLoop* eventLoop;

+ bool isResponsive;

+ std::vector<HostAddressPort> failingPorts;

+ };

+

+ private:

+ HostAddress host1;

+ HostAddress host2;

+ DummyEventLoop* eventLoop;

+ StaticDomainNameResolver* resolver;

+ MockConnectionFactory* connectionFactory;

+ DummyTimerFactory* timerFactory;

+ std::vector< boost::shared_ptr<MockConnection> > connections;

+ CPPUNIT_TEST_SUITE(ComponentHandshakeGeneratorTest);

+ CPPUNIT_TEST(testGetHandshake);

+ CPPUNIT_TEST(testGetHandshake_SpecialChars);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ }

+

+ void testGetHandshake() {

+ std::string result = ComponentHandshakeGenerator::getHandshake("myid", "mysecret", crypto.get());

+ CPPUNIT_ASSERT_EQUAL(std::string("4011cd31f9b99ac089a0cd7ce297da7323fa2525"), result);

+ }

+

+ void testGetHandshake_SpecialChars() {

+ std::string result = ComponentHandshakeGenerator::getHandshake("&<", ">'\"", crypto.get());

+ CPPUNIT_ASSERT_EQUAL(std::string("33631b3e0aaeb2a11c4994c917919324028873fe"), result);

+ }

+

+ private:

+ boost::shared_ptr<CryptoProvider> crypto;

+ CPPUNIT_TEST_SUITE(ComponentSessionTest);

+ CPPUNIT_TEST(testStart);

+ CPPUNIT_TEST(testStart_Error);

+ CPPUNIT_TEST(testStart_Unauthorized);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ server = boost::make_shared<MockSessionStream>();

+ sessionFinishedReceived = false;

+ crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ }

+

+ void testStart() {

+ boost::shared_ptr<ComponentSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->receiveHandshake();

+ server->sendHandshakeResponse();

+

+ CPPUNIT_ASSERT(server->whitespacePingEnabled);

+

+ session->finish();

+ CPPUNIT_ASSERT(!server->whitespacePingEnabled);

+

+ }

+

+ void testStart_Error() {

+ boost::shared_ptr<ComponentSession> session(createSession());

+ session->start();

+ server->breakConnection();

+

+ CPPUNIT_ASSERT_EQUAL(ComponentSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ void testStart_Unauthorized() {

+ boost::shared_ptr<ComponentSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->receiveHandshake();

+ server->sendHandshakeError();

+

+ CPPUNIT_ASSERT_EQUAL(ComponentSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ private:

+ boost::shared_ptr<ComponentSession> createSession() {

+ boost::shared_ptr<ComponentSession> session = ComponentSession::create(JID("service.foo.com"), "servicesecret", server, crypto.get());

+ session->onFinished.connect(boost::bind(&ComponentSessionTest::handleSessionFinished, this, _1));

+ return session;

+ }

+

+ void handleSessionFinished(boost::shared_ptr<Error> error) {

+ sessionFinishedReceived = true;

+ sessionFinishedError = error;

+ }

+

+ class MockSessionStream : public SessionStream {

+ public:

+ struct Event {

+ Event(boost::shared_ptr<ToplevelElement> element) : element(element), footer(false) {}

+ Event(const ProtocolHeader& header) : header(header), footer(false) {}

+ Event() : footer(true) {}

+

+ boost::shared_ptr<ToplevelElement> element;

+ boost::optional<ProtocolHeader> header;

+ bool footer;

+ };

+

+ MockSessionStream() : available(true), whitespacePingEnabled(false), resetCount(0) {

+ }

+

+ virtual void close() {

+ onClosed(boost::shared_ptr<Error>());

+ }

+

+ virtual bool isOpen() {

+ return available;

+ }

+

+ virtual void writeHeader(const ProtocolHeader& header) {

+ receivedEvents.push_back(Event(header));

+ }

+

+ virtual void writeFooter() {

+ receivedEvents.push_back(Event());

+ }

+

+ virtual void writeElement(boost::shared_ptr<ToplevelElement> element) {

+ receivedEvents.push_back(Event(element));

+ }

+

+ virtual void writeData(const std::string&) {

+ }

+

+ virtual bool supportsTLSEncryption() {

+ return false;

+ }

+

+ virtual void addTLSEncryption() {

+ assert(false);

+ }

+

+ virtual bool isTLSEncrypted() {

+ return false;

+ }

+

+ virtual ByteArray getTLSFinishMessage() const {

+ return ByteArray();

+ }

+

+ virtual Certificate::ref getPeerCertificate() const {

+ return Certificate::ref();

+ }

+

+ virtual std::vector<Certificate::ref> getPeerCertificateChain() const {

+ return std::vector<Certificate::ref>();

+ }

+

+ virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const {

+ return boost::shared_ptr<CertificateVerificationError>();

+ }

+

+ virtual bool supportsZLibCompression() {

+ return true;

+ }

+

+ virtual void addZLibCompression() {

+ assert(false);

+ }

+

+ virtual void setWhitespacePingEnabled(bool enabled) {

+ whitespacePingEnabled = enabled;

+ }

+

+ virtual void resetXMPPParser() {

+ resetCount++;

+ }

+

+ void breakConnection() {

+ onClosed(boost::make_shared<SessionStream::SessionStreamError>(SessionStream::SessionStreamError::ConnectionReadError));

+ }

+

+ void sendStreamStart() {

+ ProtocolHeader header;

+ header.setFrom("service.foo.com");

+ return onStreamStartReceived(header);

+ }

+

+ void sendHandshakeResponse() {

+ onElementReceived(ComponentHandshake::ref(new ComponentHandshake()));

+ }

+

+ void sendHandshakeError() {

+ // FIXME: This isn't the correct element

+ onElementReceived(AuthFailure::ref(new AuthFailure()));

+ }

+

+ void receiveStreamStart() {

+ Event event = popEvent();

+ CPPUNIT_ASSERT(event.header);

+ }

+

+ void receiveHandshake() {

+ Event event = popEvent();

+ CPPUNIT_ASSERT(event.element);

+ ComponentHandshake::ref handshake(boost::dynamic_pointer_cast<ComponentHandshake>(event.element));

+ CPPUNIT_ASSERT(handshake);

+ CPPUNIT_ASSERT_EQUAL(std::string("4c4f8a41141722c8bbfbdd92d827f7b2fc0a542b"), handshake->getData());

+ }

+

+ Event popEvent() {

+ CPPUNIT_ASSERT(!receivedEvents.empty());

+ Event event = receivedEvents.front();

+ receivedEvents.pop_front();

+ return event;

+ }

+

+ bool available;

+ bool whitespacePingEnabled;

+ std::string bindID;

+ int resetCount;

+ std::deque<Event> receivedEvents;

+ };

+

+ boost::shared_ptr<MockSessionStream> server;

+ bool sessionFinishedReceived;

+ boost::shared_ptr<Error> sessionFinishedError;

+ boost::shared_ptr<CryptoProvider> crypto;