pokan 0.1.0rc1

data/spec/pokan/query_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Pokan::Query do
+  before :all do
+    Pokan::Connection.redis.flushall
+    @query = Pokan::Query.new(Pokan::Peer)
+    p1 = Pokan::Peer.new
+    p1.address = p1.udp_port = '1'
+    p1.act_as_seed
+    p1.kill
+    p1.save
+    p2 = Pokan::Peer.new
+    p2.address = p2.udp_port = '2'
+    p2.act_as_seed
+    p2.save
+    p3 = Pokan::Peer.new
+    p3.address = p3.udp_port = '3'
+    p3.save
+    p4 = Pokan::Peer.new
+    p4.address = p4.udp_port = '4'
+    p4.kill
+    p4.save
+  end
+
+  context 'when getting all peers' do
+    it 'should return all alive peers' do
+      peers = @query.where(role:'peer', status:'alive').collect { |p| p.id }
+      peers.should =~ ['3:3']
+    end
+
+    it 'should return all alive seeds' do
+      peers = @query.where(role:'seed', status:'alive').collect { |p| p.id }
+      peers.should == ['2:2']
+    end
+  end
+
+  context 'when search a specific peer' do
+    it'should return a empty array if it does not exist' do
+      peers = @query.where(id:'5:5').collect! { |p| p.id }
+      peers.should == []
+    end
+
+    it 'should return the peer, if it exists' do
+      peers = @query.where(id:'4:4').collect! { |p| p.id }
+      peers.should == ['4:4']
+    end
+  end
+
+  context 'when choosing a peer' do
+    it 'should return a random seed' do
+      seeds = @query.where(role:'seed').collect! { |p| p.id }
+      id = @query.where(random:true, role:'seed')[0].id
+      seeds.include?(id).should be_true
+    end
+
+    it 'should return a random peer' do
+      peers = @query.where(role:'peer').collect! { |p| p.id }
+      id = @query.where(random:true, role:'peer')[0].id
+      peers.include?(id).should be_true
+    end
+
+    it 'should not return the peer with the specific id' do 
+      peers = @query.where(:not => ['1:1', '2:2', '3:3', '4:4'])
+      peers.include?('1:1').should be_false
+    end
+  end
+end

data/spec/pokan/request_handler_spec.rb

@@ -0,0 +1,253 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe Pokan::RequestHandler do
+  before :all do
+    Pokan::RequestHandler.address = 'ip'
+    Pokan::RequestHandler.port = '1111'
+    @req_handler = Pokan::RequestHandler.new nil
+
+    class Pokan::RequestHandler
+      def send_datagram a, b, c
+        nil
+      end
+    end
+    # @req_handler.stub!(:send_datagram).and_return(0)
+  end
+
+  before :each do
+    Pokan::Connection.redis.flushall
+    @req_handler.merge({
+      p1: {
+        status: { value: 'alive', timestamp: 100 },
+        role: { value: 'peer', timestamp: 100 },
+        answer: { value: 'FALSE', timestamp: 100 },
+        foo: { value: 'baz', timestamp: 101 }
+      },
+      p2: {
+        status: { value: 'alive', timestamp: 100 },
+        role: { value: 'peer', timestamp: 100 },
+        answer: { value: '+/-', timestamp: 102 },
+        foo: { value: 'baz', timestamp: 103 }
+      }
+    })
+  end
+
+  context 'when merging data' do
+    it 'should merge with a new set preserving newer values' do
+      @req_handler.merge({
+        p2: { answer: { value: 'GREAT', timestamp: 200 },
+             foo: {value: 'null', timestamp: 50 }
+        }
+      })
+      query = Pokan::Query.new(Pokan::Peer)
+      peer2 = query.where(id:'p2')[0]
+      peer2.value(:answer).should == 'GREAT'
+    end
+
+    it 'should not merge with a older set preserving newer values' do
+      @req_handler.merge({
+        p2: {
+          answer: {value: 'GREAT', timestamp: 200},
+          foo: {value: 'null', timestamp: 50}
+        }
+      })
+      query = Pokan::Query.new(Pokan::Peer)
+      peer2 = query.where(id:'p2')[0]
+      peer2.value(:foo).should == 'baz'
+    end
+
+    it 'should not merge a key of a dead peer' do
+      # need a better test for this
+      query = Pokan::Query.new(Pokan::Peer)
+      peer  = query.where(id:'p2')[0]
+      peer.kill
+      @req_handler.merge({
+        p2: { answer: { value: 'GREAT', timestamp: 200 },
+              foo: { value: 'null', timestamp: 50 }
+        }
+      })
+      peer.dead?.should be_true
+    end
+  end
+
+  context 'when checking the given keys' do
+    it 'should return all older keys of all peers' do
+      keys = { p1: { answer: 100, foo: 300 } }
+      older = @req_handler.older(keys)
+      older.should == { p1: [:foo] }
+    end
+
+    it 'should return all newer key/value/timestamps of all peers' do
+      keys = { p1: { answer: 109, foo: 91 } }
+      newer = @req_handler.newer(keys)
+      newer.should == { p1: { foo: { value: 'baz', timestamp: 101 } } }
+    end
+  end
+
+  context 'when returning its newer data' do
+    it 'should retrieve all requested keys/values/timestamps' do
+      query = Pokan::Query.new(Pokan::Peer)
+      query.where(id:'p1')[0].kill.save
+
+      request = { p1: [:status], p2: [:foo] }
+      data = @req_handler.retrieve(request)
+      data.should == {
+        p2: { foo: { value: 'baz', timestamp: 103 } }
+      }
+    end
+  end
+
+
+  context 'when generating a pull message' do
+    before :each do
+      query = Pokan::Query.new(Pokan::Peer)
+      @req_handler.merge({
+        p10: {
+          answer: { value: '+/-', timestamp: 102 },
+          foo: { value: 'baz', timestamp: 103 }
+        }
+      })
+      query.where(id:'p10')[0].store(:role, 'seed', 99317585671)
+      query.where(id:'p1')[0].store(:status, 'dead', 99317585671)
+      query.where(id:'p2')[0].store(:role, 'peer', 99317585671)
+      digest = {
+        action: 'digest',
+        origin: 'ip:1111',
+        data: { keys: { p1: { answer: 12.0, foo: 123.0 } } }
+      }.to_json
+      pull_json = @req_handler.receive_data(digest)
+      @pull = JSON.parse(pull_json)
+    end
+
+    it 'should set action as pull' do
+      @pull['action'].should == 'pull'
+    end
+
+    it 'should set the newer keys from all peers with values and timestamps' do
+      @pull['data']['newer'] == {
+        'p1' => { 'answer' => { 'value' => 'FALSE', 'timestamp' => 100.0 } },
+        'p10' => { 'answer' => { 'value' => '+/-', 'timestamp' => 102.0 },
+                 'foo' => { 'value' => 'baz', 'timestamp' => 103.0 } }
+      }
+    end
+
+    it 'should set the older keys from all peers in arrays' do
+      @pull['data']['older'] == {'older' => {'p1' => ['foo']}}
+    end
+  end
+
+  context 'when generating a push message' do
+    before :each do
+      @req_handler.merge({
+        p10: {
+          status: { value: 'alive', timestamp: 101 },
+          role: { value: 'seed', timestamp: 101 },
+          answer: { value: '+/-', timestamp: 102 },
+          foo: { value: 'baz', timestamp: 103  }
+        },
+        p1: {
+          status: { value: 'alive', timestamp: 101 },
+          role: { value: 'peer', timestamp: 101 }
+        },
+        p2: {
+          status: { value: 'dead', timestamp: 101 },
+          role: { value: 'peer', timestamp: 101 }
+        }
+      })
+      pull_message = {
+        action: 'pull', origin: 'ip:1111',
+        data: {
+          newer: { p1: { status: { value: 'FALSE', timestamp: 1000.0 } },
+                   p10: { answer: { value: '+/-', timestamp: 1020.0 } } },
+          older: { p1: [:foo], p10: [:foo]}
+        }
+      }
+      push_message = @req_handler.receive_data(JSON.generate(pull_message))
+      @push = JSON.parse(push_message)
+    end
+
+    it 'should set action as push' do
+      @push['action'].should == 'push'
+    end
+
+    it 'should set the requested keys from all peers with values and timestamps' do
+      @push['data'].should == {
+        'p1' => {'foo' => {'value' => 'baz', 'timestamp' => 101.0}},
+        'p10' => {'foo' => {'value' => 'baz', 'timestamp' => 103.0}}
+      }
+    end
+  end
+
+  context 'when interpreting messages' do
+    context 'when receiving a pull message' do
+      before :each do
+        pull_message = {
+          action: 'pull', origin: 'ip:1111',
+          data: {
+            newer: {
+              p1: { status: { value: 'dead', timestamp: 100000.0 },
+                    answer: { value: 'ZOMG!!', timestamp: 1000.0 } },
+              p10: { answer: { value: 'Hi!!', timestamp: 1000.0 } }
+            },
+            older: { p1: ['foo'] }
+          }
+        }
+        @req_handler.receive_data(pull_message.to_json)
+      end
+
+      it 'should kill the peer if the timestamp is greater than the stored' do
+        Pokan::Query.new(Pokan::Peer).where(id: 'p1')[0].value(:status).should == 'dead'
+      end
+
+      it 'should create the peer locally if it does not exist' do
+        Pokan::Query.new(Pokan::Peer).where(id: 'p10')[0].value(:role).should == 'peer'
+      end
+
+      it 'should update the keys with the newers in message' do
+        Pokan::Query.new(Pokan::Peer).where(id: 'p1')[0].value(:answer).should == 'ZOMG!!'
+      end
+
+      it 'should update the timestamp of keys with the newers in message' do
+        Pokan::Query.new(Pokan::Peer).where(id: 'p1')[0].timestamp(:answer).to_f.should == 1000.0
+      end
+    end
+
+    context 'when receiving a push message' do
+      before :each do
+        push_message = {
+          'action' => 'push',
+          'origin' => 'ip:1111',
+          'data' => {
+            'p1' => {'answer' => {'value' => 'ZOMG!!', 'timestamp' => 1000.0}},
+            'p2' => {'status' => {'value' => 'dead', 'timestamp' => 1000.0}},
+            'p10' => {'role' => {'value' => 'peer', 'timestamp' => 1000.0}}
+          }
+        }
+        @req_handler.receive_data(JSON.generate(push_message))
+      end
+
+      it 'should kill the peer if the timestamp is greater than the stored' do
+        peer = Pokan::Query.new(Pokan::Peer).where(id:'p2')[0]
+        peer.value(:status).should == 'dead'
+      end
+
+      it 'should create the peer locally if it does not exist' do
+        peer = Pokan::Query.new(Pokan::Peer).where(id:'p10')[0]
+        peer.value(:role).should == 'peer'
+      end
+
+      it 'should update the keys with the newers in message' do
+        peer = Pokan::Query.new(Pokan::Peer).where(id:'p1')[0]
+        peer.value(:answer).should == 'ZOMG!!'
+      end
+
+      it 'should update the timestamp of keys with the newers in message' do
+        peer = Pokan::Query.new(Pokan::Peer).where(id:'p1')[0]
+        peer.timestamp(:answer).to_f.should == 1000.0
+      end
+    end
+
+
+  end
+end

data/spec/pokan/server_messages_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Pokan::ServerMessages do
+  before :all do
+    class Messenger
+      include Pokan::ServerMessages
+      attr_accessor :address, :port
+    end
+    @messenger = Messenger.new
+    @messenger.port = 'port'
+    @messenger.address = 'ip'
+    Pokan::RequestHandler.address = 'ip'
+    Pokan::RequestHandler.port = 'port'
+    @req_handler = Pokan::RequestHandler.new nil
+  end
+
+  before :each do
+    Pokan::Connection.redis.flushall
+    @req_handler.merge({
+      p1: {
+        status: { value: 'alive', timestamp: 100 },
+        role: { value: 'peer', timestamp: 100 },
+        answer: { value: 'FALSE', timestamp: 100 },
+        foo: { value: 'baz', timestamp: 101 }
+      },
+      p2: {
+        status: { value: 'alive', timestamp: 100 },
+        role: { value: 'peer', timestamp: 100 },
+        answer: { value: '+/-', timestamp: 102 },
+        foo: { value: 'baz', timestamp: 103 }
+      }
+    })
+  end
+
+  context 'when generating a digest message' do
+    before :each do
+      @digest = JSON.parse(@messenger.digest_message)
+    end
+
+    it 'should set action as digest' do
+      @digest['action'].should == 'digest'
+    end
+
+    it 'should set the timestamps of all keys of all known ids' do
+      @digest['data'].should == {
+        'p1' => { 'answer' => 100, 'foo' => 101, 'status' => 100, 'role' => 100 },
+        'p2' => { 'answer' => 102, 'foo' => 103, 'status' => 100, 'role' => 100 }
+      }
+    end
+  end
+
+  context 'when receiving a hello message' do
+    it 'should create the peer and set its role' do
+      hello_message = {
+        'action' => 'hello',
+        'role' => 'peer',
+        'origin' => 'ip:port'
+      }
+      @req_handler.receive_data(hello_message.to_json)
+      peer = Pokan::Query.new(Pokan::Peer).where(id:'ip:port')[0]
+      peer.value(:role).should == 'peer'
+    end
+  end
+
+  context 'when receiving a goodbye message' do
+    it 'should kill the origin peer' do
+      peer = Pokan::Peer.new
+      peer.address = 'ip'
+      peer.udp_port = 'port'
+      peer.save
+      goodbye_message = {
+        'action' => 'goodbye',
+        'timestamp' => 97317585671,
+        'origin' => 'ip:port'
+      }
+      @req_handler.receive_data(goodbye_message.to_json)
+      peer = Pokan::Query.new(Pokan::Peer).where(id: 'ip:port')[0]
+      peer.value(:status).should == 'dead'
+    end
+  end
+end

data/spec/pokan/server_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Pokan::Server do
+
+  before :each do
+    Pokan::Connection.redis.flushall
+  end
+
+  context 'when server is being configured manually' do
+
+    before { @server = Pokan::Server.new('10.10.10.8') }
+
+    it 'should gossip every specified interval' do
+      @server.gossip_every(3)
+      @server.gossip_interval.should == 3
+    end
+
+    it 'should use epoll when it is told to' do
+      @server.use_epoll
+      @server.using_epoll?.should be_true
+    end
+
+  end
+
+  context 'when behavior is added to the server' do
+
+    before { @server = Pokan::Server.new('10.10.10.8') }
+
+    it 'should properly call registered callbacks on events' do
+      @block_called = false
+      add_behavior_to_event(:new_key)
+
+      @server.store 'k', 'v'
+
+      @block_called.should be_true
+    end
+
+    def add_behavior_to_event(event)
+      @server.on event do |key, value|
+        @block_called = true
+      end
+    end
+
+  end
+
+end