prepor-protobuf 3.5.0

data/spec/lib/protobuf/rpc/service_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+RSpec.describe Protobuf::Rpc::Service do
+
+  context 'class methods' do
+    subject { Test::ResourceService }
+
+    before :each do
+      reset_service_location Test::ResourceService
+    end
+
+    describe '.host' do
+      specify { expect(subject.host).to eq described_class::DEFAULT_HOST }
+    end
+
+    describe '.host=' do
+      before { subject.host = 'mynewhost.com' }
+      specify { expect(subject.host).to eq 'mynewhost.com' }
+    end
+
+    describe '.port' do
+      specify { expect(subject.port).to eq described_class::DEFAULT_PORT }
+    end
+
+    describe '.port=' do
+      before { subject.port = 12345 }
+      specify { expect(subject.port).to eq 12345 }
+    end
+
+    describe '.configure' do
+      context 'when providing a host' do
+        before { subject.configure(:host => 'mynewhost.com') }
+        specify { expect(subject.host).to eq 'mynewhost.com' }
+      end
+
+      context 'when providing a port' do
+        before { subject.configure(:port => 12345) }
+        specify { expect(subject.port).to eq 12345 }
+      end
+    end
+
+    describe '.located_at' do
+      context 'when given location is empty' do
+        before { subject.located_at(nil) }
+        specify { expect(subject.host).to eq described_class::DEFAULT_HOST }
+        specify { expect(subject.port).to eq described_class::DEFAULT_PORT }
+      end
+
+      context 'when given location is invalid' do
+        before { subject.located_at('i like pie') }
+        specify { expect(subject.host).to eq described_class::DEFAULT_HOST }
+        specify { expect(subject.port).to eq described_class::DEFAULT_PORT }
+      end
+
+      context 'when given location contains a host and port' do
+        before { subject.located_at('mynewdomain.com:12345') }
+        specify { expect(subject.host).to eq 'mynewdomain.com' }
+        specify { expect(subject.port).to eq 12345 }
+      end
+    end
+
+    describe '.client' do
+      it 'initializes a client object for this service' do
+        client = double('client')
+        expect(::Protobuf::Rpc::Client).to receive(:new)
+          .with(hash_including(
+                  :service => subject,
+                  :host => subject.host,
+                  :port => subject.port,
+          )).and_return(client)
+        expect(subject.client).to eq client
+      end
+    end
+
+    describe '.rpc' do
+      before { Test::ResourceService.rpc(:update, Test::ResourceFindRequest, Test::Resource) }
+      subject { Test::ResourceService.rpcs[:update] }
+      specify { expect(subject.method).to eq :update }
+      specify { expect(subject.request_type).to eq Test::ResourceFindRequest }
+      specify { expect(subject.response_type).to eq Test::Resource }
+    end
+
+    describe '.rpc_method?' do
+      before { Test::ResourceService.rpc(:delete, Test::Resource, Test::Resource) }
+
+      context 'when given name is a pre-defined rpc method' do
+        it 'returns true' do
+          expect(subject.rpc_method?(:delete)).to be true
+        end
+      end
+
+      context 'when given name is not a pre-defined rpc method' do
+        it 'returns false' do
+          expect(subject.rpc_method?(:zoobaboo)).to be false
+        end
+      end
+    end
+  end
+
+  context 'instance methods' do
+    context 'when invoking a service call' do
+      before do
+        stub_const('NewTestService', Class.new(Protobuf::Rpc::Service) do
+          rpc :find_with_implied_response, Test::ResourceFindRequest, Test::Resource
+          def find_with_implied_response
+            response.name = 'Implicit response'
+          end
+
+          rpc :find_with_respond_with, Test::ResourceFindRequest, Test::Resource
+          def find_with_respond_with
+            custom = Test::Resource.new(:name => 'Custom response')
+            respond_with(custom)
+          end
+
+          rpc :find_with_rpc_failed, Test::ResourceFindRequest, Test::Resource
+          def find_with_rpc_failed
+            rpc_failed('This is a failed endpoint')
+            response.name = 'Name will still be set'
+          end
+        end)
+      end
+
+      let(:request) { Test::ResourceFindRequest.new(:name => 'resource') }
+      let(:response) { Test::Resource.new }
+
+      context 'when calling the rpc method' do
+        context 'when response is implied' do
+          let(:env) do
+            Protobuf::Rpc::Env.new(
+              'request' => request,
+              'response_type' => response_type,
+            )
+          end
+          let(:response_type) { service.rpcs[:find_with_implied_response].response_type }
+          let(:service) { NewTestService }
+
+          subject { NewTestService.new(env) }
+
+          before { subject.find_with_implied_response }
+          specify { expect(subject.response).to be_a(Test::Resource) }
+          specify { expect(subject.response.name).to eq 'Implicit response' }
+        end
+
+        context 'when using respond_with paradigm' do
+          let(:env) do
+            Protobuf::Rpc::Env.new(
+              'method_name' => :find_with_respond_with,
+              'request' => request,
+            )
+          end
+
+          subject { NewTestService.new(env) }
+
+          before { subject.find_with_respond_with }
+          specify { expect(subject.response).to be_a(Test::Resource) }
+          specify { expect(subject.response.name).to eq 'Custom response' }
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf/rpc/stat_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'timecop'
+require 'active_support/core_ext/numeric/time'
+
+RSpec.describe ::Protobuf::Rpc::Stat do
+
+  before(:all) do
+    BarService = ::Struct.new(:method_name) unless defined?(BarService)
+  end
+
+  describe 'server mode' do
+    it 'describes a server response to a client' do
+      ::Timecop.freeze(10.minutes.ago) do
+        stats = ::Protobuf::Rpc::Stat.new(:SERVER)
+        stats.client = 'myserver1'
+        stats.dispatcher = double('dispatcher', :service => BarService.new(:find_bars))
+        stats.request_size = 43
+        stats.response_size = 1302
+
+        ::Timecop.freeze(1.62.seconds.from_now) do
+          stats.stop
+          expect(stats.to_s).to eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/1302B - 1.62s - #{::Time.now.iso8601}"
+        end
+      end
+    end
+
+    context 'when request is still running' do
+      it 'omits response size, duration, and timestamp' do
+        stats = ::Protobuf::Rpc::Stat.new(:SERVER)
+        stats.client = 'myserver1'
+        stats.dispatcher = double('dispatcher', :service => BarService.new(:find_bars))
+        stats.request_size = 43
+        expect(stats.to_s).to eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/-"
+      end
+    end
+  end
+
+  describe 'client mode' do
+    it 'describes a client request to a server' do
+      ::Timecop.freeze(10.minutes.ago) do
+        stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        stats.server = ['30000', 'myserver1.myhost.com']
+        stats.service = 'Foo::BarService'
+        stats.method_name = 'find_bars'
+        stats.request_size = 37
+        stats.response_size = 12345
+
+        ::Timecop.freeze(0.832.seconds.from_now) do
+          stats.stop
+          expect(stats.to_s).to eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/12345B - 0.832s - #{::Time.now.iso8601}"
+        end
+
+      end
+    end
+
+    context 'when request is still running' do
+      it 'omits response size, duration, and timestamp' do
+        stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        stats.server = ['30000', 'myserver1.myhost.com']
+        stats.service = 'Foo::BarService'
+        stats.method_name = 'find_bars'
+        stats.request_size = 37
+        expect(stats.to_s).to eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/-"
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'protobuf'
+
+RSpec.describe ::Protobuf do
+
+  describe '.client_host' do
+    after { ::Protobuf.client_host = nil }
+
+    subject { ::Protobuf.client_host }
+
+    context 'when client_host is not pre-configured' do
+      it { is_expected.to eq `hostname`.chomp }
+    end
+
+    context 'when client_host is pre-configured' do
+      let(:hostname) { 'override.myhost.com' }
+      before { ::Protobuf.client_host = hostname }
+      it { is_expected.to eq hostname }
+    end
+  end
+
+  describe '.connector_type' do
+    before { described_class.instance_variable_set(:@connector_type, nil) }
+
+    it 'defaults to socket' do
+      expect(described_class.connector_type).to eq :socket
+    end
+
+    it 'accepts socket or zmq' do
+      [:socket, :zmq].each do |type|
+        described_class.connector_type = type
+        expect(described_class.connector_type).to eq type
+      end
+    end
+
+    it 'does not accept other types' do
+      [:hello, :world, :evented].each do |type|
+        expect do
+          described_class.connector_type = type
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.gc_pause_server_request?' do
+    before { described_class.instance_variable_set(:@gc_pause_server_request, nil) }
+
+    it 'defaults to a false value' do
+      expect(described_class.gc_pause_server_request?).to be false
+    end
+
+    it 'is settable' do
+      described_class.gc_pause_server_request = true
+      expect(described_class.gc_pause_server_request?).to be true
+    end
+  end
+
+  describe '.print_deprecation_warnings?' do
+    before { described_class.instance_variable_set(:@print_deprecation_warnings, nil) }
+
+    it 'defaults to a true value' do
+      expect(described_class.print_deprecation_warnings?).to be true
+    end
+
+    it 'is settable' do
+      described_class.print_deprecation_warnings = false
+      expect(described_class.print_deprecation_warnings?).to be false
+    end
+
+    context 'when ENV["PB_IGNORE_DEPRECATIONS"] present' do
+      it 'defaults to a false value' do
+        ENV['PB_IGNORE_DEPRECATIONS'] = '1'
+        expect(described_class.print_deprecation_warnings?).to be false
+      end
+    end
+  end
+
+  describe '.ignore_unknown_fields?' do
+    before do
+      if described_class.instance_variable_defined?(:@_ignore_unknown_fields)
+        described_class.send(:remove_instance_variable, :@_ignore_unknown_fields)
+      end
+    end
+
+    it 'defaults to a true value' do
+      expect(described_class.ignore_unknown_fields?).to be true
+    end
+
+    it 'is settable' do
+      expect do
+        described_class.ignore_unknown_fields = false
+      end.to change {
+        described_class.ignore_unknown_fields?
+      }.from(true).to(false)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'timeout'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development, :test
+require 'pry'
+
+$LOAD_PATH << ::File.expand_path('../..', __FILE__)
+$LOAD_PATH << ::File.expand_path('../support', __FILE__)
+
+require 'protobuf'
+require 'protobuf/rpc/server'
+require ::File.expand_path('../support/all', __FILE__)
+
+$LOAD_PATH << ::File.expand_path("../../lib/protobuf/descriptors", __FILE__)
+require 'google/protobuf/compiler/plugin.pb'
+
+# Including a way to turn on debug logger for spec runs
+if ENV.key?('DEBUG')
+  debug_log = ::File.expand_path('../../debug_specs.log', __FILE__)
+  ::Protobuf::Logging.initialize_logger(debug_log, ::Logger::DEBUG)
+else
+  ::Protobuf::Logging.initialize_logger('/dev/null')
+end
+
+# Get rid of the deprecation env var if present (messes with specs).
+ENV.delete("PB_IGNORE_DEPRECATIONS")
+
+support_proto_glob = File.expand_path('../support/**/*.pb.rb', __FILE__)
+Dir[support_proto_glob].each { |proto_file| require proto_file }
+
+RSpec.configure(&:disable_monkey_patching!)
+
+::Protobuf::Rpc::Client.class_eval do
+  def ==(other)
+    connector.options == other.options && \
+      success_cb == other.success_cb && \
+      failure_cb == other.failure_cb
+  end
+end
+
+def reset_service_location(service)
+  service.host = nil
+  service.port = nil
+end

data/spec/support/all.rb

@@ -0,0 +1,6 @@
+require 'support/packed_field'
+require 'support/server'
+
+def now
+  Time.new.to_f
+end

data/spec/support/packed_field.rb

@@ -0,0 +1,22 @@
+if defined?(RSpec)
+  shared_examples_for :packable_field do |field_klass|
+
+    before(:all) do
+      unless defined?(PackableFieldTest)
+        class PackableFieldTest < ::Protobuf::Message; end
+      end
+
+      field_name = "#{field_klass.name.split('::').last.underscore}_packed_field".to_sym
+      tag_num = PackableFieldTest.fields.size + 1
+      PackableFieldTest.repeated(field_klass, field_name, tag_num, :packed => true)
+    end
+
+    let(:field_name) { "#{field_klass.name.split('::').last.underscore}_packed_field".to_sym }
+    let(:message_instance) { PackableFieldTest.new(field_name => [100, 200, 300]) }
+
+    subject { PackableFieldTest.get_field(field_name) }
+
+    specify { expect(subject).to be_packed }
+
+  end
+end

data/spec/support/server.rb

@@ -0,0 +1,64 @@
+require 'ostruct'
+
+require 'active_support/core_ext/hash/reverse_merge'
+
+require 'protobuf/logging'
+require 'protobuf/rpc/server'
+require 'protobuf/rpc/servers/socket/server'
+require 'protobuf/rpc/servers/socket_runner'
+require 'protobuf/rpc/servers/zmq/server'
+require 'protobuf/rpc/servers/zmq_runner'
+require 'spec/support/test/resource_service'
+
+# Want to abort if server dies?
+Thread.abort_on_exception = true
+
+class StubServer
+  include Protobuf::Logging
+
+  private
+
+  attr_accessor :options, :runner, :runner_thread
+
+  public
+
+  def initialize(options = {})
+    self.options = OpenStruct.new(
+      options.reverse_merge(
+        :host => '127.0.0.1',
+        :port => 9399,
+        :worker_port => 9400,
+        :delay => 0,
+        :server => Protobuf::Rpc::Socket::Server,
+      ),
+    )
+
+    start
+    yield self
+  ensure
+    stop
+  end
+
+  def start
+    runner_class = {
+      ::Protobuf::Rpc::Zmq::Server => ::Protobuf::Rpc::ZmqRunner,
+      ::Protobuf::Rpc::Socket::Server => ::Protobuf::Rpc::SocketRunner,
+    }.fetch(options.server)
+
+    self.runner = runner_class.new(options)
+    self.runner_thread = Thread.new(runner, &:run)
+    runner_thread.abort_on_exception = true # Set for testing purposes
+    Thread.pass until runner.running?
+
+    logger.debug { sign_message("Server started #{options.host}:#{options.port}") }
+  end
+
+  def stop
+    runner.stop
+    runner_thread.join
+  end
+
+  def log_signature
+    @_log_signature ||= "[stub-server]"
+  end
+end