2008-02-11 Tatsuhiro Tsujikawa <tujikawa at rednoah dot com>

	Added test 'testDoReceivedAction' for DHTQueryMessage 
subclasses.
	* test/DHTPingMessageTest.cc
	* test/DHTGetPeersMessageTest.cc
	* test/DHTFindNodeMessageTest.cc
	* test/DHTAnnouncePeerMessageTest.cc
	* test/MockDHTMessage.h
	* test/MockDHTMessageFactory.h
	* test/MockDHTMessageDispatcher.h: New class.

ChangeLog

@@ -1,3 +1,14 @@
+2008-02-11  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
+
+	Added test 'testDoReceivedAction' for DHTQueryMessage subclasses.
+	* test/DHTPingMessageTest.cc
+	* test/DHTGetPeersMessageTest.cc
+	* test/DHTFindNodeMessageTest.cc
+	* test/DHTAnnouncePeerMessageTest.cc
+	* test/MockDHTMessage.h
+	* test/MockDHTMessageFactory.h
+	* test/MockDHTMessageDispatcher.h: New class.
+	
 2008-02-11  Tatsuhiro Tsujikawa  <tujikawa at rednoah dot com>
 
 	Added DHTMessageDispatcherImpl. Now DHTMessageDispatcher is pure

test/DHTAnnouncePeerMessageTest.cc

@@ -6,6 +6,10 @@
 #include "Data.h"
 #include "Exception.h"
 #include "Util.h"
+#include "MockDHTMessageFactory.h"
+#include "MockDHTMessageDispatcher.h"
+#include "MockDHTMessage.h"
+#include "DHTPeerAnnounceStorage.h"
 #include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
@@ -14,6 +18,7 @@ class DHTAnnouncePeerMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTAnnouncePeerMessageTest);
   CPPUNIT_TEST(testGetBencodedMessage);
+  CPPUNIT_TEST(testDoReceivedAction);
   CPPUNIT_TEST_SUITE_END();
 public:
   void setUp() {}
@@ -21,6 +26,16 @@ public:
   void tearDown() {}
 
   void testGetBencodedMessage();
+  void testDoReceivedAction();
+
+  class MockDHTMessageFactory2:public MockDHTMessageFactory {
+    virtual SharedHandle<DHTMessage>
+    createAnnouncePeerReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+				   const std::string& transactionID)
+    {
+      return new MockDHTMessage(_localNode, remoteNode, "announce_peer", transactionID);
+    }
+  };
 };
 
 
@@ -63,4 +78,48 @@ void DHTAnnouncePeerMessageTest::testGetBencodedMessage()
 		       Util::urlencode(msgbody));
 }
 
+void DHTAnnouncePeerMessageTest::testDoReceivedAction()
+{
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
+  remoteNode->setIPAddress("192.168.0.1");
+  remoteNode->setPort(6881);
+
+  char tid[DHT_TRANSACTION_ID_LENGTH];
+  DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+
+  unsigned char infoHash[DHT_ID_LENGTH];
+  DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH);
+
+  std::string token = "token";
+  uint16_t port = 6882;
+
+  DHTPeerAnnounceStorage peerAnnounceStorage;
+  MockDHTMessageFactory2 factory;
+  factory.setLocalNode(localNode);
+  MockDHTMessageDispatcher dispatcher;
+
+  DHTAnnouncePeerMessage msg(localNode, remoteNode, infoHash, port, token, transactionID);
+  msg.setPeerAnnounceStorage(&peerAnnounceStorage);
+  msg.setMessageFactory(&factory);
+  msg.setMessageDispatcher(&dispatcher);
+
+  msg.doReceivedAction();
+
+  CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size());
+  SharedHandle<MockDHTMessage> m = dispatcher._messageQueue[0]._message;
+  CPPUNIT_ASSERT(localNode == m->getLocalNode());
+  CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
+  CPPUNIT_ASSERT_EQUAL(std::string("announce_peer"), m->getMessageType());
+  CPPUNIT_ASSERT_EQUAL(transactionID, m->getTransactionID());
+  std::deque<SharedHandle<Peer> > peers = peerAnnounceStorage.getPeers(infoHash);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, peers.size());
+  {
+    SharedHandle<Peer> peer = peers[0];
+    CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.1"), peer->ipaddr);
+    CPPUNIT_ASSERT_EQUAL((uint16_t)6882, peer->port);
+  }
+}
+
 } // namespace aria2

test/DHTFindNodeMessageTest.cc

@@ -6,6 +6,10 @@
 #include "Data.h"
 #include "Exception.h"
 #include "Util.h"
+#include "MockDHTMessageFactory.h"
+#include "MockDHTMessage.h"
+#include "MockDHTMessageDispatcher.h"
+#include "DHTRoutingTable.h"
 #include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
@@ -14,6 +18,7 @@ class DHTFindNodeMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTFindNodeMessageTest);
   CPPUNIT_TEST(testGetBencodedMessage);
+  CPPUNIT_TEST(testDoReceivedAction);
   CPPUNIT_TEST_SUITE_END();
 public:
   void setUp() {}
@@ -21,6 +26,21 @@ public:
   void tearDown() {}
 
   void testGetBencodedMessage();
+  void testDoReceivedAction();
+
+  class MockDHTMessageFactory2:public MockDHTMessageFactory {
+  public:
+    virtual SharedHandle<DHTMessage>
+    createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			       const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			       const std::string& transactionID)
+    {
+      SharedHandle<MockDHTMessage> m =
+	new MockDHTMessage(_localNode, remoteNode, "find_node", transactionID);
+      m->_nodes = closestKNodes;
+      return m;
+    }
+  };
 };
 
 
@@ -56,4 +76,37 @@ void DHTFindNodeMessageTest::testGetBencodedMessage()
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
+void DHTFindNodeMessageTest::testDoReceivedAction()
+{
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
+
+  char tid[DHT_TRANSACTION_ID_LENGTH];
+  DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+
+  SharedHandle<DHTNode> targetNode = new DHTNode();
+
+  MockDHTMessageDispatcher dispatcher;
+  MockDHTMessageFactory2 factory;
+  factory.setLocalNode(localNode);
+  DHTRoutingTable routingTable(localNode);
+  routingTable.addNode(targetNode);
+
+  DHTFindNodeMessage msg(localNode, remoteNode, targetNode->getID(), transactionID);
+  msg.setMessageDispatcher(&dispatcher);
+  msg.setMessageFactory(&factory);
+  msg.setRoutingTable(&routingTable);
+
+  msg.doReceivedAction();
+
+  CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size());
+  SharedHandle<MockDHTMessage> m = dispatcher._messageQueue[0]._message;
+  CPPUNIT_ASSERT(localNode == m->getLocalNode());
+  CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
+  CPPUNIT_ASSERT_EQUAL(std::string("find_node"), m->getMessageType());
+  CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, m->_nodes.size());
+}
+
 } // namespace aria2

test/DHTGetPeersMessageTest.cc

@@ -6,6 +6,12 @@
 #include "Data.h"
 #include "Exception.h"
 #include "Util.h"
+#include "MockDHTMessageFactory.h"
+#include "MockDHTMessage.h"
+#include "MockDHTMessageDispatcher.h"
+#include "DHTTokenTracker.h"
+#include "DHTPeerAnnounceStorage.h"
+#include "DHTRoutingTable.h"
 #include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
@@ -14,6 +20,7 @@ class DHTGetPeersMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTGetPeersMessageTest);
   CPPUNIT_TEST(testGetBencodedMessage);
+  CPPUNIT_TEST(testDoReceivedAction);
   CPPUNIT_TEST_SUITE_END();
 public:
   void setUp() {}
@@ -21,6 +28,37 @@ public:
   void tearDown() {}
 
   void testGetBencodedMessage();
+  void testDoReceivedAction();
+
+  class MockDHTMessageFactory2:public MockDHTMessageFactory {
+  public:
+    virtual SharedHandle<DHTMessage>
+    createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			       const std::deque<SharedHandle<Peer> >& peers,
+			       const std::string& token,
+			       const std::string& transactionID)
+    {
+      SharedHandle<MockDHTMessage> m =
+	new MockDHTMessage(_localNode, remoteNode, "get_peers", transactionID);
+      m->_peers = peers;
+      m->_token = token;
+      return m;
+    }
+
+    virtual SharedHandle<DHTMessage>
+    createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			       const std::deque<SharedHandle<DHTNode> >& closestKNodes,
+			       const std::string& token,
+			       const std::string& transactionID)
+    {
+      SharedHandle<MockDHTMessage> m =
+	new MockDHTMessage(_localNode, remoteNode, "get_peers", transactionID);
+      m->_nodes = closestKNodes;
+      m->_token = token;
+      return m;
+    }
+
+  };
 };
 
 
@@ -58,4 +96,83 @@ void DHTGetPeersMessageTest::testGetBencodedMessage()
 		       Util::urlencode(msgbody));
 }
 
+void DHTGetPeersMessageTest::testDoReceivedAction()
+{
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
+  remoteNode->setIPAddress("192.168.0.1");
+  remoteNode->setPort(6881);
+
+  char tid[DHT_TRANSACTION_ID_LENGTH];
+  DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+
+  unsigned char infoHash[DHT_ID_LENGTH];
+  DHTUtil::generateRandomData(infoHash, DHT_ID_LENGTH);
+
+  DHTTokenTracker tokenTracker;
+  MockDHTMessageDispatcher dispatcher;
+  MockDHTMessageFactory2 factory;
+  factory.setLocalNode(localNode);
+
+  DHTGetPeersMessage msg(localNode, remoteNode, infoHash, transactionID);
+  msg.setTokenTracker(&tokenTracker);
+  msg.setMessageDispatcher(&dispatcher);
+  msg.setMessageFactory(&factory);
+  {
+    // localhost has peer contact information for that infohash.
+    DHTPeerAnnounceStorage peerAnnounceStorage;
+    peerAnnounceStorage.addPeerAnnounce(infoHash, "192.168.0.100", 6888);
+    peerAnnounceStorage.addPeerAnnounce(infoHash, "192.168.0.101", 6889);
+
+    msg.setPeerAnnounceStorage(&peerAnnounceStorage);
+  
+    msg.doReceivedAction();
+
+    CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size());
+    SharedHandle<MockDHTMessage> m = dispatcher._messageQueue[0]._message;
+    CPPUNIT_ASSERT(localNode == m->getLocalNode());
+    CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
+    CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType());
+    CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID());
+    CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->_token);
+    CPPUNIT_ASSERT_EQUAL((size_t)0, m->_nodes.size());
+    CPPUNIT_ASSERT_EQUAL((size_t)2, m->_peers.size());
+    {
+      SharedHandle<Peer> peer = m->_peers[0];
+      CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.100"), peer->ipaddr);
+      CPPUNIT_ASSERT_EQUAL((uint16_t)6888, peer->port);
+    }
+    {
+      SharedHandle<Peer> peer = m->_peers[1];
+      CPPUNIT_ASSERT_EQUAL(std::string("192.168.0.101"), peer->ipaddr);
+      CPPUNIT_ASSERT_EQUAL((uint16_t)6889, peer->port);
+    }
+  }
+  dispatcher._messageQueue.clear();
+  {
+    // localhost doesn't have peer contact information for that infohash.
+    DHTPeerAnnounceStorage peerAnnounceStorage;
+    DHTRoutingTable routingTable(localNode);
+    SharedHandle<DHTNode> returnNode1 = new DHTNode();
+    routingTable.addNode(returnNode1);
+
+    msg.setPeerAnnounceStorage(&peerAnnounceStorage);
+    msg.setRoutingTable(&routingTable);
+
+    msg.doReceivedAction();
+
+    CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size());
+    SharedHandle<MockDHTMessage> m = dispatcher._messageQueue[0]._message;
+    CPPUNIT_ASSERT(localNode == m->getLocalNode());
+    CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
+    CPPUNIT_ASSERT_EQUAL(std::string("get_peers"), m->getMessageType());
+    CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID());
+    CPPUNIT_ASSERT_EQUAL(tokenTracker.generateToken(infoHash, remoteNode->getIPAddress(), remoteNode->getPort()), m->_token);
+    CPPUNIT_ASSERT_EQUAL((size_t)1, m->_nodes.size());
+    CPPUNIT_ASSERT(returnNode1 == m->_nodes[0]);
+    CPPUNIT_ASSERT_EQUAL((size_t)0, m->_peers.size());
+  }
+}
+
 } // namespace aria2

test/DHTPingMessageTest.cc

@@ -6,6 +6,9 @@
 #include "Data.h"
 #include "Exception.h"
 #include "Util.h"
+#include "MockDHTMessageFactory.h"
+#include "MockDHTMessageDispatcher.h"
+#include "MockDHTMessage.h"
 #include <cppunit/extensions/HelperMacros.h>
 
 namespace aria2 {
@@ -14,6 +17,7 @@ class DHTPingMessageTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(DHTPingMessageTest);
   CPPUNIT_TEST(testGetBencodedMessage);
+  CPPUNIT_TEST(testDoReceivedAction);
   CPPUNIT_TEST_SUITE_END();
 public:
   void setUp() {}
@@ -21,6 +25,19 @@ public:
   void tearDown() {}
 
   void testGetBencodedMessage();
+  void testDoReceivedAction();
+
+  class MockDHTMessageFactory2:public MockDHTMessageFactory {
+  public:
+    virtual SharedHandle<DHTMessage>
+    createPingReplyMessage(const SharedHandle<DHTNode>& remoteNode,
+			   const unsigned char* remoteNodeID,
+			   const std::string& transactionID)
+    {
+      return new MockDHTMessage(_localNode, remoteNode, "ping_reply",
+				transactionID);
+    }
+  };
 };
 
 
@@ -53,4 +70,31 @@ void DHTPingMessageTest::testGetBencodedMessage()
   CPPUNIT_ASSERT_EQUAL(v.getBencodedData(), msgbody);
 }
 
+void DHTPingMessageTest::testDoReceivedAction()
+{
+  SharedHandle<DHTNode> localNode = new DHTNode();
+  SharedHandle<DHTNode> remoteNode = new DHTNode();
+
+  char tid[DHT_TRANSACTION_ID_LENGTH];
+  DHTUtil::generateRandomData(tid, DHT_TRANSACTION_ID_LENGTH);
+  std::string transactionID(&tid[0], &tid[DHT_TRANSACTION_ID_LENGTH]);
+
+  MockDHTMessageDispatcher dispatcher;
+  MockDHTMessageFactory2 factory;
+  factory.setLocalNode(localNode);
+
+  DHTPingMessage msg(localNode, remoteNode, transactionID);
+  msg.setMessageDispatcher(&dispatcher);
+  msg.setMessageFactory(&factory);
+
+  msg.doReceivedAction();
+
+  CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher._messageQueue.size());
+  SharedHandle<MockDHTMessage> m = dispatcher._messageQueue[0]._message;
+  CPPUNIT_ASSERT(localNode == m->getLocalNode());
+  CPPUNIT_ASSERT(remoteNode == m->getRemoteNode());
+  CPPUNIT_ASSERT_EQUAL(std::string("ping_reply"), m->getMessageType());
+  CPPUNIT_ASSERT_EQUAL(msg.getTransactionID(), m->getTransactionID());
+}
+
 } // namespace aria2

test/MockDHTMessage.h

@@ -2,19 +2,29 @@
 #define _D_MOCK_DHT_MESSAGE_H_
 
 #include "DHTMessage.h"
+#include "DHTNode.h"
+#include "Peer.h"
+#include <deque>
 
 namespace aria2 {
 
 class MockDHTMessage:public DHTMessage {
-private:
+public:
   bool _isReply;
 
   std::string _messageType;
+
+  std::deque<SharedHandle<DHTNode> > _nodes;
+
+  std::deque<SharedHandle<Peer> > _peers;
+
+  std::string _token;
 public:
   MockDHTMessage(const SharedHandle<DHTNode>& localNode,
 		 const SharedHandle<DHTNode>& remoteNode,
+		 const std::string& messageType = "mock",
 		 const std::string& transactionID = ""):
-    DHTMessage(localNode, remoteNode, transactionID), _isReply(false), _messageType("mock") {}
+    DHTMessage(localNode, remoteNode, transactionID), _isReply(false), _messageType(messageType) {}
   
   virtual ~MockDHTMessage() {}
 

test/MockDHTMessageDispatcher.h

@@ -0,0 +1,58 @@
+#ifndef _D_MOCK_DHT_MESSAGE_DISPATCHER_H_
+#define _D_MOCK_DHT_MESSAGE_DISPATCHER_H_
+
+#include "DHTMessageDispatcher.h"
+#include "DHTMessageCallback.h"
+#include "DHTMessage.h"
+#include "DHTConstants.h"
+
+namespace aria2 {
+
+class MockDHTMessageDispatcher:public DHTMessageDispatcher {
+public:
+  class Entry {
+  public:
+    SharedHandle<DHTMessage> _message;
+    time_t _timeout;
+    SharedHandle<DHTMessageCallback> _callback;
+
+    Entry(const SharedHandle<DHTMessage>& message, time_t timeout,
+	  const SharedHandle<DHTMessageCallback>& callback):
+      _message(message),
+      _timeout(timeout),
+      _callback(callback) {}
+  };
+
+  std::deque<Entry> _messageQueue;
+
+public:
+  MockDHTMessageDispatcher() {}
+
+  virtual ~MockDHTMessageDispatcher() {}
+
+  virtual void
+  addMessageToQueue(const SharedHandle<DHTMessage>& message,
+		    time_t timeout,
+		    const SharedHandle<DHTMessageCallback>& callback = 0)
+  {
+    _messageQueue.push_back(Entry(message, timeout, callback));
+  }
+
+  virtual void
+  addMessageToQueue(const SharedHandle<DHTMessage>& message,
+		    const SharedHandle<DHTMessageCallback>& callback = 0)
+  {
+    _messageQueue.push_back(Entry(message, DHT_MESSAGE_TIMEOUT, callback));
+  }
+  
+  virtual void sendMessages() {}
+
+  virtual size_t countMessageInQueue() const
+  {
+    return _messageQueue.size();
+  }
+};
+
+} // namespace aria2
+
+#endif // _D_MOCK_DHT_MESSAGE_DISPATCHER_H_

test/MockDHTMessageFactory.h

@@ -10,7 +10,7 @@
 namespace aria2 {
 
 class MockDHTMessageFactory:public DHTMessageFactory {
-private:
+protected:
   SharedHandle<DHTNode> _localNode;
 public:
   MockDHTMessageFactory() {}
@@ -78,17 +78,18 @@ public:
   virtual SharedHandle<DHTMessage>
   createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			     const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-			     const std::string& transactionID,
-			     const std::string& token = "")
+			     const std::string& token,
+			     const std::string& transactionID)
   {
     return 0;
   }
 
+
   virtual SharedHandle<DHTMessage>
   createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
 			     const std::deque<SharedHandle<Peer> >& peers,
-			     const std::string& transactionID,
-			     const std::string& token = "")
+			     const std::string& token,
+			     const std::string& transactionID)
   {
     return 0;
   }