protobuf-cucumber 3.10.4

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

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require SUPPORT_PATH.join('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,101 @@
+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=' do
+    it 'understands Array' do
+      stat = ::Protobuf::Rpc::Stat.new
+      stat.server = [3333, "127.0.0.1"]
+      expect(stat.server).to eq("127.0.0.1:3333")
+    end
+
+    it 'understands String' do
+      stat = ::Protobuf::Rpc::Stat.new
+      stat.server = "thatserverthough"
+      expect(stat.server).to eq("thatserverthough")
+    end
+  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 - OK - #{::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/- - OK"
+      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 - OK - #{::Time.now.iso8601}"
+        end
+
+      end
+    end
+
+    describe 'error log' do
+      it 'resolves error to a string' do
+        ::Timecop.freeze(10.minutes.ago) do
+          stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+          stats.server = ['30000', 'myserver1.myhost.com']
+          stats.service = 'Foo::BarService'
+          stats.status = ::Protobuf::Socketrpc::ErrorReason::RPC_ERROR
+          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 - RPC_ERROR - #{::Time.now.iso8601}"
+          end
+        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/- - OK"
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/varint_spec.rb

@@ -0,0 +1,29 @@
+require 'base64'
+require 'spec_helper'
+
+RSpec.describe Protobuf::Varint do
+  VALUES = {
+    0 => "AA==",
+    5 => "BQ==",
+    51 => "Mw==",
+    9_192 => "6Ec=",
+    80_389 => "hfQE",
+    913_389 => "7d83",
+    516_192_829_912_693 => "9eyMkpivdQ==",
+    9_999_999_999_999_999_999 => "//+fz8jgyOOKAQ==",
+  }.freeze
+
+  [defined?(::Varint) ? ::Varint : nil, Protobuf::VarintPure].compact.each do |klass|
+    context "with #{klass}" do
+      before { described_class.extend(klass) }
+      after { load ::File.expand_path('../../../../lib/protobuf/varint.rb', __FILE__) }
+
+      VALUES.each do |number, encoded|
+        it "decodes #{number}" do
+          io = StringIO.new(Base64.decode64(encoded))
+          expect(described_class.decode(io)).to eq(number)
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf_spec.rb

@@ -0,0 +1,105 @@
+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 ::Socket.gethostname }
+    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_class' do
+    it "defaults to Socket" do
+      described_class.connector_type_class = nil
+      expect(described_class.connector_type_class).to eq(::Protobuf::Rpc::Connectors::Socket)
+    end
+
+    it 'fails if fails to load the PB_CLIENT_TYPE' do
+      ENV['PB_CLIENT_TYPE'] = "something_to_autoload"
+      expect { load 'protobuf.rb' }.to raise_error(LoadError, /something_to_autoload/)
+      ENV.delete('PB_CLIENT_TYPE')
+    end
+
+    it 'loads the connector type class from PB_CLIENT_TYPE' do
+      ENV['PB_CLIENT_TYPE'] = "protobuf/rpc/connectors/zmq"
+      load 'protobuf.rb'
+      expect(::Protobuf.connector_type_class).to eq(::Protobuf::Rpc::Connectors::Zmq)
+      ENV.delete('PB_CLIENT_TYPE')
+    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
+    around do |example|
+      orig = described_class.print_deprecation_warnings?
+      example.call
+      described_class.print_deprecation_warnings = orig
+    end
+
+    it 'defaults to a true value' do
+      allow(ENV).to receive(:key?).with('PB_IGNORE_DEPRECATIONS').and_return(false)
+      described_class.instance_variable_set('@field_deprecator', nil)
+      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
+        allow(ENV).to receive(:key?).with('PB_IGNORE_DEPRECATIONS').and_return(true)
+        described_class.instance_variable_set('@field_deprecator', nil)
+        expect(described_class.print_deprecation_warnings?).to be false
+      end
+    end
+  end
+
+  describe '.ignore_unknown_fields?' do
+    around do |example|
+      orig = described_class.ignore_unknown_fields?
+      example.call
+      described_class.ignore_unknown_fields = orig
+    end
+
+    it 'defaults to a true value' do
+      if described_class.instance_variable_defined?('@ignore_unknown_fields')
+        described_class.send(:remove_instance_variable, '@ignore_unknown_fields')
+      end
+      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,42 @@
+require 'timeout'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development, :test
+require 'pry'
+require 'pathname'
+
+$LOAD_PATH << ::File.expand_path('../..', __FILE__)
+SUPPORT_PATH = Pathname.new(::File.expand_path('../support', __FILE__))
+PROTOS_PATH = SUPPORT_PATH.join('protos')
+$LOAD_PATH << SUPPORT_PATH
+
+require 'protobuf'
+require 'protobuf/rpc/server'
+require SUPPORT_PATH.join('all')
+
+$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")
+
+::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