ffi-rxs 1.0.0

data/spec/nonblocking_recv_spec.rb

@@ -0,0 +1,309 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module XS
+
+
+  describe Socket do
+    before(:all) do
+      @ctx = Context.new
+    end
+
+    after(:all) do
+      @ctx.terminate
+    end
+
+
+    shared_examples_for "any socket" do
+
+      it "returns -1 when there are no messages to read" do
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        Util.resultcode_ok?(rc).should be_false
+      end
+
+      it "gets EAGAIN when there are no messages to read" do
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        XS::Util.errno.should == XS::EAGAIN
+      end
+
+      it "returns the given array unmodified when there are no messages to read" do
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        array.size.should be_zero
+      end
+
+    end
+
+    shared_examples_for "sockets without exposed envelopes" do
+
+      it "read the single message and returns a successful result code" do
+        rc = @sender.send_string('test')
+        Util.resultcode_ok?(rc).should be_true
+        sleep 0.1 # give it time to deliver to the receiver
+
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        Util.resultcode_ok?(rc).should be_true
+        array.size.should == 1
+      end
+
+      it "read all message parts transmitted and returns a successful result code" do
+        strings = Array.new(10, 'test')
+        rc = @sender.send_strings(strings)
+        Util.resultcode_ok?(rc).should be_true
+        sleep 0.1 # give it time to deliver to the sub socket
+
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        Util.resultcode_ok?(rc).should be_true
+        array.size.should == 10
+      end
+
+    end
+
+    shared_examples_for "sockets with exposed envelopes" do
+
+      it "read the single message and returns a successful result code" do
+        rc = @sender.send_string('test')
+        Util.resultcode_ok?(rc).should be_true
+        sleep 0.1 # give it time to deliver to the receiver
+
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        Util.resultcode_ok?(rc).should be_true
+        array.size.should == 1 + 1 # extra 1 for envelope
+      end
+
+      it "read all message parts transmitted and returns a successful result code" do
+        strings = Array.new(10, 'test')
+        rc = @sender.send_strings(strings)
+        Util.resultcode_ok?(rc).should be_true
+        sleep 0.1 # give it time to deliver to the sub socket
+
+        array = []
+        rc = @receiver.recvmsgs(array, XS::NonBlocking)
+        Util.resultcode_ok?(rc).should be_true
+        array.size.should == 10 + 1 # add 1 for the envelope
+      end
+
+    end
+
+    context "PUB" do
+
+      describe "non-blocking #recvmsgs where sender binds & receiver connects" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::SUB
+          port = connect_to_random_tcp_port(@receiver)
+          assert_ok(@receiver.setsockopt(XS::SUBSCRIBE, ''))
+          @sender = @ctx.socket XS::PUB
+          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
+          sleep 0.3
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets without exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+    end # Pub
+
+    context "REQ" do
+
+      describe "non-blocking #recvmsgs where sender connects & receiver binds" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::REP
+          port = bind_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::REQ
+          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets without exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+      describe "non-blocking #recvmsgs where sender binds & receiver connects" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::REP
+          port = connect_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::REQ
+          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets without exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+    end # REQ
+
+
+    context "PUSH" do
+
+      describe "non-blocking #recvmsgs where sender connects & receiver binds" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::PULL
+          port = bind_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::PUSH
+          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets without exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+      describe "non-blocking #recvmsgs where sender binds & receiver connects" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::PULL
+          port = connect_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::PUSH
+          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets without exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+    end # PUSH
+
+
+    context "DEALER" do
+
+      describe "non-blocking #recvmsgs where sender connects & receiver binds" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::ROUTER
+          port = bind_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::DEALER
+          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets with exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+      describe "non-blocking #recvmsgs where sender binds & receiver connects" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::ROUTER
+          port = connect_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::DEALER
+          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets with exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+    end # DEALER
+
+
+    context "XREQ" do
+
+      describe "non-blocking #recvmsgs where sender connects & receiver binds" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::XREP
+          port = bind_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::XREQ
+          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets with exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+      describe "non-blocking #recvmsgs where sender binds & receiver connects" do
+        include APIHelper
+
+        before(:each) do
+          @receiver = @ctx.socket XS::XREP
+          port = connect_to_random_tcp_port(@receiver)
+          @sender = @ctx.socket XS::XREQ
+          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
+          sleep 0.1
+        end
+
+        after(:each) do
+          @receiver.close
+          @sender.close
+        end
+
+        it_behaves_like "any socket"
+        it_behaves_like "sockets with exposed envelopes"
+
+      end # describe 'non-blocking recvmsgs'
+
+    end # XREQ
+
+  end # describe Socket
+
+
+end # module XS

data/spec/poll_spec.rb

@@ -0,0 +1,168 @@
+$: << "." # added for ruby 1.9.2 compatibilty; it doesn't include the current directory on the load path anymore
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module XS
+
+
+  describe Poller do
+
+    context "when initializing" do
+      include APIHelper
+
+      it "should allocate a PollItems instance" do
+        PollItems.should_receive(:new)
+        
+        Poller.new
+      end
+
+    end # context initializing
+    
+    
+    context "#register" do
+      
+      let(:poller) { Poller.new }
+      let(:socket) { mock('socket') }
+      
+      it "should return false when given a nil socket and no file descriptor" do
+        poller.register(nil, XS::POLLIN, 0).should be_false
+      end
+      
+      it "should return false when given 0 for +events+ (e.g. no registration)" do
+        poller.register(socket, 0).should be_false
+      end
+      
+      it "should return the registered event value when given a nil socket and a valid non-zero file descriptor" do
+        poller.register(nil, XS::POLLIN, 1).should == XS::POLLIN
+      end
+      
+      it "should return the default registered event value when given a valid socket" do
+        poller.register(socket).should == (XS::POLLIN | XS::POLLOUT)
+      end
+      
+      it "should access the raw 0mq socket" do
+        raw_socket = FFI::MemoryPointer.new(4)
+        socket.should_receive(:kind_of?).with(XS::Socket).and_return(true)
+        socket.should_receive(:socket).and_return(raw_socket)
+
+        poller.register(socket)
+      end
+    end
+    
+    
+    context "#delete" do
+      before(:all) do
+        @context = Context.new
+      end
+      
+      before(:each) do
+        @socket = @context.socket(XREQ)
+        @socket.setsockopt(LINGER, 0)
+        @poller = Poller.new
+      end
+      
+      after(:each) do
+        @socket.close
+      end
+      
+      after(:all) do
+        @context.terminate
+      end
+      
+      it "should return false for an unregistered socket (i.e. not found)" do
+        @poller.delete(@socket).should be_false
+      end
+      
+      it "returns true for a sucessfully deleted socket when only 1 is registered" do
+        socket1 = @context.socket(REP)
+        socket1.setsockopt(LINGER, 0)
+
+        @poller.register socket1
+        @poller.delete(socket1).should be_true
+        socket1.close
+      end
+      
+      it "returns true for a sucessfully deleted socket when more than 1 is registered" do
+        socket1 = @context.socket(REP)
+        socket2 = @context.socket(REP)
+        socket1.setsockopt(LINGER, 0)
+        socket2.setsockopt(LINGER, 0)
+
+        @poller.register socket1
+        @poller.register socket2
+        @poller.delete(socket2).should be_true
+        socket1.close
+        socket2.close
+      end
+      
+    end
+    
+    
+    context "poll" do
+      include APIHelper
+      
+      before(:all) do
+        @context = Context.new
+      end
+      
+      before(:each) do
+        @socket = @context.socket(REQ)
+        @socket2 = @context.socket(REP)
+        @socket.setsockopt(LINGER, 0)
+        @socket2.setsockopt(LINGER, 0)
+        port = bind_to_random_tcp_port(@socket2)
+        @socket.connect(local_transport_string(port))
+        sleep 0.2
+        @poller = Poller.new
+      end
+      
+      after(:each) do
+        @socket.close
+        @socket2.close
+      end
+      
+      after(:all) do
+        #@context.terminate
+      end
+      
+      it "returns 0 when there are no sockets to poll" do
+        rc = @poller.poll(0)
+        rc.should be_zero
+      end
+      
+      it "returns 0 when there is a single socket to poll and no events" do
+        @poller.register(@socket, 0)
+        rc = @poller.poll(0)
+        rc.should be_zero
+      end
+      
+      it "returns 1 when there is a read event on a socket" do
+        @poller.register_writable(@socket)
+        @poller.register_readable(@socket2)
+        sleep 0.2
+        
+        @socket.send_string('test')
+        sleep 0.1
+        rc = @poller.poll(0)
+        rc.should == 1
+      end
+      
+      it "returns 1 when there is a read event on one socket and the second socket has been removed from polling" do
+        @poller.register_readable(@socket2)
+        @poller.register_writable(@socket)
+        sleep 0.2
+        
+        @socket.send_string('test')
+        @poller.deregister_writable(@socket)
+        @socket.close
+        sleep 0.1
+        rc = @poller.poll(0)
+        rc.should == 1
+      end
+    end # poll
+
+
+  end # describe Poll
+
+
+end # module XS

data/spec/pushpull_spec.rb

@@ -0,0 +1,113 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module XS
+  describe Context do
+    context "when running basic push pull" do
+      include APIHelper
+
+      let(:string) { "booga-booga" }
+
+      before(:each) do
+        $stdout.flush
+        @context = XS::Context.new
+        @push = @context.socket XS::PUSH
+        @pull = @context.socket XS::PULL
+        @push.setsockopt XS::LINGER, 0
+        @pull.setsockopt XS::LINGER, 0
+        port = connect_to_random_tcp_port(@pull)
+        @link = "tcp://127.0.0.1:#{port}"
+        #@link = "inproc://push_pull_test" # can't connect to inproc *before* bind
+        @push.bind    @link
+      end
+
+      after(:each) do
+        @push.close
+        @pull.close
+        @context.terminate
+      end
+
+      it "should receive an exact copy of the sent message using Message objects directly on one pull socket" do
+        @push.send_string string
+        received = ''
+        rc = @pull.recv_string received
+        assert_ok(rc)
+        received.should == string
+      end
+
+      it "should receive an exact string copy of the message sent when receiving in non-blocking mode and using Message objects directly" do
+        sent_message = Message.new string
+        received_message = Message.new
+
+        rc = @push.sendmsg sent_message
+        rc.should == string.size
+        sleep 0.1 # give it time for delivery
+        rc = @pull.recvmsg received_message, XS::NonBlocking
+        rc.should == string.size
+        received_message.copy_out_string.should == string
+      end
+
+
+
+      it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages and a unique socket per thread" do
+        received = []
+        threads  = []
+        count    = 4
+        @pull.close # close this one since we aren't going to use it below and we don't want it to receive a message
+        mutex = Mutex.new
+
+        count.times do |i|
+          threads << Thread.new do
+            pull = @context.socket XS::PULL
+            rc = pull.setsockopt XS::LINGER, 0
+            rc = pull.connect @link
+            rc.should == 0
+            buffer = ''
+            rc = pull.recv_string buffer
+            rc.should == 11
+            mutex.synchronize { received << buffer }
+            pull.close
+          end
+          sleep 0.01 # give each thread time to spin up
+        end
+
+        count.times { @push.send_string(string) }
+
+        threads.each {|t| t.join}
+
+        received.find_all {|r| r == string}.length.should == count
+      end
+
+      it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages and a single shared socket protected by a mutex" do
+        received = []
+        threads  = []
+        count    = 4
+        @pull.close # close this one since we aren't going to use it below and we don't want it to receive a message
+        pull = @context.socket XS::PULL
+        rc = pull.setsockopt XS::LINGER, 0
+        rc = pull.connect @link
+        rc.should == 0
+        mutex = Mutex.new
+
+        count.times do |i|
+          threads << Thread.new do
+            buffer = ''
+            rc = 0
+            mutex.synchronize { rc = pull.recv_string buffer }
+            rc.should == 11
+            mutex.synchronize { received << buffer }
+          end
+          sleep 0.01 # give each thread time to spin up
+        end
+
+        count.times { @push.send_string(string) }
+
+        threads.each {|t| t.join}
+        pull.close
+
+        received.find_all {|r| r == string}.length.should == count
+      end
+
+    end # @context ping-pong
+  end # describe
+end # module XS

data/spec/reqrep_spec.rb

@@ -0,0 +1,66 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module XS
+
+
+  describe Context do
+
+    context "when running ping pong" do
+      include APIHelper
+
+      let(:string) { "booga-booga" }
+
+      before(:each) do
+        context = XS::Context.new
+        @ping = context.socket XS::REQ
+        @pong = context.socket XS::REP
+        port = bind_to_random_tcp_port(@pong)
+        @ping.connect "tcp://127.0.0.1:#{port}"
+      end
+
+      after(:each) do
+        @ping.close
+        @pong.close
+      end
+
+      it "should receive an exact string copy of the string message sent" do
+        @ping.send_string string
+        received_message = ''
+        rc = @pong.recv_string received_message
+
+        received_message.should == string
+      end
+
+      it "should receive an exact copy of the sent message using Message objects directly" do
+        sent_message = Message.new string
+        received_message = Message.new
+
+        rc = @ping.sendmsg sent_message
+        rc.should == string.size
+        rc = @pong.recvmsg received_message
+        rc.should == string.size
+
+        received_message.copy_out_string.should == string
+      end
+
+      it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
+        sent_message = Message.new string
+        received_message = Message.new
+
+        rc = @ping.sendmsg sent_message, XS::NonBlocking
+        rc.should == string.size
+        sleep 0.01 # give it time for delivery
+        rc = @pong.recvmsg received_message, XS::NonBlocking
+        rc.should == string.size
+
+        received_message.copy_out_string.should == string
+      end
+
+    end # context ping-pong
+
+
+  end # describe
+
+
+end # module XS