ffi-rzmq 0.9.3 → 0.9.6

data/lib/ffi-rzmq/util.rb

@@ -1,10 +1,9 @@
 
 module ZMQ
 
-  # These methods don't belong to any specific class. They get included
-  # in the #Context, #Socket and #Poller classes.
+  # General utility methods.
   #
-  module Util
+  class Util
 
     # Returns true when +rc+ is greater than or equal to 0, false otherwise.
     #
@@ -57,40 +56,15 @@ module ZMQ
 
       resultcode_ok?(rc) ? random : nil
     end
-
-    # Returns the proper flag value for non-blocking regardless of 0mq
-    # version.
-    #
-    if LibZMQ.version2?
-
-      def self.nonblocking_flag
-        NOBLOCK
-      end
-
-    elsif LibZMQ.version3?
-      
-      def self.nonblocking_flag
-        DONTWAIT
-      end
-
-    end
-
-
-    private
-
-    # generate a random port between 10_000 and 65534
-    def self.random_port
-      rand(55534) + 10_000
-    end
-
+    
     # :doc:
-    # Called by most library methods to verify there were no errors during
+    # Called to verify whether there were any errors during
     # operation. If any are found, raise the appropriate #ZeroMQError.
     #
     # When no error is found, this method returns +true+ which is behavior
     # used internally by #send and #recv.
     #
-    def error_check source, result_code
+    def self.error_check source, result_code
       if -1 == result_code
         raise_error source, result_code
       end
@@ -99,23 +73,55 @@ module ZMQ
       true
     end
 
-    def raise_error source, result_code
-      if 'zmq_init' == source || 'zmq_socket' == source
+
+    private
+
+    # generate a random port between 10_000 and 65534
+    def self.random_port
+      rand(55534) + 10_000
+    end
+
+    def self.raise_error source, result_code
+      if context_error?(source)
         raise ContextError.new source, result_code, ZMQ::Util.errno, ZMQ::Util.error_string
 
-      elsif ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move'].include?(source)
+      elsif message_error?(source)
         raise MessageError.new source, result_code, ZMQ::Util.errno, ZMQ::Util.error_string
 
       else
-        puts "else"
         raise ZeroMQError.new source, result_code, -1,
         "Source [#{source}] does not match any zmq_* strings, rc [#{result_code}], errno [#{ZMQ::Util.errno}], error_string [#{ZMQ::Util.error_string}]"
       end
     end
 
-    def eagain?
+    def self.eagain?
       EAGAIN == ZMQ::Util.errno
     end
+    
+    if LibZMQ.version2?
+      def self.context_error?(source)
+        'zmq_init' == source ||
+        'zmq_socket' == source
+      end
+      
+      def self.message_error?(source)
+        ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move'].include?(source)
+      end
+      
+    elsif LibZMQ.version3?
+      def self.context_error?(source)
+        'zmq_ctx_new' == source ||
+        'zmq_ctx_set' == source ||
+        'zmq_ctx_get' == source ||
+        'zmq_ctx_destory' == source ||
+        'zmq_ctx_set_monitor' == source
+      end
+      
+      def self.message_error?(source)
+        ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move', 'zmq_msg_close', 'zmq_msg_get',
+          'zmq_msg_more', 'zmq_msg_recv', 'zmq_msg_send', 'zmq_msg_set'].include?(source)
+      end
+    end # if LibZMQ.version...?
 
   end # module Util
 

data/lib/ffi-rzmq/version.rb

@@ -1,3 +1,3 @@
 module ZMQ
-  VERSION = "0.9.3"
+  VERSION = "0.9.6"
 end

data/spec/context_spec.rb

@@ -11,16 +11,12 @@ module ZMQ
       include APIHelper
 
       it "should return nil for negative io threads" do
-        LibZMQ.stub(:zmq_init => nil)
         Context.create(-1).should be_nil
       end
       
       it "should default to requesting 1 i/o thread when no argument is passed" do
-        ctx = mock('ctx')
-        ctx.stub!(:null? => false)
-        LibZMQ.should_receive(:zmq_init).with(1).and_return(ctx)
-        
-        Context.create
+        ctx = Context.create
+        ctx.io_threads.should == 1
       end
 
       it "should set the :pointer accessor to non-nil" do
@@ -48,17 +44,13 @@ module ZMQ
     context "when initializing with #new" do
       include APIHelper
 
-      it "should raise an error for negative io threads" do
-        LibZMQ.stub(:zmq_init => nil)
+      it "should raise a ContextError exception for negative io threads" do
         lambda { Context.new(-1) }.should raise_exception(ZMQ::ContextError)
       end
       
       it "should default to requesting 1 i/o thread when no argument is passed" do
-        ctx = mock('ctx')
-        ctx.stub!(:null? => false)
-        LibZMQ.should_receive(:zmq_init).with(1).and_return(ctx)
-        
-        Context.new
+        ctx = Context.new
+        ctx.io_threads.should == 1
       end
 
       it "should set the :pointer accessor to non-nil" do
@@ -78,16 +70,28 @@ module ZMQ
       
       it "should define a finalizer on this object" do
         ObjectSpace.should_receive(:define_finalizer)
-        ctx = Context.new 1
+        Context.new 1
       end
     end # context initializing
 
 
     context "when terminating" do
-      it "should call zmq_term to terminate the library's context" do
+      it "should set the context to nil when terminating the library's context" do
         ctx = Context.new # can't use a shared context here because we are terminating it!
-        LibZMQ.should_receive(:zmq_term).with(ctx.pointer).and_return(0)
         ctx.terminate
+        ctx.pointer.should be_nil
+      end
+      
+      it "should call the correct library function to terminate the context" do
+        ctx = Context.new
+        
+        if LibZMQ.version2?
+          LibZMQ.should_receive(:zmq_term).and_return(0)
+          ctx.terminate
+        else
+          LibZMQ.should_receive(:zmq_ctx_destroy).with(ctx.pointer).and_return(0)
+          ctx.terminate
+        end
       end
     end # context terminate
 

data/spec/device_spec.rb

@@ -1,89 +1,77 @@
 
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
-if version2?
+module ZMQ
+  describe Device do
+    include APIHelper
 
-  module ZMQ
-    describe Device do
-      include APIHelper
+    before(:all) do
+      @ctx = Context.new
+      poller_setup
+      @front_endpoint = "inproc://device_front_test"
+      @back_endpoint = "inproc://device_back_test"
+      @mutex = Mutex.new
+    end
 
-      before(:each) do
-        @ctx = Context.new
-      end
+    after(:all) do
+      @ctx.terminate
+    end
 
-      after(:each) do
-        @ctx.terminate
+    def create_streamer
+      @device_thread = false
+
+      Thread.new do
+        back  = @ctx.socket(ZMQ::PULL)
+        back.bind(@back_endpoint)
+        front = @ctx.socket(ZMQ::PUSH)
+        front.bind(@front_endpoint)
+        @mutex.synchronize { @device_thread = true }
+        Device.new(ZMQ::STREAMER, back, front)
+        back.close
+        front.close
       end
-      
-      def create_streamer
-        @backport = @frontport = nil
-        Thread.new do
-          back  = @ctx.socket(ZMQ::PULL)
-          @backport = bind_to_random_tcp_port(back)
-          front = @ctx.socket(ZMQ::PUSH)
-          @frontport = bind_to_random_tcp_port(front)
-          Device.new(ZMQ::STREAMER, back, front)
-          back.close
-          front.close
+    end
+    
+    def wait_for_device
+      loop do
+        can_break = false
+        @mutex.synchronize do
+          can_break = true if @device_thread
         end
-        sleep 0.5
-      end
-      
-      it "should create a streamer device without error given valid opts" do
-        create_streamer
+        break if can_break
       end
-      
-      it "should be able to send messages through the device" do
-        create_streamer
-      
-        pusher = @ctx.socket(ZMQ::PUSH)
-        pusher.connect("tcp://127.0.0.1:#{@backport}")
-        puller = @ctx.socket(ZMQ::PULL)
-        puller.connect("tcp://127.0.0.1:#{@frontport}")
-      
+    end
+
+    it "should create a device without error given valid opts" do
+      create_streamer
+      wait_for_device
+    end
+
+    it "should be able to send messages through the device" do
+      create_streamer
+      wait_for_device
+
+      pusher = @ctx.socket(ZMQ::PUSH)
+      connect_to_inproc(pusher, @back_endpoint)
+      puller = @ctx.socket(ZMQ::PULL)
+      connect_to_inproc(puller, @front_endpoint)
+
+      poll_it_for_read(puller) do
         pusher.send_string("hello")
-        sleep 0.5
-        res = ''
-        rc = puller.recv_string(res, ZMQ::NOBLOCK)
-        res.should == "hello"
-        
-        pusher.close
-        puller.close
-        sleep 0.5
-      end
-      
-      it "should raise an ArgumentError when trying to pass non-socket objects into the device" do
-        lambda {
-          Device.new(ZMQ::STREAMER, 1,2)
-        }.should raise_exception(ArgumentError)
-      end
-      
-      it "should be able to create a forwarder device without error" do
-        Thread.new do
-          back  = @ctx.socket(ZMQ::SUB)
-          bind_to_random_tcp_port(back)
-          front = @ctx.socket(ZMQ::PUB)
-          bind_to_random_tcp_port(front)
-          Device.new(ZMQ::FORWARDER, back, front)
-          back.close
-          front.close
-        end
-        sleep 0.5
-      end
-      
-      it "should be able to create a queue device without error" do
-        Thread.new do
-          back  = @ctx.socket(ZMQ::ROUTER)
-          bind_to_random_tcp_port(back)
-          front = @ctx.socket(ZMQ::DEALER)
-          bind_to_random_tcp_port(front)
-          Device.new(ZMQ::QUEUE, back, front)
-          back.close
-          front.close
-        end
-        sleep 0.5
       end
+
+      res = ''
+      rc = puller.recv_string(res, ZMQ::NonBlocking)
+      res.should == "hello"
+
+      pusher.close
+      puller.close
     end
-  end
 
-end # if version2?
+    it "should raise an ArgumentError when trying to pass non-socket objects into the device" do
+      lambda {
+        Device.new(ZMQ::STREAMER, 1,2)
+      }.should raise_exception(ArgumentError)
+    end
+  end
+end

data/spec/multipart_spec.rb

@@ -55,7 +55,6 @@ module ZMQ
         end
       end
 
-      if version2?
         context "with identity" do
           include APIHelper
 
@@ -104,59 +103,6 @@ module ZMQ
           end
         end
 
-      elsif LibZMQ.version3? # version3
-
-        context "with identity" do
-          include APIHelper
-
-          before(:each) do # was :all
-            @rep = Socket.new(@ctx.pointer, ZMQ::ROUTER)
-            port = bind_to_random_tcp_port(@rep)
-
-            @req = Socket.new(@ctx.pointer, ZMQ::DEALER)
-            @req.identity = 'foo'
-            @req.connect("tcp://127.0.0.1:#{port}")
-          end
-
-          after(:each) do # was :all
-            @req.close
-            @rep.close
-          end
-
-          it "should be delivered between ROUTER and DEALER returning an array of strings" do
-            req_data, rep_data = "hello", [ @req.identity, "ok" ]
-
-            @req.send_string(req_data)
-            strings = []
-            rc = @rep.recv_strings(strings)
-            strings.should == [ @req.identity, "hello" ]
-
-            @rep.send_strings(rep_data)
-            string = ''
-            rc = @req.recv_string(string)
-            string.should == rep_data.last
-          end
-
-          it "should be delivered between ROUTER and DEALER returning an array of messages" do
-            req_data, rep_data = "hello", [ @req.identity, "ok" ]
-
-            @req.send_string(req_data)
-            msgs = []
-            rc = @rep.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == @req.identity
-            msgs[1].copy_out_string.should == "hello"
-
-            @rep.send_strings(rep_data)
-            msgs = []
-            rc = @req.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == rep_data.last
-          end
-
-        end
-
-      end # if version...
-
-
     end
   end
 end

data/spec/nonblocking_recv_spec.rb

@@ -5,32 +5,26 @@ module ZMQ
 
 
   describe Socket do
-    before(:all) do
-      @ctx = Context.new
-    end
-
-    after(:all) do
-      @ctx.terminate
-    end
+    include APIHelper
 
 
     shared_examples_for "any socket" do
 
       it "returns -1 when there are no messages to read" do
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::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, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::NonBlocking)
         ZMQ::Util.errno.should == ZMQ::EAGAIN
       end
 
       it "returns the given array unmodified when there are no messages to read" do
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::NonBlocking)
         array.size.should be_zero
       end
 
@@ -39,24 +33,26 @@ module ZMQ
     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
-
+        poll_it_for_read(@receiver) do
+          rc = @sender.send_string('test')
+          Util.resultcode_ok?(rc).should be_true
+        end
+        
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::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
+        poll_it_for_read(@receiver) do
+          strings = Array.new(10, 'test')
+          rc = @sender.send_strings(strings)
+          Util.resultcode_ok?(rc).should be_true
+        end
 
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::NonBlocking)
         Util.resultcode_ok?(rc).should be_true
         array.size.should == 10
       end
@@ -66,24 +62,26 @@ module ZMQ
     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
+        poll_it_for_read(@receiver) do
+          rc = @sender.send_string('test')
+          Util.resultcode_ok?(rc).should be_true
+        end
 
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::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
+        poll_it_for_read(@receiver) do
+          strings = Array.new(10, 'test')
+          rc = @sender.send_strings(strings)
+          Util.resultcode_ok?(rc).should be_true
+        end
 
         array = []
-        rc = @receiver.recvmsgs(array, NonBlockingFlag)
+        rc = @receiver.recvmsgs(array, ZMQ::NonBlocking)
         Util.resultcode_ok?(rc).should be_true
         array.size.should == 10 + 1 # add 1 for the envelope
       end
@@ -96,21 +94,25 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::SUB
-          port = bind_to_random_tcp_port(@receiver)
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::SUB
           assert_ok(@receiver.setsockopt(ZMQ::SUBSCRIBE, ''))
-          @sender = @ctx.socket ZMQ::PUB
-          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
-          sleep 0.3
+          @sender = @context.socket ZMQ::PUB
+          @receiver.bind(endpoint)
+          connect_to_inproc(@sender, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
-        it_behaves_like "sockets without exposed envelopes"
+        #it_behaves_like "sockets without exposed envelopes" # see Jira LIBZMQ-270; fails with tcp transport
 
       end # describe 'non-blocking recvmsgs'
 
@@ -118,21 +120,26 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::SUB
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::SUB
           port = connect_to_random_tcp_port(@receiver)
           assert_ok(@receiver.setsockopt(ZMQ::SUBSCRIBE, ''))
-          @sender = @ctx.socket ZMQ::PUB
-          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
-          sleep 0.3
+          @sender = @context.socket ZMQ::PUB
+          @sender.bind(endpoint)
+          connect_to_inproc(@receiver, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
-        it_behaves_like "sockets without exposed envelopes"
+        it_behaves_like "sockets without exposed envelopes" # see Jira LIBZMQ-270; fails with tcp transport
 
       end # describe 'non-blocking recvmsgs'
 
@@ -144,16 +151,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::REP
-          port = bind_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::REQ
-          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::REP
+          @sender = @context.socket ZMQ::REQ
+          @receiver.bind(endpoint)
+          connect_to_inproc(@sender, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -165,16 +176,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::REP
-          port = connect_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::REQ
-          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::REP
+          @sender = @context.socket ZMQ::REQ
+          @sender.bind(endpoint)
+          connect_to_inproc(@receiver, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -191,16 +206,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::PULL
-          port = bind_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::PUSH
-          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::PULL
+          @sender = @context.socket ZMQ::PUSH
+          @receiver.bind(endpoint)
+          connect_to_inproc(@sender, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -212,16 +231,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::PULL
-          port = connect_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::PUSH
-          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::PULL
+          @sender = @context.socket ZMQ::PUSH
+          @sender.bind(endpoint)
+          connect_to_inproc(@receiver, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -238,16 +261,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::ROUTER
-          port = bind_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::DEALER
-          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::ROUTER
+          @sender = @context.socket ZMQ::DEALER
+          @receiver.bind(endpoint)
+          connect_to_inproc(@sender, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -259,16 +286,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::ROUTER
-          port = connect_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::DEALER
-          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::ROUTER
+          @sender = @context.socket ZMQ::DEALER
+          @sender.bind(endpoint)
+          connect_to_inproc(@receiver, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -285,16 +316,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::XREP
-          port = bind_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::XREQ
-          assert_ok(@sender.connect("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::XREP
+          @sender = @context.socket ZMQ::XREQ
+          @receiver.bind(endpoint)
+          connect_to_inproc(@sender, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"
@@ -306,16 +341,20 @@ module ZMQ
         include APIHelper
 
         before(:each) do
-          @receiver = @ctx.socket ZMQ::XREP
-          port = connect_to_random_tcp_port(@receiver)
-          @sender = @ctx.socket ZMQ::XREQ
-          assert_ok(@sender.bind("tcp://127.0.0.1:#{port}"))
-          sleep 0.1
+          @context = Context.new
+          poller_setup
+
+          endpoint = "inproc://nonblocking_test"
+          @receiver = @context.socket ZMQ::XREP
+          @sender = @context.socket ZMQ::XREQ
+          @sender.bind(endpoint)
+          connect_to_inproc(@receiver, endpoint)
         end
 
         after(:each) do
           @receiver.close
           @sender.close
+          @context.terminate
         end
 
         it_behaves_like "any socket"