protobuf-cucumber 3.10.4

data/spec/functional/code_generator_spec.rb

@@ -0,0 +1,58 @@
+# 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 for map types" do
+    input_descriptor = ::Google::Protobuf::FileDescriptorSet.decode(
+      IO.read(PROTOS_PATH.join('map-test.bin'), :mode => 'rb'))
+    request = ::Google::Protobuf::Compiler::CodeGeneratorRequest.new(:file_to_generate => ['map-test.proto'],
+                                                                     :proto_file => input_descriptor.file)
+
+    file_name = "map-test.pb.rb"
+    file_content = File.open(PROTOS_PATH.join(file_name), "r:UTF-8", &:read)
+    expected_file_output =
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(
+        :name => file_name, :content => file_content)
+
+    expected_response =
+      ::Google::Protobuf::Compiler::CodeGeneratorResponse.encode(:file => [expected_file_output])
+
+    code_generator = ::Protobuf::CodeGenerator.new(request.encode)
+    code_generator.eval_unknown_extensions!
+    expect(code_generator.response_bytes).to eq(expected_response)
+  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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require SUPPORT_PATH.join('resource_service')
+
+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, &:run)
+    Thread.pass until @runner.running?
+  end
+
+  after(:all) do
+    @runner.stop
+    @server_thread.join
+  end
+
+  it 'runs fine when required fields are set' do
+    expect do
+      client = ::Test::ResourceService.client
+
+      client.find(:name => 'Test Name', :active => true) do |c|
+        c.on_success do |succ|
+          expect(succ.name).to eq("Test Name")
+          expect(succ.status).to eq(::Test::StatusType::ENABLED)
+        end
+
+        c.on_failure do |err|
+          fail err.inspect
+        end
+      end
+    end.to_not raise_error
+  end
+
+  it 'calls the on_failure callback when a message is malformed' do
+    error = nil
+    request = ::Test::ResourceFindRequest.new(:active => true)
+    client = ::Test::ResourceService.client
+
+    client.find(request) do |c|
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
+    end
+
+    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
+    error = nil
+    request = ::Test::Resource.new(:name => 'Test Name')
+    client = ::Test::ResourceService.client
+
+    client.find(request) do |c|
+      c.on_success { fail "shouldn't pass" }
+      c.on_failure { |e| error = e }
+    end
+    expect(error.message).to match(/expected request.*ResourceFindRequest.*Resource instead/i)
+  end
+end

data/spec/functional/zmq_server_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+require 'protobuf/rpc/service_directory'
+require SUPPORT_PATH.join('resource_service')
+
+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, &:run)
+    Thread.pass until @runner.running?
+  end
+
+  after(:all) do
+    @runner.stop
+    @server_thread.join
+  end
+
+  it 'runs fine when required fields are set' do
+    expect do
+      client = ::Test::ResourceService.client
+
+      client.find(:name => 'Test Name', :active => true) do |c|
+        c.on_success do |succ|
+          expect(succ.name).to eq("Test Name")
+          expect(succ.status).to eq(::Test::StatusType::ENABLED)
+        end
+
+        c.on_failure do |err|
+          fail err.inspect
+        end
+      end
+    end.to_not raise_error
+  end
+
+  it 'runs under heavy load' do
+    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|
+              expect(succ.name).to eq("Test Name")
+              expect(succ.status).to eq(::Test::StatusType::ENABLED)
+            end
+
+            c.on_failure do |err|
+              fail err.inspect
+            end
+          end
+        end
+      end.each(&:join)
+    end
+  end
+
+  context 'when a message is malformed' do
+    it 'calls the on_failure callback' do
+      error = nil
+      request = ::Test::ResourceFindRequest.new(:active => true)
+      client = ::Test::ResourceService.client
+
+      client.find(request) do |c|
+        c.on_success { fail "shouldn't pass" }
+        c.on_failure { |e| error = e }
+      end
+      expect(error.message).to match(/Required field.*does not have a value/)
+    end
+  end
+
+  context 'when the request type is wrong' do
+    it 'calls the on_failure callback' do
+      error = nil
+      request = ::Test::Resource.new(:name => 'Test Name')
+      client = ::Test::ResourceService.client
+
+      client.find(request) do |c|
+        c.on_success { fail "shouldn't pass" }
+        c.on_failure { |e| error = e }
+      end
+      expect(error.message).to match(/expected request.*ResourceFindRequest.*Resource instead/i)
+    end
+  end
+
+  context 'when the server takes too long to respond' do
+    it 'responds with a timeout error' do
+      error = nil
+      client = ::Test::ResourceService.client(:timeout => 1)
+
+      client.find_with_sleep(:sleep => 2) do |c|
+        c.on_success { fail "shouldn't pass" }
+        c.on_failure { |e| error = e }
+      end
+      expect(error.message).to match(/The server repeatedly failed to respond/)
+    end
+  end
+
+end

data/spec/lib/protobuf/cli_spec.rb

@@ -0,0 +1,317 @@
+require 'spec_helper'
+require 'protobuf/cli'
+
+RSpec.describe ::Protobuf::CLI do
+
+  let(:app_file) do
+    File.expand_path('../../../support/test_app_file.rb', __FILE__)
+  end
+
+  let(:sock_runner) do
+    runner = double("SocketRunner", :register_signals => nil)
+    allow(runner).to receive(:run).and_return(::ActiveSupport::Notifications.publish("after_server_bind"))
+    runner
+  end
+
+  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
+    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(:test_args) { [] }
+    let(:args) { base_args + test_args }
+
+    context 'host option' do
+      let(:test_args) { ['--host=123.123.123.123'] }
+
+      it 'sends the host option to the runner' do
+        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'] }
+
+      it 'sends the port option to the runner' do
+        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'] }
+
+      it 'sends the threads option to the runner' do
+        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'] }
+
+      it 'sends the backlog option to the runner' do
+        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'] }
+
+      it 'sends the backlog option to the runner' do
+        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'] }
+
+      it 'sends the log file and level options to the runner' do
+        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
+    end
+
+    context 'gc options' do
+
+      context 'when gc options are not present' do
+        let(:test_args) { [] }
+
+        it 'sets both request and serialization pausing to false' do
+          described_class.start(args)
+          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'] }
+
+          it 'sets the configuration option to GC pause server request' do
+            described_class.start(args)
+            expect(::Protobuf).to be_gc_pause_server_request
+          end
+        end
+      end
+    end
+
+    context 'deprecation options' do
+      context 'when not given' do
+        let(:test_args) { [] }
+
+        context 'when no ENV is present and no command line option' do
+          before { ENV.delete("PB_IGNORE_DEPRECATIONS") }
+
+          it 'sets the deprecation warning flag to true' do
+            described_class.start(args)
+            expect(::Protobuf.print_deprecation_warnings?).to be true
+          end
+        end
+
+        context 'if ENV["PB_IGNORE_DEPRECATIONS"] is present' do
+          before { ENV["PB_IGNORE_DEPRECATIONS"] = "1" }
+          after { ENV.delete("PB_IGNORE_DEPRECATIONS") }
+
+          it 'sets the deprecation warning flag to false ' do
+            described_class.start(args)
+            expect(::Protobuf.print_deprecation_warnings?).to be false
+          end
+        end
+      end
+
+      context 'when enabled' do
+        let(:test_args) { ['--print_deprecation_warnings'] }
+
+        it 'sets the deprecation warning flag to true' do
+          described_class.start(args)
+          expect(::Protobuf.print_deprecation_warnings?).to be true
+        end
+      end
+
+      context 'when disabled' do
+        let(:test_args) { ['--no-print_deprecation_warnings'] }
+
+        it 'sets the deprecation warning flag to false' do
+          described_class.start(args)
+          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(:runner) { ::Protobuf::Rpc::SocketRunner }
+
+        before do
+          expect(::Protobuf::Rpc::ZmqRunner).not_to receive(:new)
+        end
+
+        it 'is activated by the --socket switch' do
+          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"
+          expect(runner).to receive(:new).and_return(sock_runner)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
+      end
+
+      context 'zmq workers only' do
+        let(:test_args) { ['--workers_only', '--zmq'] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
+        end
+
+        it 'is activated by the --workers_only switch' do
+          expect(runner).to receive(:new) do |options|
+            expect(options[:workers_only]).to be true
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+        end
+
+        it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do
+          ENV['PB_WORKERS_ONLY'] = "1"
+          expect(runner).to receive(:new) do |options|
+            expect(options[:workers_only]).to be true
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+          ENV.delete('PB_WORKERS_ONLY')
+        end
+      end
+
+      context 'zmq worker port' do
+        let(:test_args) { ['--worker_port=1234', '--zmq'] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
+        end
+
+        it 'is activated by the --worker_port switch' do
+          expect(runner).to receive(:new) do |options|
+            expect(options[:worker_port]).to eq(1234)
+          end.and_return(zmq_runner)
+
+          described_class.start(args)
+        end
+      end
+
+      context 'zmq' do
+        let(:test_args) { ['--zmq'] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
+
+        before do
+          expect(::Protobuf::Rpc::SocketRunner).not_to receive(:new)
+        end
+
+        it 'is activated by the --zmq switch' do
+          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"
+          expect(runner).to receive(:new)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
+      end
+
+      context 'after server bind' do
+        let(:sock_runner) { double("FakeRunner", :run => nil) }
+
+        before { allow(sock_runner).to receive(:run).and_yield }
+
+        it 'publishes when using the lib/protobuf callback' do
+          message_after_bind = false
+          ::Protobuf.after_server_bind do
+            message_after_bind = true
+          end
+          described_class.start(args)
+          expect(message_after_bind).to eq(true)
+        end
+      end
+
+      context 'before server bind' do
+        it 'publishes a message before the runner runs' do
+          message_before_bind = false
+          ::ActiveSupport::Notifications.subscribe('before_server_bind') do
+            message_before_bind = true
+          end
+          described_class.start(args)
+          expect(message_before_bind).to eq(true)
+        end
+
+        it 'publishes when using the lib/protobuf callback' do
+          message_before_bind = false
+          ::Protobuf.before_server_bind do
+            message_before_bind = true
+          end
+          described_class.start(args)
+          expect(message_before_bind).to eq(true)
+        end
+      end
+
+    end
+
+  end
+
+end