示例#1
0
 function __construct()
 {
     parent::__construct('Kademlia HTTP Test');
     return;
     #############################
     $this->node = KademliaTestFactory::constructNode(['protocols' => [Kademlia\Http::protocol_id => ['protocol' => 'http', 'host' => '10.0.0.1', 'port' => 8080, 'path' => '/kad/kademlia']]]);
 }
示例#2
0
 public function testAddingInvalidNodeIdDoesNothing()
 {
     $settings = $this->settings;
     $bucket = new Kademlia\Bucket($settings);
     $first_node = KademliaTestFactory::constructNode();
     $bucket->addNode($first_node);
     $invalid_node = KademliaTestFactory::constructNode(['id' => 'foobar']);
     $bucket->addNode($invalid_node);
     $this->assertEqual($bucket->positionOfNodeId($first_node), 0);
     $this->assertFalse($bucket->positionOfNodeId($invalid_node));
 }
示例#3
0
 public function testDistance()
 {
     $data_a = ['id' => str_repeat('FF', N / 8)];
     $node_a = KademliaTestFactory::constructNode($data_a);
     $zeros = Kademlia\Node::hexId2bin(str_repeat('00', N / 8));
     $this->assertEqual($node_a->distanceTo($node_a), $zeros);
     $data_b = ['id' => str_repeat('FF', N / 8)];
     $data_b['id'][2 * N / 8 - 1] = 'E';
     $node_b = KademliaTestFactory::constructNode($data_b);
     $one = Kademlia\Node::hexid2bin(str_repeat('0', 2 * N / 8 - 1) . '1');
     $this->assertEqual($node_a->distanceTo($node_b), $one);
 }
 public function testEmitSuccessWhenValueFound()
 {
     $settings = new Kademlia\Settings();
     $settings->own_node_id = Kademlia\Node::randomNodeId();
     $callback_done =& new TestCallback();
     $callback_success =& new TestCallback();
     $node = KademliaTestFactory::constructNode();
     $task = new Kademlia\FindValue($settings, $node->idBin(), new Kademlia\NodeList([]));
     $task->done([$callback_done, 'callme']);
     $task->done([$callback_success, 'callme']);
     $task->perform([[['node_list' => new Kademlia\NodeList([$node]), 'values' => ['abc' => 'd']]]]);
     $callback_success->expectOnce('callme');
     $callback_done->expectOnce('callme');
 }
 public function testClosestNodes()
 {
     $zeros = str_repeat('00', N / 8);
     $node_array = [];
     for ($i = 0; $i < N / 8; $i++) {
         $id = str_repeat('00', N / 8);
         $id[2 * $i + 1] = '1';
         array_push($node_array, KademliaTestFactory::constructNode(['id' => $id]));
     }
     $expected_nearest_node_id = str_repeat('00', N / 8 - 1) . '01';
     $expected_second_nearest_node_id = str_repeat('00', N / 8 - 2) . '0100';
     shuffle($node_array);
     $node_list = new Kademlia\NodeList($node_array);
     $two_closest_nodes = $node_list->closestNodes($zeros, 2)->toArray();
     $nearest_node = $two_closest_nodes[0];
     $second_nearest_node = $two_closest_nodes[1];
     $this->assertNotEqual($nearest_node->idStr(), $second_nearest_node->idStr());
     $this->assertEqual($nearest_node->idStr(), $expected_nearest_node_id);
     $this->assertEqual($second_nearest_node->idStr(), $expected_second_nearest_node_id);
 }
示例#6
0
 public function testRawStoring()
 {
     $settings = new \Kademlia\Settings();
     $protocol = new \Kademlia\Http\Protocol($settings);
     $expire = 10;
     $sender_node = KademliaTestFactory::constructNode();
     $key_id_A = \Kademlia\Node::randomNodeId();
     $value = 'foobar';
     $protocol->createStoreResponse($sender_node, $key_id_A, $value, $expire);
     $key_id_B = \Kademlia\Node::randomNodeId();
     $protocol->createStoreResponse($sender_node, $key_id_B, $value, $expire);
     $sender_node = KademliaTestFactory::constructNode();
     $value = 'barfoo';
     $protocol->createStoreResponse($sender_node, $key_id_B, $value, $expire);
     $this->assertEqual(count($settings->value_storage), 2);
     $response = $protocol->createFindValueResponse($key_id_B, $sender_node);
     $this->assertEqual($response['values'], ['foobar', 'barfoo']);
     $response = $protocol->createFindValueResponse($key_id_A, $sender_node);
     $this->assertEqual($response['values'], ['foobar']);
 }
示例#7
0
 public function testClosestNodes()
 {
     $zeros = str_repeat('00', N / 8);
     $settings = new Kademlia\Settings();
     $settings->own_node_id = $zeros;
     $kbuckets = new Kademlia\KBuckets($settings);
     for ($i = 0; $i < N / 8; $i++) {
         $id = str_repeat('00', N / 8);
         $id[2 * $i + 1] = '1';
         $node = KademliaTestFactory::constructNode(['id' => $id]);
         $kbuckets->nodeOnline($node);
     }
     $expected_nearest_node_id = str_repeat('00', N / 8 - 1) . '01';
     $expected_second_nearest_node_id = str_repeat('00', N / 8 - 2) . '0100';
     $two_closest_nodes = $kbuckets->closestNodes($zeros, 2)->toArray();
     $nearest_node = $two_closest_nodes[0];
     $second_nearest_node = $two_closest_nodes[1];
     $this->assertNotEqual($nearest_node->idStr(), $second_nearest_node->idStr());
     $this->assertEqual($nearest_node->idStr(), $expected_nearest_node_id);
     $this->assertEqual($second_nearest_node->idStr(), $expected_second_nearest_node_id);
 }