em-zmq-tp10 0.1.7

data/tests/test_req.rb

@@ -0,0 +1,229 @@
+require 'eventmachine'
+require 'minitest/autorun'
+require File.expand_path('../helper.rb', __FILE__)
+
+require 'em/protocols/zmq2/req'
+
+describe 'Req' do
+  let(:connected) do
+    EM::DefaultDeferrable.new
+  end
+
+  describe EM::Protocols::Zmq2::PreReq do
+    class MyPreReq < EM::Protocols::Zmq2::PreReq
+      attr :incoming_queue
+      def initialize(opts={})
+        super
+        @connected = opts[:connected]
+        @incoming_queue = []
+      end
+      def peer_free(peer_identity, connection)
+        super
+        @connected.succeed
+      end
+      def receive_reply(message, data, request_id)
+        message.first.must_equal 'world'
+        message.last.must_equal data.to_s
+        @incoming_queue << ['hello', message.last]
+      end
+    end
+
+    attr :req
+    before do
+      @req = MyPreReq.new(identity: 'REQ', connected: connected)
+      @req.connect(Native::ZBIND_ADDR)
+    end
+
+    let(:messages){
+      300.times.map{|i| ['hello', i.to_s]} << ['hello', 'xxx']
+    }
+
+    it 'should send requests' do
+      Native.with_socket('REP') do |zrep|
+        thrd = Thread.new do
+          messages.size.times do
+            ar = []
+            zrep.recv_strings ar
+            ar[0] = 'world'
+            zrep.send_strings ar
+          end
+        end
+        EM.run {
+          connected.callback {
+            dup = messages.dup
+            cb = lambda {
+              if dup.empty?
+                EM.add_timer(0.3){
+                  EM.next_tick{ EM.stop }
+                }
+              else
+                message = dup.first
+                if String === req.send_request(message, message.last)
+                  dup.shift
+                  EM.next_tick cb
+                else
+                  EM.add_timer 0.1, cb
+                end
+              end
+            }
+            cb.call
+          }
+        }
+        thrd.join
+      end
+      (req.incoming_queue - messages).must_be_empty
+      (messages - req.incoming_queue).must_be_empty
+    end
+  end
+
+  describe EM::Protocols::Zmq2::Req do
+    class MyReq < EM::Protocols::Zmq2::Req
+      attr :incoming_queue, :canceled_requests
+      def initialize(opts={}, defered_conn, defered_mess)
+        super opts
+        @defered_conn = defered_conn
+        @defered_mess = defered_mess
+        @incoming_queue = []
+        @canceled_requests = []
+      end
+      def peer_free(peer_identity, connection)
+        super
+        @defered_conn.succeed
+      end
+      def receive_reply(message, data, request_id)
+        message.first.must_equal 'world'
+        message.last.must_equal data.to_s
+        @incoming_queue << ['hello', message.last]
+        @defered_mess.succeed  if message.last == 'xxx'
+      end
+      def cancel_request(request_id)
+        @canceled_requests << request_id
+      end
+    end
+
+    let(:finished){ EM::DefaultDeferrable.new }
+    attr :req
+    before do
+      @req = MyReq.new({identity: 'REQ'}, connected, finished)
+      @req.connect(Native::ZBIND_ADDR)
+    end
+    let(:messages){
+      5000.times.map{|i| ['hello', i.to_s]} << ['hello', 'xxx']
+    }
+
+    it 'should send a lot of requests' do
+      Native.with_socket('REP') do |zrep|
+        thrd = Thread.new do
+          messages.size.times do
+            ar = []
+            zrep.recv_strings ar
+            ar[0] = 'world'
+            zrep.send_strings ar
+          end
+        end
+        EM.run {
+          connected.callback {
+            messages.each{|message|
+              req.send_request(message, message.last)
+            }
+          }
+          finished.callback {
+            EM.next_tick{ EM.stop }
+          }
+        }
+        thrd.join
+      end
+      (req.incoming_queue - messages).must_be_empty
+      (messages - req.incoming_queue).must_be_empty
+    end
+
+    it "should not accept message on low hwm with strategy :drop_last" do
+      req.hwm = 2
+      req.hwm_strategy = :drop_last
+      EM.run {
+        req.send_request(['hi', 'ho1'], nil).must_be_kind_of String
+        req.send_request(['hi', 'ho2'], nil).must_be_kind_of String
+        req.send_request(['hi', 'ho3'], nil).wont_be_kind_of String
+        EM.stop
+      }
+    end
+
+    it "should cancel earlier message on low hwm with strategy :drop_first" do
+      req.hwm = 2
+      req.hwm_strategy = :drop_first
+      first_req = nil
+      EM.run {
+        first_req = req.send_request(['hi', 'ho1'], nil)
+        first_req.must_be_kind_of String
+        req.send_request(['hi', 'ho2'], nil).must_be_kind_of String
+        req.send_request(['hi', 'ho3'], nil).must_be_kind_of String
+        EM.stop
+      }
+      req.canceled_requests.must_equal [first_req]
+    end
+  end
+
+  describe EM::Protocols::Zmq2::ReqDefer do
+    class TSTRep < EM::Protocols::Zmq2::Rep
+      include DeferredMixin
+      def receive_request(message, environment)
+        send_reply([message.first, 'yeah'], environment)
+      end
+      def peer_free(peer, conn)
+        super
+        @connected.succeed
+      end
+    end
+    it "should correctly setup and call deferrable" do
+      req = EM::Protocols::Zmq2::ReqDefer.new
+      def req.send_message(message, even = false)
+        res = super
+        res
+      end
+      rep = TSTRep.new(connected: connected)
+      rep.bind('inproc://tst')
+      first_success, first_error = nil, nil
+      second_success, second_error = nil, nil
+          require 'pp'
+      EM.run {
+        uniq = Object.new.freeze
+        first = nil
+        follow = proc do |null, data|
+          data.must_equal uniq
+          null.must_be_nil
+          req.connect('inproc://tst')
+          connected.callback do
+            stop = proc{ EM.next_tick{ EM.stop } }
+            second = req.send_request(['hi', 'ho'], uniq) do |reply, data|
+              second_success = true
+              reply.must_equal ['hi', 'yeah']
+              data.must_equal uniq
+            end
+            second.must_be_kind_of EM::Deferrable
+            second.errback do
+              second_error = true
+            end
+            second.callback &stop
+            second.errback &stop
+          end
+        end
+        first = req.send_request(['hi', 'ho'], uniq) do |reply, data|
+          first_success = true
+          reply.must_equal ['hi', 'yeah']
+          data.must_equal uniq
+        end
+        first.must_be_kind_of EM::Deferrable
+        first.timeout(0.3, 1, uniq)
+        first.errback do
+          first_error = true
+        end
+        first.callback &follow
+        first.errback &follow
+      }
+      first_success.must_equal nil
+      first_error.must_equal true
+      second_success.must_equal true
+      second_error.must_equal nil
+    end
+  end
+end

data/tests/test_router.rb

@@ -0,0 +1,221 @@
+require 'eventmachine'
+require 'minitest/autorun'
+require File.expand_path('../helper.rb', __FILE__)
+
+require 'em/protocols/zmq2/router'
+
+describe 'Router' do
+
+  let(:connected) do
+    EM::DefaultDeferrable.new
+  end
+
+  let(:finished) do
+    EM::DefaultDeferrable.new
+  end
+
+  class DealerCollector
+    attr :res_a, :res_b
+    def initialize(till)
+      @till = till
+      @res_a, @res_b = [], []
+    end
+    def full?
+      @res_a.size + @res_b.size >= @till
+    end
+    def full_res
+      @res_a + @res_b
+    end
+    def set_sockets(zbind, zconnect)
+      @zbind = zbind
+      @zconnect = zconnect
+    end
+    def thread
+      Thread.new do
+        begin
+        result = []
+        until full?
+          while @zbind.recv_strings(result, ZMQ::NOBLOCK) != -1
+            result.first.must_equal 'hello'
+            @res_a << result
+            result = []
+          end
+          while @zconnect.recv_strings(result, ZMQ::NOBLOCK) != -1
+            result.first.must_equal 'hello'
+            @res_b << result
+            result = []
+          end
+          sleep(0.01)
+        end
+        rescue
+          puts $!
+        end
+      end
+    end
+  end
+
+  describe EM::Protocols::Zmq2::PreRouter do
+    class MyPreRouter < EM::Protocols::Zmq2::PreRouter
+      attr :incoming_queue
+      def initialize(connected, finished, opts={})
+        super opts
+        @connected = connected
+        @finished = finished
+        @incoming_queue = {}
+      end
+      def peer_free(peer_ident, connection)
+        super
+        @connected.succeed  if @free_peers.size == 2
+      end
+      def receive_message(message)
+        (@incoming_queue[message.first] ||= []) << message[1..-1]
+        @finished.succeed  if message.last == 'xxx'
+      end
+    end
+
+    attr :router
+    before do
+      @router = MyPreRouter.new(connected, finished, identity: 'MyRouter')
+      @router.bind(Native::ZCONNECT_ADDR)
+      @router.connect(Native::ZBIND_ADDR)
+    end
+
+    let(:messages) do
+      62.times.map{|n| ['hello', n.to_s] } << ['hello', 'xxx']
+    end
+
+    it "should be able to receive messages" do
+      halves = messages[0...(messages.size/2)], messages[(messages.size/2)..-1]
+      Native.with_socket_pair('DEALER') do |zbind, zconnect|
+        EM.run {
+          connected.callback do
+            halves[0].each do |message|
+              zbind.send_strings(message)
+            end
+            halves[1].each do |message|
+              zconnect.send_strings(message)
+            end
+          end
+          finished.callback do
+            EM.next_tick{ EM.stop }
+          end
+        }
+      end
+      router.incoming_queue['BIND_DEALER'].must_equal halves[0]
+      router.incoming_queue['CONNECT_DEALER'].must_equal halves[1]
+    end
+
+    it "should be able to route messages" do
+      collector = DealerCollector.new(messages.size)
+      halves = messages[0...(messages.size/2)], messages[(messages.size/2)..-1]
+      Native.with_socket_pair('DEALER') do |zbind, zconnect|
+        collector.set_sockets zbind, zconnect
+        thrd = collector.thread
+        EM.run {
+          dup_halves = halves.map(&:dup)
+          connected.callback do
+            dup_halves[0].each do |message|
+              router.send_message(['BIND_DEALER', *message]).must_equal true
+            end
+            dup_halves[1].each do |message|
+              router.send_message(['CONNECT_DEALER', *message]).must_equal true
+            end
+            EM.defer(proc do thrd.join end, proc do
+              EM.next_tick{ EM.stop }
+            end)
+          end
+        }
+      end
+      collector.res_a.must_equal halves[0]
+      collector.res_b.must_equal halves[1]
+    end
+  end
+
+  describe EM::Protocols::Zmq2::Router do
+    class MyRouter < EM::Protocols::Zmq2::Router
+      attr :incoming_queue, :canceled_messages
+      def initialize(connected, finished, opts={})
+        super opts
+        @connected = connected
+        @finished = finished
+        @incoming_queue = {}
+        @canceled_messages = []
+      end
+      def peer_free(peer_ident, connection)
+        super
+        @connected.succeed  if @free_peers.size == 2
+      end
+      def receive_message(message)
+        (@incoming_queue[message.first] ||= []) << message[1..-1]
+        @finished.succeed  if message.last == 'xxx'
+      end
+      def cancel_message(message)
+        @canceled_messages << message
+      end
+    end
+
+    attr :router
+    before do
+      @router = MyRouter.new(connected, finished, identity: 'MyRouter')
+      @router.bind(Native::ZCONNECT_ADDR)
+      @router.connect(Native::ZBIND_ADDR)
+    end
+
+    let(:messages) do
+      10000.times.map{|n| ['hello', n.to_s] } << ['hello', 'xxx']
+    end
+
+    it "should be able to route a lot of messages" do
+      collector = DealerCollector.new(messages.size)
+      halves = messages[0...(messages.size/2)], messages[(messages.size/2)..-1]
+      Native.with_socket_pair('DEALER') do |zbind, zconnect|
+        collector.set_sockets zbind, zconnect
+        thrd = collector.thread
+        EM.run {
+          dup_halves = halves.map(&:dup)
+          connected.callback do
+            dup_halves[0].each do |message|
+              router.send_message(['BIND_DEALER', *message])
+            end
+            dup_halves[1].each do |message|
+              router.send_message(['CONNECT_DEALER', *message])
+            end
+            EM.defer(proc do thrd.join end, proc do
+              EM.next_tick{ EM.stop }
+            end)
+          end
+        }
+        thrd.join
+      end
+      collector.res_a.must_equal halves[0]
+      collector.res_b.must_equal halves[1]
+    end
+
+    it "should not accept message on low hwm with strategy :drop_last" do
+      router.hwm = 1
+      router.hwm_strategy = :drop_last
+      EM.run {
+        router.send_message(['FIRST_PEER', 'hi', 'ho1']).must_equal true
+        router.send_message(['FIRST_PEER', 'hi', 'ho2']).wont_equal true
+        router.send_message(['SECOND_PEER', 'hi', 'ho1']).must_equal true
+        router.send_message(['SECOND_PEER', 'hi', 'ho2']).wont_equal true
+        EM.stop
+      }
+    end
+
+    it "should cancel earlier message on low hwm with strategy :drop_first" do
+      router.hwm = 1
+      router.hwm_strategy = :drop_first
+      EM.run {
+        router.send_message(['FIRST_PEER', 'hi', 'ho1']).must_equal true
+        router.send_message(['FIRST_PEER', 'hi', 'ho2']).must_equal true
+        router.send_message(['SECOND_PEER', 'hi', 'ho1']).must_equal true
+        router.send_message(['SECOND_PEER', 'hi', 'ho2']).must_equal true
+        EM.stop
+      }
+      router.canceled_messages.count.must_equal 2
+      router.canceled_messages.must_include ['FIRST_PEER', 'hi', 'ho1']
+      router.canceled_messages.must_include ['SECOND_PEER', 'hi', 'ho1']
+    end
+  end
+end