protobuffy 3.6.0 → 4.0.0

data/spec/functional/code_generator_spec.rb

@@ -0,0 +1,38 @@
+# encoding: binary
+
+require 'spec_helper'
+require 'protobuf/code_generator'
+
+RSpec.describe 'code generation' do
+  it "generates code for google's unittest.proto" do
+    bytes = IO.read(PROTOS_PATH.join('google_unittest.bin'), :mode => 'rb')
+
+    expected_files =
+      ["google_unittest_import_public.pb.rb", "google_unittest_import.pb.rb", "google_unittest.pb.rb"]
+
+    expected_file_descriptors = expected_files.map do |file_name|
+      file_content = File.open(PROTOS_PATH.join(file_name), "r:UTF-8", &:read)
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
+        :name => "protos/" + file_name, :content => file_content)
+    end
+
+    expected_output =
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse.encode(:file => expected_file_descriptors)
+
+    code_generator = ::Protobuf::CodeGenerator.new(bytes)
+    code_generator.eval_unknown_extensions!
+    expect(code_generator.response_bytes).to eq(expected_output)
+  end
+
+  it "generates code (including service stubs) with custom field and method options" do
+    expected_unittest_custom_options =
+      File.open(PROTOS_PATH.join('google_unittest_custom_options.pb.rb'), "r:UTF-8", &:read)
+
+    bytes = IO.read(PROTOS_PATH.join('google_unittest_custom_options.bin'), :mode => 'rb')
+    code_generator = ::Protobuf::CodeGenerator.new(bytes)
+    code_generator.eval_unknown_extensions!
+    response = ::Google::Protobuf::Compiler::CodeGeneratorResponse.decode(code_generator.response_bytes)
+    expect(response.file.find { |f| f.name == 'protos/google_unittest_custom_options.pb.rb' }.content)
+      .to eq(expected_unittest_custom_options)
+  end
+end

data/spec/functional/socket_server_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
-require 'spec/support/test/resource_service'
+require SUPPORT_PATH.join('resource_service')
 
-describe 'Functional Socket Client' do
+RSpec.describe 'Functional Socket Client' do
   before(:all) do
     load "protobuf/socket.rb"
     @options = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
     @runner = ::Protobuf::Rpc::SocketRunner.new(@options)
-    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    @server_thread = Thread.new(@runner, &:run)
     Thread.pass until @runner.running?
   end
 
@@ -16,20 +16,20 @@ describe 'Functional Socket Client' do
   end
 
   it 'runs fine when required fields are set' do
-    expect {
+    expect do
       client = ::Test::ResourceService.client
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
-          succ.name.should eq("Test Name")
-          succ.status.should eq(::Test::StatusType::ENABLED)
+          expect(succ.name).to eq("Test Name")
+          expect(succ.status).to eq(::Test::StatusType::ENABLED)
         end
 
         c.on_failure do |err|
-          raise err.inspect
+          fail err.inspect
         end
       end
-    }.to_not raise_error
+    end.to_not raise_error
   end
 
   it 'calls the on_failure callback when a message is malformed' do
@@ -38,10 +38,11 @@ describe 'Functional Socket Client' do
     client = ::Test::ResourceService.client
 
     client.find(request) do |c|
-      c.on_success { raise "shouldn't pass"}
-      c.on_failure {|e| error = e}
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
     end
-    error.message.should =~ /name.*required/
+
+    expect(error.message).to match(/Required field.*does not have a value/)
   end
 
   it 'calls the on_failure callback when the request type is wrong' do
@@ -50,10 +51,9 @@ describe 'Functional Socket Client' do
     client = ::Test::ResourceService.client
 
     client.find(request) do |c|
-      c.on_success { raise "shouldn't pass"}
-      c.on_failure {|e| error = e}
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
     end
-    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
+    expect(error.message).to match(/expected request.*ResourceFindRequest.*Resource instead/i)
   end
 end
-

data/spec/functional/zmq_server_spec.rb

@@ -1,18 +1,20 @@
 require 'spec_helper'
 
-require 'spec/support/test/resource_service'
 require 'protobuf/rpc/service_directory'
+require SUPPORT_PATH.join('resource_service')
 
-describe 'Functional ZMQ Client' do
+RSpec.describe 'Functional ZMQ Client' do
   before(:all) do
     load "protobuf/zmq.rb"
-    @runner = ::Protobuf::Rpc::ZmqRunner.new({ :host => "127.0.0.1",
-                                               :port => 9399,
-                                               :worker_port => 9408,
-                                               :backlog => 100,
-                                               :threshold => 100,
-                                               :threads => 5 })
-    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    @runner = ::Protobuf::Rpc::ZmqRunner.new(
+      'host' => '127.0.0.1',
+      'port' => 9399,
+      'worker_port' => 9408,
+      'backlog' => 100,
+      'threshold' => 100,
+      'threads' => 5
+    )
+    @server_thread = Thread.new(@runner, &:run)
     Thread.pass until @runner.running?
   end
 
@@ -22,36 +24,36 @@ describe 'Functional ZMQ Client' do
   end
 
   it 'runs fine when required fields are set' do
-    expect {
+    expect do
       client = ::Test::ResourceService.client
 
       client.find(:name => 'Test Name', :active => true) do |c|
         c.on_success do |succ|
-          succ.name.should eq("Test Name")
-          succ.status.should eq(::Test::StatusType::ENABLED)
+          expect(succ.name).to eq("Test Name")
+          expect(succ.status).to eq(::Test::StatusType::ENABLED)
         end
 
         c.on_failure do |err|
-          raise err.inspect
+          fail err.inspect
         end
       end
-    }.to_not raise_error
+    end.to_not raise_error
   end
 
   it 'runs under heavy load' do
-    10.times do |x|
-      5.times.map do |y|
+    10.times do
+      5.times.map do
         Thread.new do
           client = ::Test::ResourceService.client
 
           client.find(:name => 'Test Name', :active => true) do |c|
             c.on_success do |succ|
-              succ.name.should eq("Test Name")
-              succ.status.should eq(::Test::StatusType::ENABLED)
+              expect(succ.name).to eq("Test Name")
+              expect(succ.status).to eq(::Test::StatusType::ENABLED)
             end
 
             c.on_failure do |err|
-              raise err.inspect
+              fail err.inspect
             end
           end
         end
@@ -66,10 +68,10 @@ describe 'Functional ZMQ Client' do
       client = ::Test::ResourceService.client
 
       client.find(request) do |c|
-        c.on_success { raise "shouldn't pass" }
-        c.on_failure {|e| error = e }
+        c.on_success { fail "shouldn't pass" }
+        c.on_failure { |e| error = e }
       end
-      error.message.should match(/name.*required/)
+      expect(error.message).to match(/Required field.*does not have a value/)
     end
   end
 
@@ -80,10 +82,10 @@ describe 'Functional ZMQ Client' do
       client = ::Test::ResourceService.client
 
       client.find(request) do |c|
-        c.on_success { raise "shouldn't pass" }
-        c.on_failure {|e| error = e}
+        c.on_success { fail "shouldn't pass" }
+        c.on_failure { |e| error = e }
       end
-      error.message.should match(/expected request.*ResourceFindRequest.*Resource instead/i)
+      expect(error.message).to match(/expected request.*ResourceFindRequest.*Resource instead/i)
     end
   end
 
@@ -93,10 +95,10 @@ describe 'Functional ZMQ Client' do
       client = ::Test::ResourceService.client(:timeout => 1)
 
       client.find_with_sleep(:sleep => 2) do |c|
-        c.on_success { raise "shouldn't pass" }
+        c.on_success { fail "shouldn't pass" }
         c.on_failure { |e| error = e }
       end
-      error.message.should match(/The server repeatedly failed to respond/)
+      expect(error.message).to match(/The server repeatedly failed to respond/)
     end
   end
 

data/spec/lib/protobuf/cli_spec.rb

@@ -1,96 +1,102 @@
 require 'spec_helper'
 require 'protobuf/cli'
 
-describe ::Protobuf::CLI do
+RSpec.describe ::Protobuf::CLI do
 
   let(:app_file) do
     File.expand_path('../../../support/test_app_file.rb', __FILE__)
   end
 
-  let(:sock_runner) {
+  let(:sock_runner) do
     runner = double("SocketRunner", :register_signals => nil)
-    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
+    allow(runner).to receive(:run).and_return(::ActiveSupport::Notifications.publish("after_server_bind"))
     runner
-  }
+  end
 
-  let(:zmq_runner) {
-    runner = double "ZmqRunner", register_signals: nil
-    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
+  let(:zmq_runner) do
+    runner = double("ZmqRunner", :register_signals => nil)
+    allow(runner).to receive(:run).and_return(::ActiveSupport::Notifications.publish("after_server_bind"))
     runner
-  }
+  end
+
+  around(:each) do |example|
+    logger = ::Protobuf::Logging.logger
+    example.run
+    ::Protobuf::Logging.logger = logger
+  end
 
   before(:each) do
-    ::Protobuf::Rpc::SocketRunner.stub(:new) { sock_runner }
-    ::Protobuf::Rpc::ZmqRunner.stub(:new) { zmq_runner }
+    allow(::Protobuf::Rpc::SocketRunner).to receive(:new).and_return(sock_runner)
+    allow(::Protobuf::Rpc::ZmqRunner).to receive(:new).and_return(zmq_runner)
   end
 
   describe '#start' do
-    let(:base_args) { [ 'start', app_file ] }
+    let(:base_args) { ['start', app_file] }
     let(:test_args) { [] }
     let(:args) { base_args + test_args }
 
     context 'host option' do
-      let(:test_args) { [ '--host=123.123.123.123' ] }
+      let(:test_args) { ['--host=123.123.123.123'] }
 
       it 'sends the host option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
-          options[:host].should eq '123.123.123.123'
+        expect(::Protobuf::Rpc::SocketRunner).to receive(:new) do |options|
+          expect(options[:host]).to eq '123.123.123.123'
         end.and_return(sock_runner)
         described_class.start(args)
       end
     end
 
     context 'port option' do
-      let(:test_args) { [ '--port=12345' ] }
+      let(:test_args) { ['--port=12345'] }
 
       it 'sends the port option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
-          options[:port].should eq 12345
+        expect(::Protobuf::Rpc::SocketRunner).to receive(:new) do |options|
+          expect(options[:port]).to eq 12345
         end.and_return(sock_runner)
         described_class.start(args)
       end
     end
 
     context 'threads option' do
-      let(:test_args) { [ '--threads=500' ] }
+      let(:test_args) { ['--threads=500'] }
 
       it 'sends the threads option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
-          options[:threads].should eq 500
+        expect(::Protobuf::Rpc::SocketRunner).to receive(:new) do |options|
+          expect(options[:threads]).to eq 500
         end.and_return(sock_runner)
         described_class.start(args)
       end
     end
 
     context 'backlog option' do
-      let(:test_args) { [ '--backlog=500' ] }
+      let(:test_args) { ['--backlog=500'] }
 
       it 'sends the backlog option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
-          options[:backlog].should eq 500
+        expect(::Protobuf::Rpc::SocketRunner).to receive(:new) do |options|
+          expect(options[:backlog]).to eq 500
         end.and_return(sock_runner)
         described_class.start(args)
       end
     end
 
     context 'threshold option' do
-      let(:test_args) { [ '--threshold=500' ] }
+      let(:test_args) { ['--threshold=500'] }
 
       it 'sends the backlog option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
-          options[:threshold].should eq 500
+        expect(::Protobuf::Rpc::SocketRunner).to receive(:new) do |options|
+          expect(options[:threshold]).to eq 500
         end.and_return(sock_runner)
         described_class.start(args)
       end
     end
 
     context 'log options' do
-      let(:test_args) { [ '--log=mylog.log', '--level=0' ] }
+      let(:test_args) { ['--log=mylog.log', '--level=0'] }
 
       it 'sends the log file and level options to the runner' do
-        ::Protobuf::Logger.should_receive(:configure) do |options|
-          options[:file].should eq 'mylog.log'
-          options[:level].should eq 0
+        expect(::Protobuf::Logging).to receive(:initialize_logger) do |file, level|
+          expect(file).to eq 'mylog.log'
+          expect(level).to eq 0
         end
         described_class.start(args)
       end
@@ -103,17 +109,17 @@ describe ::Protobuf::CLI do
 
         it 'sets both request and serialization pausing to false' do
           described_class.start(args)
-          ::Protobuf.should_not be_gc_pause_server_request
+          expect(::Protobuf).to_not be_gc_pause_server_request
         end
       end
 
       unless defined?(JRUBY_VERSION)
         context 'request pausing' do
-          let(:test_args) { [ '--gc_pause_request' ] }
+          let(:test_args) { ['--gc_pause_request'] }
 
           it 'sets the configuration option to GC pause server request' do
             described_class.start(args)
-            ::Protobuf.should be_gc_pause_server_request
+            expect(::Protobuf).to be_gc_pause_server_request
           end
         end
       end
@@ -128,7 +134,7 @@ describe ::Protobuf::CLI do
 
           it 'sets the deprecation warning flag to true' do
             described_class.start(args)
-            ::Protobuf.print_deprecation_warnings?.should be_true
+            expect(::Protobuf.print_deprecation_warnings?).to be true
           end
         end
 
@@ -138,69 +144,83 @@ describe ::Protobuf::CLI do
 
           it 'sets the deprecation warning flag to false ' do
             described_class.start(args)
-            ::Protobuf.print_deprecation_warnings?.should be_false
+            expect(::Protobuf.print_deprecation_warnings?).to be false
           end
         end
       end
 
       context 'when enabled' do
-        let(:test_args) { [ '--print_deprecation_warnings' ] }
+        let(:test_args) { ['--print_deprecation_warnings'] }
 
         it 'sets the deprecation warning flag to true' do
           described_class.start(args)
-          ::Protobuf.print_deprecation_warnings?.should be_true
+          expect(::Protobuf.print_deprecation_warnings?).to be true
         end
       end
 
       context 'when disabled' do
-        let(:test_args) { [ '--no-print_deprecation_warnings' ] }
+        let(:test_args) { ['--no-print_deprecation_warnings'] }
 
         it 'sets the deprecation warning flag to false' do
           described_class.start(args)
-          ::Protobuf.print_deprecation_warnings?.should be_false
+          expect(::Protobuf.print_deprecation_warnings?).to be false
         end
       end
     end
 
     context 'run modes' do
 
+      context "extension" do
+        let(:runner) { ::Protobuf::Rpc::Servers::SocketRunner }
+
+        it "loads the runner specified by PB_SERVER_TYPE" do
+          ENV['PB_SERVER_TYPE'] = "protobuf/rpc/servers/socket_runner"
+          expect(runner).to receive(:new).and_return(sock_runner)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
+
+        context "without extension loaded" do
+          it "will throw a LoadError when extension is not loaded" do
+            ENV['PB_SERVER_TYPE'] = "socket_to_load"
+            expect { described_class.start(args) }.to raise_error(LoadError, /socket_to_load/)
+            ENV.delete("PB_SERVER_TYPE")
+          end
+        end
+      end
+
       context 'socket' do
-        let(:test_args) { [ '--socket' ] }
+        let(:test_args) { ['--socket'] }
         let(:runner) { ::Protobuf::Rpc::SocketRunner }
 
         before do
-          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
+          expect(::Protobuf::Rpc::ZmqRunner).not_to receive(:new)
         end
 
         it 'is activated by the --socket switch' do
-          runner.should_receive(:new)
+          expect(runner).to receive(:new)
           described_class.start(args)
         end
 
         it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do
           ENV['PB_SERVER_TYPE'] = "Socket"
-          runner.should_receive(:new).and_return(sock_runner)
+          expect(runner).to receive(:new).and_return(sock_runner)
           described_class.start(args)
           ENV.delete('PB_SERVER_TYPE')
         end
-
-        it 'configures the connector type to be socket' do
-          load "protobuf/socket.rb"
-          ::Protobuf.connector_type.should == :socket
-        end
       end
 
       context 'zmq workers only' do
-        let(:test_args) { [ '--workers_only', '--zmq' ] }
+        let(:test_args) { ['--workers_only', '--zmq'] }
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
         end
 
         it 'is activated by the --workers_only switch' do
-          runner.should_receive(:new) do |options|
-            options[:workers_only].should be_true
+          expect(runner).to receive(:new) do |options|
+            expect(options[:workers_only]).to be true
           end.and_return(zmq_runner)
 
           described_class.start(args)
@@ -208,8 +228,8 @@ describe ::Protobuf::CLI do
 
         it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do
           ENV['PB_WORKERS_ONLY'] = "1"
-          runner.should_receive(:new) do |options|
-            options[:workers_only].should be_true
+          expect(runner).to receive(:new) do |options|
+            expect(options[:workers_only]).to be true
           end.and_return(zmq_runner)
 
           described_class.start(args)
@@ -218,16 +238,16 @@ describe ::Protobuf::CLI do
       end
 
       context 'zmq worker port' do
-        let(:test_args) { [ '--worker_port=1234', '--zmq' ] }
+        let(:test_args) { ['--worker_port=1234', '--zmq'] }
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
         end
 
         it 'is activated by the --worker_port switch' do
-          runner.should_receive(:new) do |options|
-            options[:worker_port].should eq(1234)
+          expect(runner).to receive(:new) do |options|
+            expect(options[:worker_port]).to eq(1234)
           end.and_return(zmq_runner)
 
           described_class.start(args)
@@ -235,29 +255,24 @@ describe ::Protobuf::CLI do
       end
 
       context 'zmq' do
-        let(:test_args) { [ '--zmq' ] }
+        let(:test_args) { ['--zmq'] }
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
         end
 
         it 'is activated by the --zmq switch' do
-          runner.should_receive(:new)
+          expect(runner).to receive(:new)
           described_class.start(args)
         end
 
         it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do
           ENV['PB_SERVER_TYPE'] = "Zmq"
-          runner.should_receive(:new)
+          expect(runner).to receive(:new)
           described_class.start(args)
           ENV.delete('PB_SERVER_TYPE')
         end
-
-        it 'configures the connector type to be zmq' do
-          load "protobuf/zmq.rb"
-          ::Protobuf.connector_type.should == :zmq
-        end
       end
 
     end