rbczmq 0.1

data/test/socket/test_push_socket.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPushSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PUSH)
+    assert_equal ZMQ::PUSH, sock.type
+    assert_equal "PUSH socket", sock.to_s
+    assert_raises ZMQ::Error do
+      sock.recv
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_rep_socket.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestRepSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert_equal ZMQ::REP, sock.type
+    assert_equal "REP socket", sock.to_s
+  ensure
+    ctx.destroy
+  end
+
+  def test_flow
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    sock.bind("inproc://test.rep-sock-flow")
+    assert_raises ZMQ::Error do
+      sock.send_frame(ZMQ::Frame("frame"), ZMQ::Frame::MORE)
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_req_rep_sockets.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestReqRepSockets < ZmqTestCase
+  def test_flow
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, "inproc://test.req-rep-flow")
+    ctx.connect(:REQ, "inproc://test.req-rep-flow")
+    begin
+      rep.send("message")
+    rescue ZMQ::Error => e
+      assert_match(/REP sockets allows only an alternating sequence of receive and subsequent send calls. Please assert that you're not sending \/ receiving out of band data when using the REQ \/ REP socket pairs./, e.message)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_transfer
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, "inproc://test.req-rep-transfer")
+    req = ctx.connect(:REQ, "inproc://test.req-rep-transfer")
+    req.send("message")
+    assert_equal "message", rep.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_distribution
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, "inproc://test.req-rep-distribution")
+    thread = Thread.new do
+      req = ctx.connect(:REQ, "inproc://test.req-rep-distribution")
+      req.send_frame ZMQ::Frame("message")
+      req.close
+    end
+    thread.join
+    assert_equal ZMQ::Frame("message"), rep.recv_frame
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_req_socket.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestReqSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REQ)
+    assert_equal ZMQ::REQ, sock.type
+    assert_equal "REQ socket", sock.to_s
+  ensure
+    ctx.destroy
+  end
+
+  def test_flow
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    rep.bind("inproc://test.req-sock-flow")
+    sock = ctx.socket(:REQ)
+    sock.connect("inproc://test.req-sock-flow")
+    assert_raises ZMQ::Error do
+      sock.send_frame(ZMQ::Frame("frame"), ZMQ::Frame::MORE)
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_router_socket.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestRouterSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:ROUTER)
+    assert_equal ZMQ::ROUTER, sock.type
+    assert_equal "ROUTER socket", sock.to_s
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_routing.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestRouting < ZmqTestCase
+  def test_flow
+    ctx = ZMQ::Context.new
+    router = ctx.bind(:ROUTER, "inproc://test.routing-flow")
+    dealer = ctx.socket(:DEALER)
+    dealer.identity = "xyz"
+    dealer.connect("inproc://test.routing-flow")
+
+    router.sendm("xyz")
+    router.send("request")
+    assert_equal "request", dealer.recv
+
+    dealer.send("reply")
+    assert_equal "xyz", router.recv
+    assert_equal "reply", router.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_transfer
+    ctx = ZMQ::Context.new
+    router = ctx.bind(:ROUTER, "inproc://test.routing-transfer")
+    dealer = ctx.socket(:DEALER)
+    dealer.identity = "xyz"
+    dealer.connect("inproc://test.routing-transfer")
+
+    router.send_frame ZMQ::Frame("xyz"), ZMQ::Frame::MORE
+    router.send_frame ZMQ::Frame("request")
+
+    assert_equal ZMQ::Frame("request"), dealer.recv_frame
+
+    req = ZMQ::Message.new
+    req.push ZMQ::Frame("request")
+    req.push ZMQ::Frame("xyz")
+    router.send_message req
+
+    msg = dealer.recv_message
+    assert_equal ZMQ::Frame("request"), msg.pop
+  ensure
+    ctx.destroy
+  end
+
+  def test_distribution
+    ctx = ZMQ::Context.new
+    router = ctx.bind(:ROUTER, "inproc://test.routing-distribution")
+    thread = Thread.new do
+      dealer = ctx.socket(:DEALER)
+      dealer.identity = "xyz"
+      dealer.connect("inproc://test.routing-distribution")
+      frame = dealer.recv_frame
+      dealer.close
+      frame
+    end
+
+    sleep 0.5 # "slow joiner" syndrome
+    router.send_frame ZMQ::Frame("xyz"), ZMQ::Frame::MORE
+    router.send_frame ZMQ::Frame("message")
+    assert_equal ZMQ::Frame("message"), thread.value
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_sub_socket.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestSubSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:SUB)
+    assert_equal ZMQ::SUB, sock.type
+    assert_equal "SUB socket", sock.to_s
+    assert_raises ZMQ::Error do
+      sock.send("message")
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqContext < ZmqTestCase
+  def test_context
+    ctx = ZMQ::Context.new
+    assert_instance_of ZMQ::Context, ctx
+    assert_raises(ZMQ::Error) do
+      ZMQ::Context.new
+    end
+    assert_equal ctx, ZMQ.context
+  ensure
+    assert_nil ctx.destroy
+  end
+
+  def test_destroyed_context
+    ctx = ZMQ::Context.new
+    ctx.destroy
+    assert_raises ZMQ::Error do
+      ctx.iothreads = 2
+    end
+  end
+
+  def test_context_with_iothreads
+    ctx = ZMQ::Context.new(2)
+    assert_instance_of ZMQ::Context, ctx
+    assert_raises(ZMQ::Error) do
+      ZMQ::Context.new
+    end
+    assert_equal ctx, ZMQ.context
+  ensure
+    assert_nil ctx.destroy
+  end
+
+  def test_iothreads
+    ctx = ZMQ::Context.new
+    assert_raises TypeError do
+      ctx.iothreads = :invalid  
+    end
+    ctx.iothreads = 2
+    assert_raises ZMQ::Error do
+      ctx.iothreads = -2
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_linger
+    ctx = ZMQ::Context.new
+    assert_raises TypeError do
+      ctx.linger = :invalid  
+    end
+    ctx.linger = 10
+    assert_raises ZMQ::Error do
+      ctx.linger = -2
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_bind_connect
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, "inproc://test.bind_connect")
+    req = ctx.connect(:REQ, "inproc://test.bind_connect")
+    req.send('success')
+    assert_equal 'success', rep.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_socket
+    ctx = ZMQ::Context.new
+    assert_raises TypeError do
+      ctx.socket("invalid")
+    end
+    socket = ctx.socket(ZMQ::REP)
+    assert_instance_of ZMQ::Socket::Rep, socket
+    assert_nil socket.close
+    socket = ctx.socket(:REP)
+    assert_instance_of ZMQ::Socket::Rep, socket
+    assert_nil socket.close
+  ensure
+    ctx.destroy
+  end
+end

data/test/test_frame.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqFrame < ZmqTestCase
+  def test_alloc
+    frame = ZMQ::Frame("message")
+    assert_instance_of ZMQ::Frame, frame
+    assert_nil frame.destroy
+  end
+
+  def test_destroyed_frame
+    frame = ZMQ::Frame("message")
+    frame.destroy
+    assert_raises ZMQ::Error do
+      frame.data
+    end
+  end
+
+  def test_alloc_empty
+    frame = ZMQ::Frame.new
+    assert_equal 0, frame.size
+    frame.destroy
+  end
+
+  def test_size
+    assert_equal 7, ZMQ::Frame("message").size
+  end
+
+  def test_data
+    frame =  ZMQ::Frame("message")
+    assert_equal "message", frame.data
+    assert_equal "message", frame.to_s
+    assert_equal "message", frame.to_str
+  end
+
+  def test_dup
+    frame =  ZMQ::Frame("message")
+    dup_frame = frame.dup
+    assert_not_equal dup_frame.object_id, frame.object_id
+    assert_equal frame.data, dup_frame.data
+  end
+
+  def test_strhex
+    frame =  ZMQ::Frame("message")
+    assert_equal "6D657373616765", frame.strhex
+  end
+
+  def test_data_equals
+    frame =  ZMQ::Frame("message")
+    assert frame.data_equals?("message")
+    assert !frame.data_equals?("msg")
+  end
+
+  def test_equals
+    frame =  ZMQ::Frame("message")
+    assert_equal frame, ZMQ::Frame("message")
+    assert_not_equal frame, ZMQ::Frame("msg")
+  end
+
+  def test_compare
+    frame =  ZMQ::Frame("message")
+    assert frame > ZMQ::Frame("msg")
+    assert ZMQ::Frame("msg") < ZMQ::Frame("message")
+  end
+
+  def test_print
+    frame =  ZMQ::Frame("message")
+    assert_nil frame.print
+    assert_nil frame.print("prefix")
+  end
+
+  def test_reset
+    frame =  ZMQ::Frame("message")
+    frame.reset("msg")
+    assert_equal "msg", frame.data
+  end
+end

data/test/test_handler.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqHandler < ZmqTestCase
+  def test_expects_pollitem
+    assert_raises TypeError do
+      ZMQ::Handler.new(:socket)
+    end
+  end
+
+  def test_readable_writable_contracts
+    handler = ZMQ::Handler.new(ZMQ::Pollitem(STDIN))
+    assert_raises NotImplementedError do
+      handler.on_readable
+    end
+    assert_raises NotImplementedError do
+      handler.on_writable
+    end
+  end
+
+  def test_error
+    handler = ZMQ::Handler.new(ZMQ::Pollitem(STDIN))
+    assert_raises StandardError do
+      handler.on_error(StandardError.new)
+    end
+  end
+end

data/test/test_loop.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqLoop < ZmqTestCase
+  def test_alloc
+    lp = ZMQ::Loop.new
+    assert_instance_of ZMQ::Loop, lp
+  end
+
+  def test_destroyed
+    lp = ZMQ::Loop.new
+    lp.destroy
+    assert_raises ZMQ::Error do
+      lp.start
+    end
+  end
+
+  def test_run_and_stop
+    ctx = ZMQ::Context.new
+    ZMQ::Loop.run do
+      assert !ZL.running?
+      ZL.add_oneshot_timer(0.2) do
+        ZL.stop
+      end
+      ZL.add_oneshot_timer(0.1) do
+        assert ZL.running?
+      end
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_callback_stops_event_loop
+    ctx = ZMQ::Context.new
+    ret = ZMQ::Loop.run do
+      ZL.add_oneshot_timer(0.2){ false }
+    end
+    assert_equal(-1, ret)
+  ensure
+    ctx.destroy
+  end
+
+  def test_callback_error_stops_event_loop
+    ctx = ZMQ::Context.new
+    assert_raises RuntimeError do
+      ret = ZMQ::Loop.run do
+        ZL.add_oneshot_timer(0.2){ raise("stop!") }
+      end
+      assert_equal(-1, ret)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_add_periodic_timer
+    ctx = ZMQ::Context.new
+    fired = 0
+    ZMQ::Loop.run do
+      ZL.add_periodic_timer(0.1) do 
+        fired += 1
+        fired < 3
+      end
+    end
+    assert_equal 3, fired
+  ensure
+    ctx.destroy
+  end
+
+  def test_add_timer
+    ctx = ZMQ::Context.new
+    fired, timer = 0, nil
+    ZMQ::Loop.run do
+      timer = ZL.add_timer(0.1, 5) do
+        fired += 1
+        fired < 5
+      end
+    end
+    assert_instance_of ZMQ::Timer, timer
+    assert_equal 5, fired
+  ensure
+    ctx.destroy
+  end
+
+  def test_cancel_timer
+    ctx = ZMQ::Context.new
+    fired = 0
+    ZMQ::Loop.run do
+      timer = ZL.add_timer(0.1, 5) do
+        fired += 1
+        fired < 5
+      end
+      assert ZL.cancel_timer(timer)
+      ZL.add_oneshot_timer(0.1){ false }
+    end
+    assert_equal 0, fired
+  ensure
+    ctx.destroy
+  end
+
+  def test_cancel_timer_instance
+    ctx = ZMQ::Context.new
+    fired = 0
+    timer = ZMQ::Timer.new(0.1, 2){ fired += 1 }
+    ZMQ::Loop.run do
+      ZL.register_timer(timer)
+      ZL.add_oneshot_timer(0.3){ false }
+      timer.cancel
+    end
+    assert_equal 0, fired
+  ensure
+    ctx.destroy
+  end
+
+  def test_add_oneshot_timer
+    ctx = ZMQ::Context.new
+    ret = ZMQ::Loop.run do
+      ZL.add_oneshot_timer(0.2){ false }
+    end
+    assert_equal(-1, ret)
+  ensure
+    ctx.destroy
+  end
+
+  def test_run_in_thread
+    ctx = ZMQ::Context.new
+    t = Thread.new do
+      ZMQ::Loop.run do
+        ZL.add_oneshot_timer(0.2){ false }
+      end
+      :done
+    end
+    assert_equal :done, t.value
+  ensure
+    ctx.destroy
+  end
+
+  class LoopBreaker < ZMQ::Handler
+    def on_readable
+      p :on_readable
+      false
+    end
+
+    def on_writable
+    end
+  end
+
+  def test_register_sockets
+    ctx = ZMQ::Context.new
+    ret = ZMQ::Loop.run do
+      s1 = ctx.socket(:PAIR)
+      s2 = ctx.socket(:PAIR)
+      s3 = ctx.socket(:PAIR)
+      ZL.bind(s1, "inproc://test.loop-register", LoopBreaker)
+      ZL.connect(s2, "inproc://test.loop-register")
+      s2.send("message")
+      assert_raises ZMQ::Error do
+        ZL.register(s3)
+      end
+    end
+    assert_equal(-1, ret)
+  ensure
+    ctx.destroy
+  end
+
+  def test_register_ios
+    r, w = IO.pipe
+    ret = ZMQ::Loop.run do
+      ZL.register_readable(r, LoopBreaker)
+      ZL.register_writable(w)
+      w.write("message")
+    end
+    assert_equal(-1, ret)
+  end
+
+  def test_register_ruby_sockets
+    server = TCPServer.new("127.0.0.1", 0)
+    f, port, host, addr = server.addr
+    client = TCPSocket.new("127.0.0.1", port)
+    s = server.accept
+    ret = ZMQ::Loop.run do
+      ZL.register_readable(s, LoopBreaker)
+      ZL.register_writable(client)
+      client.send("message", 0)
+    end
+    assert_equal(-1, ret)
+  end
+
+  class FailHandler < ZMQ::Handler
+    def on_readable
+      p :on_readable
+      raise "fail"
+    end
+
+    def on_writable
+    end
+  end
+
+  def test_raise_from_socket_callback
+    ctx = ZMQ::Context.new
+    assert_raises RuntimeError do
+      ret = ZMQ::Loop.run do
+        s1 = ctx.socket(:PAIR)
+        s2 = ctx.socket(:PAIR)
+        ZL.bind(s1, "inproc://test.loop-raise_from_socket_callback", FailHandler)
+        ZL.connect(s2, "inproc://test.loop-raise_from_socket_callback")
+        s2.send("message")
+      end
+      assert_equal(-1, ret)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_raise_from_io_callback
+    assert_raises RuntimeError do
+      ret = ZMQ::Loop.run do
+        r, w = IO.pipe
+        ZL.register_readable(r, FailHandler)
+        ZL.register_writable(w)
+        w.write("message")
+      end
+      assert_equal(-1, ret)
+    end
+  end
+
+  def test_raise_on_invalid_handler
+    ctx = ZMQ::Context.new
+    assert_raises RuntimeError do
+      ret = ZMQ::Loop.run do
+        s1 = ctx.socket(:PAIR)
+        s2 = ctx.socket(:PAIR)
+        ZL.bind(s1, "inproc://test.loop-raise_on_invalid_handler", FailHandler)
+        ZL.connect(s2, "inproc://test.loop-raise_on_invalid_handler")
+        s2.send("message")
+      end
+      assert_equal(-1, ret)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_double_stop
+    ctx = ZMQ::Context.new
+    assert_raises ZMQ::Error do
+      lp = ZMQ::Loop.new
+      lp.stop
+    end
+  ensure
+    ctx.destroy
+  end
+end