3 files changed, 80 insertions, 27 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
@@ -21,13 +21,18 @@
 #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);
@@ -64,11 +69,16 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			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;
 		}
 
@@ -91,10 +101,13 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			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());
 		}
 
@@ -125,15 +138,20 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			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. */
 
@@ -142,6 +160,7 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			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();
@@ -167,6 +186,7 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 
 			rid++;
 			testling->restartStream();
+			eventLoop->processEvents();
 			readResponse("<body/>", connectionFactory->connections[0]);
 
 			rid++;
@@ -199,6 +219,7 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 
 			rid++;
 			testling->write(createSafeByteArray("<bleh/>"));
+			eventLoop->processEvents();
 			CPPUNIT_ASSERT(c0->pending);
 			CPPUNIT_ASSERT(c1->pending);
 			CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size()); /* data */
@@ -214,6 +235,7 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 
 		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);
 
@@ -258,15 +280,18 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 			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];
@@ -279,12 +304,17 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 	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;
 		}
 
@@ -406,6 +436,8 @@ class BOSHConnectionPoolTest : public CppUnit::TestFixture {
 		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;
diff --git a/Swiften/Network/UnitTest/BOSHConnectionTest.cpp b/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
index 8062bea..e0dc0bf 100644
--- a/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
+++ b/Swiften/Network/UnitTest/BOSHConnectionTest.cpp
@@ -20,6 +20,8 @@
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/BOSHConnection.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>
 
@@ -43,6 +45,8 @@ class BOSHConnectionTest : public CppUnit::TestFixture {
 		void setUp() {
 			eventLoop = new DummyEventLoop();
 			connectionFactory = new MockConnectionFactory(eventLoop);
+			resolver = new StaticDomainNameResolver(eventLoop);
+			timerFactory = new DummyTimerFactory();
 			connectFinished = false;
 			disconnected = false;
 			disconnectedError = false;
@@ -52,7 +56,9 @@ class BOSHConnectionTest : public CppUnit::TestFixture {
 		void tearDown() {
 			eventLoop->processEvents();
 			delete connectionFactory;
-			delete eventLoop;	
+			delete resolver;
+			delete timerFactory;
+			delete eventLoop;
 		}
 
 		void testHeader() {
@@ -185,7 +191,9 @@ class BOSHConnectionTest : public CppUnit::TestFixture {
 	private:
 
 		BOSHConnection::ref createTestling() {
-			BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "http-bind"), connectionFactory, &parserFactory, static_cast<TLSContextFactory*>(NULL));
+			resolver->addAddress("wonderland.lit", HostAddress("127.0.0.1"));
+			Connector::ref connector = Connector::create("wonderland.lit", resolver, connectionFactory, timerFactory, 5280);
+			BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "http-bind"), connector, &parserFactory);
 			c->onConnectFinished.connect(boost::bind(&BOSHConnectionTest::handleConnectFinished, this, _1));
 			c->onDisconnected.connect(boost::bind(&BOSHConnectionTest::handleDisconnected, this, _1));
 			c->onXMPPDataRead.connect(boost::bind(&BOSHConnectionTest::handleDataRead, this, _1));
@@ -284,6 +292,8 @@ class BOSHConnectionTest : public CppUnit::TestFixture {
 		bool disconnectedError;
 		ByteArray dataRead;
 		PlatformXMLParserFactory parserFactory;
+		StaticDomainNameResolver* resolver;
+		TimerFactory* timerFactory;
 		std::string sid;	
 
 };
diff --git a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
index c0252d4..347a145 100644
--- a/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
+++ b/Swiften/Network/UnitTest/HTTPConnectProxiedConnectionTest.cpp
@@ -18,6 +18,8 @@
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/HTTPConnectProxiedConnection.h>
 #include <Swiften/Network/HostAddressPort.h>
+#include <Swiften/Network/StaticDomainNameResolver.h>
+#include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 
 using namespace Swift;
@@ -37,44 +39,55 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 	public:
 		void setUp() {
-			proxyHost = HostAddressPort(HostAddress("1.1.1.1"), 1234);
+			proxyHost = "doo.bah";
+			proxyPort = 1234;
+			proxyHostAddress = HostAddressPort(HostAddress("1.1.1.1"), proxyPort);
 			host = HostAddressPort(HostAddress("2.2.2.2"), 2345);
 			eventLoop = new DummyEventLoop();
+			resolver = new StaticDomainNameResolver(eventLoop);
+			resolver->addAddress(proxyHost, proxyHostAddress.getAddress());
+			timerFactory = new DummyTimerFactory();
 			connectionFactory = new MockConnectionFactory(eventLoop);
 			connectFinished = false;
 			disconnected = false;
 		}
 
 		void tearDown() {
+			delete timerFactory;
 			delete connectionFactory;
+			delete resolver;
 			delete eventLoop;
 		}
 
+		void connect(HTTPConnectProxiedConnection::ref connection, const HostAddressPort& to) {
+			connection->connect(to);
+			eventLoop->processEvents();
+			eventLoop->processEvents();
+			eventLoop->processEvents();
+		}
+
 		void testConnect_CreatesConnectionToProxy() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
 
-			testling->connect(host);
-			eventLoop->processEvents();
+			connect(testling, host);
 
 			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connectionFactory->connections.size()));
 			CPPUNIT_ASSERT(connectionFactory->connections[0]->hostAddressPort);
-			CPPUNIT_ASSERT(proxyHost == *connectionFactory->connections[0]->hostAddressPort);
+			CPPUNIT_ASSERT(proxyHostAddress == *connectionFactory->connections[0]->hostAddressPort);
 			CPPUNIT_ASSERT(!connectFinished);
 		}
 
 		void testConnect_SendsConnectRequest() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
 
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 
 			CPPUNIT_ASSERT_EQUAL(createByteArray("CONNECT 2.2.2.2:2345 HTTP/1.1\r\n\r\n"), connectionFactory->connections[0]->dataWritten);
 		}
 
 		void testConnect_ReceiveConnectResponse() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
@@ -86,8 +99,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testConnect_ReceiveMalformedConnectResponse() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("FLOOP"));
 			eventLoop->processEvents();
@@ -99,8 +111,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testConnect_ReceiveErrorConnectResponse() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 401 Unauthorized\r\n\r\n"));
 			eventLoop->processEvents();
@@ -112,8 +123,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testConnect_ReceiveDataAfterConnect() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 
@@ -124,8 +134,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testWrite_AfterConnect() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 			connectionFactory->connections[0]->dataWritten.clear();
@@ -137,8 +146,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testDisconnect_AfterConnectRequest() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 
 			testling->disconnect();
 
@@ -149,8 +157,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 		void testDisconnect_AfterConnect() {
 			HTTPConnectProxiedConnection::ref testling(createTestling());
-			testling->connect(HostAddressPort(HostAddress("2.2.2.2"), 2345));
-			eventLoop->processEvents();
+			connect(testling, HostAddressPort(HostAddress("2.2.2.2"), 2345));
 			connectionFactory->connections[0]->onDataRead(createSafeByteArrayRef("HTTP/1.0 200 Connection established\r\n\r\n"));
 			eventLoop->processEvents();
 
@@ -163,7 +170,7 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 
 	private:
 		HTTPConnectProxiedConnection::ref createTestling() {
-			boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(connectionFactory, proxyHost, "", "");
+			boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(resolver, connectionFactory, timerFactory, eventLoop, proxyHost, proxyPort, "", "");
 			c->onConnectFinished.connect(boost::bind(&HTTPConnectProxiedConnectionTest::handleConnectFinished, this, _1));
 			c->onDisconnected.connect(boost::bind(&HTTPConnectProxiedConnectionTest::handleDisconnected, this, _1));
 			c->onDataRead.connect(boost::bind(&HTTPConnectProxiedConnectionTest::handleDataRead, this, _1));
@@ -231,10 +238,14 @@ class HTTPConnectProxiedConnectionTest : public CppUnit::TestFixture {
 		};
 
 	private:
-		HostAddressPort proxyHost;
+		std::string proxyHost;
+		HostAddressPort proxyHostAddress;
+		int proxyPort;
 		HostAddressPort host;
 		DummyEventLoop* eventLoop;
+		StaticDomainNameResolver* resolver;
 		MockConnectionFactory* connectionFactory;
+		TimerFactory* timerFactory;
 		std::vector< boost::shared_ptr<MockConnection> > connections;
 		bool connectFinished;
 		bool connectFinishedWithError;