ffi-rzmq 1.0.3 → 2.0.7

data/spec/socket_spec.rb

@@ -7,11 +7,8 @@ module ZMQ
   describe Socket do
     include APIHelper
 
-    socket_types = if LibZMQ.version2?
-      [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR]
-    elsif LibZMQ.version3?
+    socket_types =
       [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR, ZMQ::XPUB, ZMQ::XSUB]
-    end
 
     context "when initializing" do
       before(:all) { @ctx = Context.new }
@@ -19,21 +16,21 @@ module ZMQ
 
 
       it "should raise an error for a nil context" do
-        lambda { Socket.new(FFI::Pointer.new(0), ZMQ::REQ) }.should raise_exception(ZMQ::ContextError)
+        expect { Socket.new(FFI::Pointer.new(0), ZMQ::REQ) }.to raise_exception(ZMQ::ContextError)
       end
 
       it "works with a Context#pointer as the context_ptr" do
-        lambda do
+        expect do
           s = Socket.new(@ctx.pointer, ZMQ::REQ)
           s.close
-        end.should_not raise_exception
+        end.not_to raise_exception
       end
 
       it "works with a Context instance as the context_ptr" do
-        lambda do
+        expect do
           s = Socket.new(@ctx, ZMQ::SUB)
           s.close
-        end.should_not raise_exception
+        end.not_to raise_exception
       end
 
 
@@ -41,22 +38,22 @@ module ZMQ
 
         it "should not raise an error for a [#{ZMQ::SocketTypeNameMap[socket_type]}] socket type" do
           sock = nil
-          lambda { sock = Socket.new(@ctx.pointer, socket_type) }.should_not raise_error
+          expect { sock = Socket.new(@ctx.pointer, socket_type) }.not_to raise_error
           sock.close
         end
       end # each socket_type
 
       it "should set the :socket accessor to the raw socket allocated by libzmq" do
         socket = double('socket')
-        socket.stub(:null? => false)
-        LibZMQ.should_receive(:zmq_socket).and_return(socket)
+        allow(socket).to receive(:null?).and_return(false)
+        expect(LibZMQ).to receive(:zmq_socket).and_return(socket)
 
         sock = Socket.new(@ctx.pointer, ZMQ::REQ)
-        sock.socket.should == socket
+        expect(sock.socket).to eq(socket)
       end
 
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer).at_least(1)
+        expect(ObjectSpace).to receive(:define_finalizer).at_least(1)
         sock = Socket.new(@ctx.pointer, ZMQ::REQ)
         sock.close
       end
@@ -80,7 +77,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
         raw_socket = sock.socket
 
-        LibZMQ.should_receive(:close).with(raw_socket)
+        expect(LibZMQ).to receive(:close).with(raw_socket)
         sock.close
         sock.close
         LibZMQ.close raw_socket # *really close it otherwise the context will block indefinitely
@@ -97,7 +94,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ('a' * 256)
-        sock.identity.should == ''
+        expect(sock.identity).to eq('')
         sock.close
       end
 
@@ -105,7 +102,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ''
-        sock.identity.should == ''
+        expect(sock.identity).to eq('')
         sock.close
       end
 
@@ -113,7 +110,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = 'a'
-        sock.identity.should == 'a'
+        expect(sock.identity).to eq('a')
         sock.close
       end
 
@@ -121,7 +118,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ('a' * 255)
-        sock.identity.should == ('a' * 255)
+        expect(sock.identity).to eq('a' * 255)
         sock.close
       end
 
@@ -129,7 +126,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = 7
-        sock.identity.should == '7'
+        expect(sock.identity).to eq('7')
         sock.close
       end
     end # context identity=
@@ -160,8 +157,8 @@ module ZMQ
 
               array = []
               rc = socket.getsockopt(ZMQ::IDENTITY, array)
-              rc.should == 0
-              array[0].should == identity
+              expect(rc).to eq(0)
+              expect(array[0]).to eq(identity)
             end
           end
 
@@ -169,138 +166,63 @@ module ZMQ
             identity = 'a' * 256
             array = []
             rc = socket.setsockopt(ZMQ::IDENTITY, identity)
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::IDENTITY
 
+        context "using option ZMQ::IPV4ONLY" do
+          it "should enable use of IPV6 sockets when set to 0" do
+            value = 0
+            socket.setsockopt ZMQ::IPV4ONLY, value
+            array = []
+            rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
+          end
 
-        if version2?
-
-          context "using option ZMQ::HWM" do
-            it "should set the high water mark given a positive value" do
-              hwm = 4
-              socket.setsockopt ZMQ::HWM, hwm
-              array = []
-              rc = socket.getsockopt(ZMQ::HWM, array)
-              rc.should == 0
-              array[0].should == hwm
-            end
-          end # context using option ZMQ::HWM
-
-
-          context "using option ZMQ::SWAP" do
-            it "should set the swap value given a positive value" do
-              swap = 10_000
-              socket.setsockopt ZMQ::SWAP, swap
-              array = []
-              rc = socket.getsockopt(ZMQ::SWAP, array)
-              rc.should == 0
-              array[0].should == swap
-            end
-
-            it "returns -1 given a negative value" do
-              swap = -10_000
-              rc = socket.setsockopt(ZMQ::SWAP, swap)
-              rc.should == -1
-            end
-          end # context using option ZMQ::SWP
-
-
-          context "using option ZMQ::MCAST_LOOP" do
-            it "should enable the multicast loopback given a 1 (true) value" do
-              socket.setsockopt ZMQ::MCAST_LOOP, 1
-              array = []
-              rc = socket.getsockopt(ZMQ::MCAST_LOOP, array)
-              rc.should == 0
-              array[0].should be_true
-            end
-
-            it "should disable the multicast loopback given a 0 (false) value" do
-              socket.setsockopt ZMQ::MCAST_LOOP, 0
-              array = []
-              rc = socket.getsockopt(ZMQ::MCAST_LOOP, array)
-              rc.should == 0
-              array[0].should be_false
-            end
-          end # context using option ZMQ::MCAST_LOOP
-
-
-          context "using option ZMQ::RECOVERY_IVL_MSEC" do
-            it "should set the time interval for saving messages measured in milliseconds given a positive value" do
-              value = 200
-              socket.setsockopt ZMQ::RECOVERY_IVL_MSEC, value
-              array = []
-              rc = socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "should default to a value of -1" do
-              value = -1
-              array = []
-              rc = socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC, array)
-              rc.should == 0
-              array[0].should == value
-            end
-          end # context using option ZMQ::RECOVERY_IVL_MSEC
-
-        else # version3 or higher
-
-          context "using option ZMQ::IPV4ONLY" do
-            it "should enable use of IPV6 sockets when set to 0" do
-              value = 0
-              socket.setsockopt ZMQ::IPV4ONLY, value
-              array = []
-              rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "should default to a value of 1" do
-              value = 1
-              array = []
-              rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "returns -1 given a negative value" do
-              value = -1
-              rc = socket.setsockopt ZMQ::IPV4ONLY, value
-              rc.should == -1
-            end
+          it "should default to a value of 1" do
+            value = 1
+            array = []
+            rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
+          end
 
-            it "returns -1 given a value > 1" do
-              value = 2
-              rc = socket.setsockopt ZMQ::IPV4ONLY, value
-              rc.should == -1
-            end
-          end # context using option ZMQ::IPV4ONLY
+          it "returns -1 given a negative value" do
+            value = -1
+            rc = socket.setsockopt ZMQ::IPV4ONLY, value
+            expect(rc).to eq(-1)
+          end
 
-          context "using option ZMQ::LAST_ENDPOINT" do
-            it "should return last enpoint" do
-              random_port = bind_to_random_tcp_port(socket, max_tries = 500)
-              array = []
-              rc = socket.getsockopt(ZMQ::LAST_ENDPOINT, array)
-              ZMQ::Util.resultcode_ok?(rc).should == true
-              endpoint_regex = %r{\Atcp://(.*):(\d+)\0\z}
-              array[0].should =~ endpoint_regex
-              Integer(array[0][endpoint_regex, 2]).should == random_port
-            end
+          it "returns -1 given a value > 1" do
+            value = 2
+            rc = socket.setsockopt ZMQ::IPV4ONLY, value
+            expect(rc).to eq(-1)
           end
-        end # version2? if/else block
+        end # context using option ZMQ::IPV4ONLY
 
+        context "using option ZMQ::LAST_ENDPOINT" do
+          it "should return last enpoint" do
+            random_port = bind_to_random_tcp_port(socket, max_tries = 500)
+            array = []
+            rc = socket.getsockopt(ZMQ::LAST_ENDPOINT, array)
+            expect(ZMQ::Util.resultcode_ok?(rc)).to eq(true)
+            endpoint_regex = %r{\Atcp://(.*):(\d+)\0\z}
+            expect(array[0]).to match(endpoint_regex)
+            expect(Integer(array[0][endpoint_regex, 2])).to eq(random_port)
+          end
+        end
 
         context "using option ZMQ::SUBSCRIBE" do
           if ZMQ::SUB == socket_type
             it "returns 0 for a SUB socket" do
               rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
-              rc.should == 0
+              expect(rc).to eq(0)
             end
           else
             it "returns -1 for non-SUB sockets" do
               rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
-              rc.should == -1
+              expect(rc).to eq(-1)
             end
           end
         end # context using option ZMQ::SUBSCRIBE
@@ -311,13 +233,13 @@ module ZMQ
             it "returns 0 given a topic string that was previously subscribed" do
               socket.setsockopt ZMQ::SUBSCRIBE, "topic.string"
               rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
-              rc.should == 0
+              expect(rc).to eq(0)
             end
 
           else
             it "returns -1 for non-SUB sockets" do
               rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
-              rc.should == -1
+              expect(rc).to eq(-1)
             end
           end
         end # context using option ZMQ::UNSUBSCRIBE
@@ -329,8 +251,8 @@ module ZMQ
             socket.setsockopt ZMQ::AFFINITY, affinity
             array = []
             rc = socket.getsockopt(ZMQ::AFFINITY, array)
-            rc.should == 0
-            array[0].should == affinity
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(affinity)
           end
         end # context using option ZMQ::AFFINITY
 
@@ -341,14 +263,14 @@ module ZMQ
             socket.setsockopt ZMQ::RATE, rate
             array = []
             rc = socket.getsockopt(ZMQ::RATE, array)
-            rc.should == 0
-            array[0].should == rate
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(rate)
           end
 
           it "returns -1 given a negative value" do
             rate = -200
             rc = socket.setsockopt ZMQ::RATE, rate
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::RATE
 
@@ -359,14 +281,14 @@ module ZMQ
             socket.setsockopt ZMQ::RECOVERY_IVL, rate
             array = []
             rc = socket.getsockopt(ZMQ::RECOVERY_IVL, array)
-            rc.should == 0
-            array[0].should == rate
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(rate)
           end
 
           it "returns -1 given a negative value" do
             rate = -200
             rc = socket.setsockopt ZMQ::RECOVERY_IVL, rate
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::RECOVERY_IVL
 
@@ -377,8 +299,8 @@ module ZMQ
             socket.setsockopt ZMQ::SNDBUF, size
             array = []
             rc = socket.getsockopt(ZMQ::SNDBUF, array)
-            rc.should == 0
-            array[0].should == size
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(size)
           end
         end # context using option ZMQ::SNDBUF
 
@@ -389,8 +311,8 @@ module ZMQ
             socket.setsockopt ZMQ::RCVBUF, size
             array = []
             rc = socket.getsockopt(ZMQ::RCVBUF, array)
-            rc.should == 0
-            array[0].should == size
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(size)
           end
         end # context using option ZMQ::RCVBUF
 
@@ -401,8 +323,8 @@ module ZMQ
             socket.setsockopt ZMQ::LINGER, value
             array = []
             rc = socket.getsockopt(ZMQ::LINGER, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should set the socket message linger option to 0 for dropping packets" do
@@ -410,27 +332,17 @@ module ZMQ
             socket.setsockopt ZMQ::LINGER, value
             array = []
             rc = socket.getsockopt(ZMQ::LINGER, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
-          if (ZMQ::SUB == socket_type) && version3? || (defined?(ZMQ::XSUB) && ZMQ::XSUB == socket_type)
             it "should default to a value of 0" do
-              value = 0
-              array = []
-              rc = socket.getsockopt(ZMQ::LINGER, array)
-              rc.should == 0
-              array[0].should == value
-            end
-          else
-            it "should default to a value of -1" do
-              value = -1
+              value = [SUB, XSUB].include?(socket_type) ? 0 : -1
               array = []
               rc = socket.getsockopt(ZMQ::LINGER, array)
-              rc.should == 0
-              array[0].should == value
+              expect(rc).to eq(0)
+              expect(array[0]).to eq(value)
             end
-          end
         end # context using option ZMQ::LINGER
 
 
@@ -440,16 +352,16 @@ module ZMQ
             socket.setsockopt ZMQ::RECONNECT_IVL, value
             array = []
             rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should default to a value of 100" do
             value = 100
             array = []
             rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
         end # context using option ZMQ::RECONNECT_IVL
 
@@ -457,19 +369,20 @@ module ZMQ
         context "using option ZMQ::BACKLOG" do
           it "should set the maximum number of pending socket connections given a positive value" do
             value = 200
-            socket.setsockopt ZMQ::BACKLOG, value
+            rc = socket.setsockopt ZMQ::BACKLOG, value
+            expect(rc).to eq(0)
             array = []
             rc = socket.getsockopt(ZMQ::BACKLOG, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should default to a value of 100" do
             value = 100
             array = []
             rc = socket.getsockopt(ZMQ::BACKLOG, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
         end # context using option ZMQ::BACKLOG
 
@@ -495,8 +408,8 @@ module ZMQ
             it "should return an FD as a positive integer" do
               array = []
               rc = socket.getsockopt(ZMQ::FD, array)
-              rc.should == 0
-              array[0].should > 0
+              expect(rc).to eq(0)
+              expect(array[0]).to be > 0
             end
 
             it "returns a valid FD that is accepted by the system poll() function" do
@@ -514,14 +427,14 @@ module ZMQ
 
                 class PollFD < FFI::Struct
                   layout :fd,    :int,
-                  :events, :short,
-                  :revents, :short
+                    :events, :short,
+                    :revents, :short
                 end
               end # module LibSocket
 
               array = []
               rc = socket.getsockopt(ZMQ::FD, array)
-              rc.should be_zero
+              expect(rc).to eq(0)
               fd = array[0]
 
               # setup the BSD poll_fd struct
@@ -531,18 +444,18 @@ module ZMQ
               pollfd[:revents] = 0
 
               rc = LibSocket.poll(pollfd, 1, 0)
-              rc.should be_zero
+              expect(rc).to eq(0)
             end
           end
 
         end # posix platform
 
         context "using option ZMQ::EVENTS" do
-          it "should return a mask of events as a Fixnum" do
+          it "should return a mask of events as an Integer" do
             array = []
             rc = socket.getsockopt(ZMQ::EVENTS, array)
-            rc.should == 0
-            array[0].should be_a(Fixnum)
+            expect(rc).to eq(0)
+            expect(array[0]).to be_a(Integer)
           end
         end
 
@@ -550,8 +463,8 @@ module ZMQ
           it "should return the socket type" do
             array = []
             rc = socket.getsockopt(ZMQ::TYPE, array)
-            rc.should == 0
-            array[0].should == socket_type
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(socket_type)
           end
         end
       end # context #getsockopt
@@ -566,29 +479,29 @@ module ZMQ
         it "SUB socket that received a message always has POLLIN set" do
           events = []
           rc = @sub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should == ZMQ::POLLIN
+          expect(rc).to eq(0)
+          expect(events[0]).to eq ZMQ::POLLIN
         end
 
         it "PUB socket always has POLLOUT set" do
           events = []
           rc = @pub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should == ZMQ::POLLOUT
+          expect(rc).to eq(0)
+          expect(events[0]).to eq ZMQ::POLLOUT
         end
 
         it "PUB socket never has POLLIN set" do
           events = []
           rc = @pub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should_not == ZMQ::POLLIN
+          expect(rc).to eq(0)
+          expect(events[0]).not_to eq ZMQ::POLLIN
         end
 
         it "SUB socket never has POLLOUT set" do
           events = []
           rc = @sub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should_not == ZMQ::POLLOUT
+          expect(rc).to eq(0)
+          expect(events[0]).not_to eq ZMQ::POLLOUT
         end
       end # shared example for pubsub
 
@@ -601,7 +514,7 @@ module ZMQ
           endpoint = "inproc://socket_test"
           @sub = @ctx.socket ZMQ::SUB
           rc = @sub.setsockopt ZMQ::SUBSCRIBE, ''
-          rc.should == 0
+          expect(rc).to eq(0)
 
           @pub = @ctx.socket ZMQ::PUB
           @sub.bind(endpoint)

data/spec/spec_helper.rb

@@ -1,11 +1,7 @@
-# To run these specs using rake, make sure the 'bones' and 'bones-extras'
-# gems are installed. Then execute 'rake spec' from the main directory
-# to run all specs.
 
 require File.expand_path(
 File.join(File.dirname(__FILE__), %w[.. lib ffi-rzmq]))
 
-require 'thread' # necessary when testing in MRI 1.8 mode
 Thread.abort_on_exception = true
 
 require 'openssl'
@@ -14,12 +10,8 @@ require 'securerandom'
 
 # define some version guards so we can turn on/off specs based upon
 # the version of the 0mq library that is loaded
-def version2?
-  ZMQ::LibZMQ.version2?
-end
-
-def version3?
-  ZMQ::LibZMQ.version3?
+def version4?
+  ZMQ::LibZMQ.version4?
 end
 
 def jruby?
@@ -35,7 +27,7 @@ end
 
 module APIHelper
   def poller_setup
-    @helper_poller ||= ZMQ::Poller.new
+    @helper_poller = ZMQ::Poller.new
   end
 
   def poller_register_socket(socket)

data/spec/support/generate_keys_and_certs.rb

@@ -0,0 +1,41 @@
+# Copied from Debian:
+# https://salsa.debian.org/ruby-team/ruby-ffi-rzmq/commit/15ad9dd6f4c3358acbd7db2c7e288aae2d5efcf8
+#
+# Script should be run from the spec/support directory.
+#
+
+require "openssl"
+
+key = OpenSSL::PKey::RSA.new 4096
+
+open 'private_key.pem', 'w' do |io| io.write key.to_pem end
+open 'public_key.pem', 'w' do |io| io.write key.public_key.to_pem end
+
+
+name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example'
+
+cert = OpenSSL::X509::Certificate.new
+cert.version = 2
+cert.serial = 0
+cert.not_before = Time.now
+cert.not_after = Time.now + 3600*24*365*10
+
+cert.public_key = key.public_key
+cert.subject = name
+cert.issuer = name
+
+extension_factory = OpenSSL::X509::ExtensionFactory.new
+extension_factory.subject_certificate = cert
+extension_factory.issuer_certificate = cert
+
+cert.add_extension \
+  extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+cert.sign key, OpenSSL::Digest::SHA1.new
+open 'ca.pem', 'w' do |io|
+  io.write cert.to_pem
+end
+
+require 'fileutils'
+
+FileUtils.cp 'ca.pem',         'test.crt'
+FileUtils.cp 'private_key.pem', 'test.key'