protobuffy 3.6.0 → 4.0.0

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'spec/support/test/resource_service'
+require SUPPORT_PATH.join('resource_service')
 
-describe Protobuf::Rpc::Service do
+RSpec.describe Protobuf::Rpc::Service do
 
   context 'class methods' do
     subject { Test::ResourceService }
@@ -11,73 +11,74 @@ describe Protobuf::Rpc::Service do
     end
 
     describe '.host' do
-      its(:host) { should eq described_class::DEFAULT_HOST }
+      specify { expect(subject.host).to eq described_class::DEFAULT_HOST }
     end
 
     describe '.host=' do
       before { subject.host = 'mynewhost.com' }
-      its(:host) { should eq 'mynewhost.com' }
+      specify { expect(subject.host).to eq 'mynewhost.com' }
     end
 
     describe '.port' do
-      its(:port) { should eq described_class::DEFAULT_PORT }
+      specify { expect(subject.port).to eq described_class::DEFAULT_PORT }
     end
 
     describe '.port=' do
       before { subject.port = 12345 }
-      its(:port) { should eq 12345 }
+      specify { expect(subject.port).to eq 12345 }
     end
 
     describe '.configure' do
       context 'when providing a host' do
         before { subject.configure(:host => 'mynewhost.com') }
-        its(:host) { should eq 'mynewhost.com' }
+        specify { expect(subject.host).to eq 'mynewhost.com' }
       end
 
       context 'when providing a port' do
         before { subject.configure(:port => 12345) }
-        its(:port) { should eq 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) }
-        its(:host) { should eq described_class::DEFAULT_HOST }
-        its(:port) { should eq described_class::DEFAULT_PORT }
+        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') }
-        its(:host) { should eq described_class::DEFAULT_HOST }
-        its(:port) { should eq described_class::DEFAULT_PORT }
+        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') }
-        its(:host) { should eq 'mynewdomain.com' }
-        its(:port) { should eq 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')
-        ::Protobuf::Rpc::Client.should_receive(:new)
-                                .with(hash_including({ :service => subject,
-                                                       :host => subject.host,
-                                                       :port => subject.port }))
-                                .and_return(client)
-        subject.client.should eq 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] }
-      its(:method) { should eq :update }
-      its(:request_type) { should eq Test::ResourceFindRequest }
-      its(:response_type) { should eq Test::Resource }
+      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
@@ -85,13 +86,13 @@ describe Protobuf::Rpc::Service do
 
       context 'when given name is a pre-defined rpc method' do
         it 'returns true' do
-          subject.rpc_method?(:delete).should be_true
+          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
-          subject.rpc_method?(:zoobaboo).should be_false
+          expect(subject.rpc_method?(:zoobaboo)).to be false
         end
       end
     end
@@ -99,8 +100,8 @@ describe Protobuf::Rpc::Service do
 
   context 'instance methods' do
     context 'when invoking a service call' do
-      before(:all) do
-        class ::NewTestService < Protobuf::Rpc::Service
+      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'
@@ -117,7 +118,7 @@ describe Protobuf::Rpc::Service do
             rpc_failed('This is a failed endpoint')
             response.name = 'Name will still be set'
           end
-        end
+        end)
       end
 
       let(:request) { Test::ResourceFindRequest.new(:name => 'resource') }
@@ -125,35 +126,35 @@ describe Protobuf::Rpc::Service do
 
       context 'when calling the rpc method' do
         context 'when response is implied' do
-          let(:env) {
+          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 }
-          its(:response) { should be_a(Test::Resource) }
-          specify { subject.response.name.should eq 'Implicit 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) {
+          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 }
-          its(:response) { should be_a(Test::Resource) }
-          specify { subject.response.name.should eq 'Custom response' }
+          specify { expect(subject.response).to be_a(Test::Resource) }
+          specify { expect(subject.response.name).to eq 'Custom response' }
         end
       end
     end

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

@@ -2,12 +2,10 @@ require 'spec_helper'
 require 'timecop'
 require 'active_support/core_ext/numeric/time'
 
-describe ::Protobuf::Rpc::Stat do
+RSpec.describe ::Protobuf::Rpc::Stat do
 
   before(:all) do
-    unless defined?(BarService)
-      class BarService < ::Struct.new(:method_name); end
-    end
+    BarService = ::Struct.new(:method_name) unless defined?(BarService)
   end
 
   describe 'server mode' do
@@ -21,7 +19,7 @@ describe ::Protobuf::Rpc::Stat do
 
         ::Timecop.freeze(1.62.seconds.from_now) do
           stats.stop
-          stats.to_s.should eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/1302B - 1.62s - #{::Time.now.iso8601}"
+          expect(stats.to_s).to eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/1302B - 1.62s - #{::Time.now.iso8601}"
         end
       end
     end
@@ -32,7 +30,7 @@ describe ::Protobuf::Rpc::Stat do
         stats.client = 'myserver1'
         stats.dispatcher = double('dispatcher', :service => BarService.new(:find_bars))
         stats.request_size = 43
-        stats.to_s.should eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/-"
+        expect(stats.to_s).to eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/-"
       end
     end
   end
@@ -49,7 +47,7 @@ describe ::Protobuf::Rpc::Stat do
 
         ::Timecop.freeze(0.832.seconds.from_now) do
           stats.stop
-          stats.to_s.should eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/12345B - 0.832s - #{::Time.now.iso8601}"
+          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
@@ -62,7 +60,7 @@ describe ::Protobuf::Rpc::Stat do
         stats.service = 'Foo::BarService'
         stats.method_name = 'find_bars'
         stats.request_size = 37
-        stats.to_s.should eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/-"
+        expect(stats.to_s).to eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/-"
       end
     end
   end
@@ -101,7 +99,7 @@ describe ::Protobuf::Rpc::Stat do
 
     context "when statsd_client hasn't been set" do
       it "should not raise" do
-        expect{ stop }.not_to raise_error
+        expect { stop }.not_to raise_error
       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

@@ -1,77 +1,104 @@
 require 'spec_helper'
 require 'protobuf'
 
-describe ::Protobuf do
+RSpec.describe ::Protobuf do
 
   describe '.client_host' do
-    after { ::Protobuf.instance_variable_set(:@_client_host, nil) }
+    after { ::Protobuf.client_host = nil }
 
     subject { ::Protobuf.client_host }
 
     context 'when client_host is not pre-configured' do
-      it { should eq `hostname`.chomp }
+      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 { should eq 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
-      described_class.connector_type.should eq :socket
+  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 'accepts socket or zmq' do
-      [:socket, :zmq].each do |type|
-        described_class.connector_type = type
-        described_class.connector_type.should eq type
-      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 'does not accept other types' do
-      [:hello, :world, :evented].each do |type|
-        expect {
-          described_class.connector_type = type
-        }.to raise_error(ArgumentError)
-      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) }
+    before { described_class.instance_variable_set(:@gc_pause_server_request, nil) }
 
     it 'defaults to a false value' do
-      described_class.gc_pause_server_request?.should be_false
+      expect(described_class.gc_pause_server_request?).to be false
     end
 
     it 'is settable' do
       described_class.gc_pause_server_request = true
-      described_class.gc_pause_server_request?.should be_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) }
+    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
-      described_class.print_deprecation_warnings?.should be_true
+      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
-      described_class.print_deprecation_warnings?.should be_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'
-        described_class.print_deprecation_warnings?.should be_false
+        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
 

data/spec/spec_helper.rb

@@ -1,49 +1,34 @@
-require 'simplecov'
-SimpleCov.start
-
 require 'timeout'
 require 'rubygems'
 require 'bundler'
 Bundler.setup :default, :development, :test
 require 'pry'
+require 'pathname'
 
-$: << ::File.expand_path('../..', __FILE__)
-$: << ::File.expand_path('../support', __FILE__)
+$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 ::File.expand_path('../support/all', __FILE__)
+require SUPPORT_PATH.join('all')
 
-$: << ::File.expand_path("../../lib/protobuf/descriptors", __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.dirname(__FILE__) )
-  ::Protobuf::Logger.configure(:file => debug_log, :level => ::Logger::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")
 
-::RSpec.configure do |c|
-  c.include(::Sander6::CustomMatchers)
-  c.mock_with :rspec
-
-  c.before(:suite) do
-    unless ENV['NO_COMPILE_TEST_PROTOS']
-      require 'rake'
-      load ::File.expand_path('../../Rakefile', __FILE__)
-      $stdout.puts 'Compiling test protos (use NO_COMPILE_TEST_PROTOS=1 to skip)'
-      ::Rake::Task['compile:spec']
-    end
-  end
-end
-
-support_proto_glob = File.expand_path('../support/**/*.pb.rb', __FILE__)
-Dir[support_proto_glob].each { |proto_file| require proto_file }
-
-class ::Protobuf::Rpc::Client
+::Protobuf::Rpc::Client.class_eval do
   def ==(other)
     connector.options == other.options && \
       success_cb == other.success_cb && \