1 files changed, 35 insertions, 3 deletions
diff --git a/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp b/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
index 1bfee10..82762c5 100644
--- a/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
+++ b/Swiften/Network/UnitTest/BOSHConnectionPoolTest.cpp
@@ -15,25 +15,30 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <Swiften/Base/Algorithm.h>
 #include <Swiften/Network/Connection.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/BOSHConnection.h>
 #include <Swiften/Network/BOSHConnectionPool.h>
 #include <Swiften/Network/HostAddressPort.h>
+#include <Swiften/Network/StaticDomainNameResolver.h>
+#include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Parser/PlatformXMLParserFactory.h>
 
+
+
 using namespace Swift;
 
 typedef boost::shared_ptr<BOSHConnectionPool> PoolRef;
 
+
 class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 	CPPUNIT_TEST_SUITE(BOSHConnectionPoolTest);
 	CPPUNIT_TEST(testConnectionCount_OneWrite);
 	CPPUNIT_TEST(testConnectionCount_TwoWrites);
 	CPPUNIT_TEST(testConnectionCount_ThreeWrites);
 	CPPUNIT_TEST(testConnectionCount_ThreeWrites_ManualConnect);
 	CPPUNIT_TEST(testConnectionCount_ThreeWritesTwoReads);
 	CPPUNIT_TEST(testSession);
 	CPPUNIT_TEST(testWrite_Empty);
@@ -58,23 +63,28 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			eventLoop = new DummyEventLoop();
 			connectionFactory = new MockConnectionFactory(eventLoop);
 			boshURL = URL("http", to, 5280, path);
 			sessionTerminated = 0;
 			sessionStarted = 0;
 			initialRID = 2349876;
 			xmppDataRead.clear();
 			boshDataRead.clear();
 			boshDataWritten.clear();
+			resolver = new StaticDomainNameResolver(eventLoop);
+			resolver->addAddress(to, HostAddress("127.0.0.1"));
+			timerFactory = new DummyTimerFactory();
 		}
 
 		void tearDown() {
 			eventLoop->processEvents();
 			delete connectionFactory;
+			delete resolver;
+			delete timerFactory;
 			delete eventLoop;
 		}
 
 		void testConnectionCount_OneWrite() {
 			PoolRef testling = createTestling();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(0, sessionStarted);
 			readResponse(initial, connectionFactory->connections[0]);
@@ -85,22 +95,25 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			CPPUNIT_ASSERT_EQUAL(1, sessionStarted);
 		}
 
 		void testConnectionCount_TwoWrites() {
 			PoolRef testling = createTestling();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			eventLoop->processEvents();
 			readResponse(initial, connectionFactory->connections[0]);
+			eventLoop->processEvents();
 			testling->write(createSafeByteArray("<blah/>"));
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			testling->write(createSafeByteArray("<bleh/>"));
 			eventLoop->processEvents();
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 		}
 
 		void testConnectionCount_ThreeWrites() {
 			PoolRef testling = createTestling();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			eventLoop->processEvents();
 			readResponse(initial, connectionFactory->connections[0]);
 			testling->restartStream();
@@ -119,35 +132,41 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			PoolRef testling = createTestling();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			CPPUNIT_ASSERT_EQUAL(st(0), boshDataWritten.size()); /* Connection not connected yet, can't send data */
 
 			connectionFactory->connections[0]->onConnectFinished(false);
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Connection finished, stream header sent */
 
 			readResponse(initial, connectionFactory->connections[0]);
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Don't respond to initial data with a holding call */
 
 			testling->restartStream();
+			eventLoop->processEvents();
 			readResponse("<body/>", connectionFactory->connections[0]);
+			eventLoop->processEvents();
 			testling->restartStream();
+			eventLoop->processEvents();
 
 
 			testling->write(createSafeByteArray("<blah/>"));
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 			CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size()); /* New connection isn't up yet. */
 
 			connectionFactory->connections[1]->onConnectFinished(false);
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* New connection ready. */
 
 			testling->write(createSafeByteArray("<bleh/>"));
+			eventLoop->processEvents();
 			testling->write(createSafeByteArray("<bluh/>"));
 			CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* New data can't be sent, no free connections. */
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT(st(2) >= connectionFactory->connections.size());
 		}
 
 		void testConnectionCount_ThreeWritesTwoReads() {
 			boost::shared_ptr<MockConnection> c0;
 			boost::shared_ptr<MockConnection> c1;
@@ -161,18 +180,19 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 
 			rid++;
 			readResponse(initial, c0);
 			CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size());
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			CPPUNIT_ASSERT(!c0->pending);
 
 			rid++;
 			testling->restartStream();
+			eventLoop->processEvents();
 			readResponse("<body/>", connectionFactory->connections[0]);
 
 			rid++;
 			testling->write(createSafeByteArray("<blah/>"));
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size()); /* 0 was waiting for response, open and send on 1 */
 			CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size()); /* data */
 			c1 = connectionFactory->connections[1];
 			std::string fullBody = "<body rid='" + boost::lexical_cast<std::string>(rid) + "' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'><blah/></body>"; /* check empty write */
@@ -193,33 +213,35 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			readResponse("<body xmlns='http://jabber.org/protocol/httpbind'><message><splatploing><blittlebarg/></splatploing></message></body>", c1);
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT(!c1->pending);
 			CPPUNIT_ASSERT(c0->pending);
 			CPPUNIT_ASSERT_EQUAL(st(5), boshDataWritten.size()); /* empty to make room */
 			CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 
 			rid++;
 			testling->write(createSafeByteArray("<bleh/>"));
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT(c0->pending);
 			CPPUNIT_ASSERT(c1->pending);
 			CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* data */
 
 			rid++;
 			testling->write(createSafeByteArray("<bluh/>"));
 			CPPUNIT_ASSERT(c0->pending);
 			CPPUNIT_ASSERT(c1->pending);
 			CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* Don't send data, no room */
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size());
 		}
 
 		void testSession() {
 			to = "prosody.doomsong.co.uk";
+			resolver->addAddress("prosody.doomsong.co.uk", HostAddress("127.0.0.1"));
 			path = "http-bind/";
 			boshURL = URL("http", to, 5280, path);
 
 			PoolRef testling = createTestling();
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* header*/
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 
@@ -252,45 +274,53 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size());
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
 		}
 
 		void testWrite_Empty() {
 			boost::shared_ptr<MockConnection> c0;
 
 			PoolRef testling = createTestling();
-			c0 = connectionFactory->connections[0];
 			CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());
-			eventLoop->processEvents();
+			c0 = connectionFactory->connections[0];
 
 			readResponse(initial, c0);
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(1), boshDataWritten.size()); /* Shouldn't have sent anything extra */
+			eventLoop->processEvents();
 			testling->restartStream();
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(2), boshDataWritten.size());
 			readResponse("<body></body>", c0);
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(st(3), boshDataWritten.size());
 			std::string fullBody = "<body rid='" + boost::lexical_cast<std::string>(initialRID + 2) + "' sid='" + sid + "' xmlns='http://jabber.org/protocol/httpbind'></body>";
 			std::string response = boshDataWritten[2];
 			size_t bodyPosition = response.find("\r\n\r\n");
 			CPPUNIT_ASSERT_EQUAL(fullBody, response.substr(bodyPosition+4));
 
 
 		}
 
 	private:
 
 		PoolRef createTestling() {
-			PoolRef pool = boost::make_shared<BOSHConnectionPool>(boshURL, connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL), to, initialRID, URL(), "", "");
+			BOSHConnectionPool* a = new BOSHConnectionPool(boshURL, resolver, connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL), timerFactory, eventLoop, to, initialRID, URL(), SafeString(""), SafeString(""));
+			PoolRef pool(a);
+			//FIXME: Remko - why does the above work, but the below fail?
+			//PoolRef pool = boost::make_shared<BOSHConnectionPool>(boshURL, resolver, connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL), timerFactory, eventLoop, to, initialRID, URL(), SafeString(""), SafeString(""));
 			pool->onXMPPDataRead.connect(boost::bind(&BOSHConnectionPoolTest::handleXMPPDataRead, this, _1));
 			pool->onBOSHDataRead.connect(boost::bind(&BOSHConnectionPoolTest::handleBOSHDataRead, this, _1));
 			pool->onBOSHDataWritten.connect(boost::bind(&BOSHConnectionPoolTest::handleBOSHDataWritten, this, _1));
 			pool->onSessionStarted.connect(boost::bind(&BOSHConnectionPoolTest::handleSessionStarted, this));
 			pool->onSessionTerminated.connect(boost::bind(&BOSHConnectionPoolTest::handleSessionTerminated, this));
+			eventLoop->processEvents();
+			eventLoop->processEvents();
 			return pool;
 		}
 
 		std::string lastBody() {
 			std::string response = boshDataWritten[boshDataWritten.size() - 1];
 			size_t bodyPosition = response.find("\r\n\r\n");
 			return response.substr(bodyPosition+4);
 		}
 
@@ -400,18 +430,20 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 
 	private:
 		URL boshURL;
 		DummyEventLoop* eventLoop;
 		MockConnectionFactory* connectionFactory;
 		std::vector<std::string> xmppDataRead;
 		std::vector<std::string> boshDataRead;
 		std::vector<std::string> boshDataWritten;
 		PlatformXMLParserFactory parserFactory;
+		StaticDomainNameResolver* resolver;
+		TimerFactory* timerFactory;
 		std::string to;
 		std::string path;
 		std::string port;
 		std::string sid;
 		std::string initial;
 		long initialRID;
 		int sessionStarted;
 		int sessionTerminated;