protobuffy 3.6.0 → 4.0.0

data/spec/lib/protobuf/optionable_spec.rb

@@ -1,46 +1,222 @@
 require 'spec_helper'
 require 'protobuf/optionable'
+require 'protobuf/field/message_field'
+require PROTOS_PATH.join('resource.pb')
 
-describe 'Optionable' do
+RSpec.describe 'Optionable' do
+  describe '.{get,get!}_option' do
+    before do
+      stub_const("OptionableGetOptionTest", Class.new(::Protobuf::Message) do
+        set_option :deprecated, true
+        set_option :".package.message_field", :field => 33
 
-  describe '.set_option' do
-    before(:all) do
-      OptionableSetOptionTest = ::Class.new do
-        include ::Protobuf::Optionable
-      end
+        optional :int32, :field, 1
+      end)
+    end
+
+    it '.get_option retrieves the option as a symbol' do
+      expect(OptionableGetOptionTest.get_option(:deprecated)).to be(true)
+    end
+
+    it '.get_option returns the default value for unset options' do
+      expect(OptionableGetOptionTest.get_option(:message_set_wire_format)).to be(false)
+    end
+
+    it '.get_option retrieves the option as a string' do
+      expect(OptionableGetOptionTest.get_option('deprecated')).to be(true)
+    end
+
+    it '.get_option errors if the option does not exist' do
+      expect { OptionableGetOptionTest.get_option(:baz) }.to raise_error(ArgumentError)
+    end
+
+    it '.get_option errors if the option is not accessed by its fully qualified name' do
+      message_field = ::Protobuf::Field::MessageField.new(
+        OptionableGetOptionTest, :optional, OptionableGetOptionTest, '.package.message_field', 2, '.message_field', {})
+      allow(::Google::Protobuf::MessageOptions).to receive(:get_field).and_return(message_field)
+      expect { OptionableGetOptionTest.get_option(message_field.name) }.to raise_error(ArgumentError)
+    end
+
+    it '.get_option can return an option representing a message' do
+      message_field = ::Protobuf::Field::MessageField.new(
+        OptionableGetOptionTest, :optional, OptionableGetOptionTest, '.package.message_field', 2, 'message_field', {})
+      allow(::Google::Protobuf::MessageOptions).to receive(:get_field).and_return(message_field)
+      expect(OptionableGetOptionTest.get_option(message_field.fully_qualified_name)).to eq(OptionableGetOptionTest.new(:field => 33))
+    end
+
+    it '.get_option! retrieves explicitly an set option' do
+      expect(OptionableGetOptionTest.get_option!(:deprecated)).to be(true)
+    end
+
+    it '.get_option! returns nil for unset options' do
+      expect(OptionableGetOptionTest.get_option!(:message_set_wire_format)).to be(nil)
     end
 
-    it 'stores the given option and value' do
-      expect(OptionableSetOptionTest).to respond_to(:set_option)
-      expect(OptionableSetOptionTest.method(:set_option).arity).to eq(-2)
-      expect {
-        OptionableSetOptionTest.set_option(:foo, :bar)
-      }.to_not raise_error
+    it '.get_option! errors if the option does not exist' do
+      expect { OptionableGetOptionTest.get_option(:baz) }.to raise_error(ArgumentError)
     end
 
-    it 'defaults the value to true' do
-      OptionableSetOptionTest.set_option(:baz_enabled)
-      expect(OptionableSetOptionTest.get_option(:baz_enabled)).to be_true
+    it '#get_option retrieves the option as a symbol' do
+      expect(OptionableGetOptionTest.new.get_option(:deprecated)).to be(true)
+    end
+
+    it '#get_option returns the default value for unset options' do
+      expect(OptionableGetOptionTest.new.get_option(:message_set_wire_format)).to be(false)
+    end
+
+    it '#get_option retrieves the option as a string' do
+      expect(OptionableGetOptionTest.new.get_option('deprecated')).to be(true)
+    end
+
+    it '#get_option errors if the option is not accessed by its fully qualified name' do
+      message_field = ::Protobuf::Field::MessageField.new(
+        OptionableGetOptionTest, :optional, OptionableGetOptionTest, '.package.message_field', 2, 'message_field', {})
+      allow(::Google::Protobuf::MessageOptions).to receive(:get_field).and_return(message_field)
+      expect { OptionableGetOptionTest.new.get_option(message_field.name) }.to raise_error(ArgumentError)
+    end
+
+    it '#get_option can return an option representing a message' do
+      message_field = ::Protobuf::Field::MessageField.new(
+        OptionableGetOptionTest, :optional, OptionableGetOptionTest, '.package.message_field', 2, 'message_field', {})
+      allow(::Google::Protobuf::MessageOptions).to receive(:get_field).and_return(message_field)
+      expect(OptionableGetOptionTest.new.get_option(message_field.fully_qualified_name)).to eq(OptionableGetOptionTest.new(:field => 33))
+    end
+
+    it '#get_option errors if the option does not exist' do
+      expect { OptionableGetOptionTest.new.get_option(:baz) }.to raise_error(ArgumentError)
+    end
+
+    it '#get_option! retrieves explicitly an set option' do
+      expect(OptionableGetOptionTest.new.get_option!(:deprecated)).to be(true)
+    end
+
+    it '#get_option! returns nil for unset options' do
+      expect(OptionableGetOptionTest.new.get_option!(:message_set_wire_format)).to be(nil)
+    end
+
+    it '#get_option! errors if the option does not exist' do
+      expect { OptionableGetOptionTest.new.get_option(:baz) }.to raise_error(ArgumentError)
     end
   end
 
-  describe '.get_option' do
-    before(:all) do
-      OptionableGetOptionTest = ::Class.new do
-        include ::Protobuf::Optionable
-        set_option :foo, :bar
+  describe '.inject' do
+    let(:klass) { Class.new }
+
+    it 'adds klass.{set,get}_option' do
+      expect { klass.get_option(:deprecated) }.to raise_error(NoMethodError)
+      expect { klass.__send__(:set_option, :deprecated, true) }.to raise_error(NoMethodError)
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
+      expect(klass.get_option(:deprecated)).to eq(false)
+      expect { klass.set_option(:deprecated, true) }.to raise_error(NoMethodError)
+      klass.__send__(:set_option, :deprecated, true)
+      expect(klass.get_option(:deprecated)).to eq(true)
+    end
+
+    it 'adds klass#get_option' do
+      expect { klass.new.get_option(:deprecated) }.to raise_error(NoMethodError)
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
+      expect(klass.new.get_option(:deprecated)).to eq(false)
+    end
+
+    it 'adds klass.optionable_descriptor_class' do
+      expect { klass.optionable_descriptor_class }.to raise_error(NoMethodError)
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
+      expect(klass.optionable_descriptor_class).to eq(::Google::Protobuf::MessageOptions)
+    end
+
+    it 'does not add klass.optionable_descriptor_class twice' do
+      expect(klass).to receive(:define_singleton_method).once
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
+      klass.instance_eval do
+        def optionable_descriptor_class
+          ::Google::Protobuf::MessageOptions
+        end
       end
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
     end
 
-    it 'retrieves the option for the given name, if any' do
-      expect(OptionableGetOptionTest.get_option(:foo)).to eq(:bar)
-      expect(OptionableGetOptionTest.get_option(:baz)).to be_nil
+    it 'throws error when klass.optionable_descriptor_class defined twice with different args' do
+      ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::MessageOptions }
+      expect { ::Protobuf::Optionable.inject(klass) { ::Google::Protobuf::FileOptions } }
+        .to raise_error('A class is being defined with two different descriptor classes, something is very wrong')
     end
 
-    it 'retrieves the option in the context of an instance' do
-      expect(OptionableGetOptionTest.new.get_option(:foo)).to eq(:bar)
-      expect(OptionableGetOptionTest.new.get_option(:baz)).to be_nil
+    context 'extend_class = false' do
+      let(:object) { klass.new }
+      it 'adds object.{get,set}_option' do
+        expect { object.get_option(:deprecated) }.to raise_error(NoMethodError)
+        expect { object.__send__(:set_option, :deprecated, true) }.to raise_error(NoMethodError)
+        ::Protobuf::Optionable.inject(klass, false) { ::Google::Protobuf::MessageOptions }
+        expect(object.get_option(:deprecated)).to eq(false)
+        expect { object.set_option(:deprecated, true) }.to raise_error(NoMethodError)
+        object.__send__(:set_option, :deprecated, true)
+        expect(object.get_option(:deprecated)).to eq(true)
+      end
+
+      it 'does not add klass.{get,set}_option' do
+        expect { object.get_option(:deprecated) }.to raise_error(NoMethodError)
+        ::Protobuf::Optionable.inject(klass, false) { ::Google::Protobuf::MessageOptions }
+        expect { klass.get_option(:deprecated) }.to raise_error(NoMethodError)
+        expect { klass.__send__(:set_option, :deprecated) }.to raise_error(NoMethodError)
+      end
+
+      it 'creates an instance method optionable_descriptor_class' do
+        expect { object.optionable_descriptor_class }.to raise_error(NoMethodError)
+        ::Protobuf::Optionable.inject(klass, false) { ::Google::Protobuf::MessageOptions }
+        expect(object.optionable_descriptor_class).to eq(::Google::Protobuf::MessageOptions)
+      end
     end
   end
 
+  describe 'getting options from generated code' do
+    context 'file options' do
+      it 'gets base options' do
+        expect(::Test.get_option!(:cc_generic_services)).to eq(true)
+      end
+
+      it 'gets unset options' do
+        expect(::Test.get_option!(:java_multiple_files)).to eq(nil)
+        expect(::Test.get_option(:java_multiple_files)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(::Test.get_option!(:".test.file_option")).to eq(9876543210)
+      end
+    end
+
+    context 'field options' do
+      subject { ::Test::Resource.fields[0] }
+
+      it 'gets base options' do
+        expect(subject.get_option!(:ctype))
+          .to eq(::Google::Protobuf::FieldOptions::CType::CORD)
+      end
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:lazy)).to eq(nil)
+        expect(subject.get_option(:lazy)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.field_option")).to eq(8765432109)
+      end
+    end
+
+    context 'enum options' do
+      subject { ::Test::StatusType }
+
+      it 'gets base options' do
+        expect(subject.get_option!(:allow_alias)).to eq(true)
+      end
+
+      it 'gets unset options' do
+        expect(subject.get_option!(:deprecated)).to eq(nil)
+        expect(subject.get_option(:deprecated)).to eq(false)
+      end
+
+      it 'gets custom options' do
+        expect(subject.get_option!(:".test.enum_option")).to eq(-789)
+      end
+    end
+  end
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'spec/support/test/resource_service'
+require SUPPORT_PATH.join('resource_service')
 
-describe Protobuf::Rpc::Client do
+RSpec.describe Protobuf::Rpc::Client do
   before(:each) do
     load 'protobuf/socket.rb'
   end
@@ -10,29 +10,29 @@ describe Protobuf::Rpc::Client do
     before { reset_service_location(Test::ResourceService) }
 
     it 'should be able to get a client through the Service#client helper method' do
-      Test::ResourceService.client(:port => 9191).should eq(Protobuf::Rpc::Client.new(:service => Test::ResourceService, :port => 9191))
+      expect(::Test::ResourceService.client(:port => 9191)).to eq(Protobuf::Rpc::Client.new(:service => Test::ResourceService, :port => 9191))
     end
 
     it "should be able to override a service location's host and port" do
       Test::ResourceService.located_at 'somewheregreat.com:12345'
       clean_client = Test::ResourceService.client
-      clean_client.options[:host].should eq('somewheregreat.com')
-      clean_client.options[:port].should eq(12345)
+      expect(clean_client.options[:host]).to eq('somewheregreat.com')
+      expect(clean_client.options[:port]).to eq(12345)
 
       updated_client = Test::ResourceService.client(:host => 'amazing.com', :port => 54321)
-      updated_client.options[:host].should eq('amazing.com')
-      updated_client.options[:port].should eq(54321)
+      expect(updated_client.options[:host]).to eq('amazing.com')
+      expect(updated_client.options[:port]).to eq(54321)
     end
 
     it 'should be able to define which service to create itself for' do
       client = Protobuf::Rpc::Client.new :service => Test::ResourceService
-      client.options[:service].should eq(Test::ResourceService)
+      expect(client.options[:service]).to eq(Test::ResourceService)
     end
 
     it 'should have a hard default for host and port on a service that has not been configured' do
       client = Test::ResourceService.client
-      client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_HOST)
-      client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_PORT)
+      expect(client.options[:host]).to eq(Protobuf::Rpc::Service::DEFAULT_HOST)
+      expect(client.options[:port]).to eq(Protobuf::Rpc::Service::DEFAULT_PORT)
     end
 
   end
@@ -45,7 +45,7 @@ describe Protobuf::Rpc::Client do
 
     it 'should respond to defined service methods' do
       client = Test::ResourceService.client
-      client.should_receive(:send_request).and_return(nil)
+      expect(client).to receive(:send_request).and_return(nil)
       expect { client.find(nil) }.to_not raise_error
     end
   end
@@ -54,11 +54,11 @@ describe Protobuf::Rpc::Client do
 
     it 'should be able to create the correct request object if passed a hash' do
       client = Test::ResourceService.client
-      client.should_receive(:send_request)
-      client.find({:name => 'Test Name', :active => false})
-      client.options[:request].should be_a(Test::ResourceFindRequest)
-      client.options[:request].name.should eq('Test Name')
-      client.options[:request].active.should eq(false)
+      expect(client).to receive(:send_request)
+      client.find(:name => 'Test Name', :active => false)
+      expect(client.options[:request]).to be_a(Test::ResourceFindRequest)
+      expect(client.options[:request].name).to eq('Test Name')
+      expect(client.options[:request].active).to eq(false)
     end
 
   end

data/spec/lib/protobuf/rpc/connectors/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Connectors::Base do
+RSpec.describe Protobuf::Rpc::Connectors::Base do
 
   let(:options) do
     { :timeout => 60 }
@@ -8,43 +8,197 @@ describe Protobuf::Rpc::Connectors::Base do
 
   subject { Protobuf::Rpc::Connectors::Base.new(options) }
 
+  context "API" do
+    specify { expect(subject.respond_to?(:any_callbacks?)).to be true }
+    specify { expect(subject.respond_to?(:request_caller)).to be true }
+    specify { expect(subject.respond_to?(:data_callback)).to be true }
+    specify { expect(subject.respond_to?(:error)).to be true }
+    specify { expect(subject.respond_to?(:failure)).to be true }
+    specify { expect(subject.respond_to?(:complete)).to be true }
+    specify { expect(subject.respond_to?(:parse_response)).to be true }
+    specify { expect(subject.respond_to?(:verify_options!)).to be true }
+    specify { expect(subject.respond_to?(:verify_callbacks)).to be true }
+  end
+
+  describe "#any_callbacks?" do
+    [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
+      it "returns true if #{cb} is provided" do
+        subject.instance_variable_set(cb, "something")
+        expect(subject.any_callbacks?).to be true
+      end
+    end
+
+    it "returns false when all callbacks are not provided" do
+      subject.instance_variable_set(:@complete_cb, nil)
+      subject.instance_variable_set(:@success_cb, nil)
+      subject.instance_variable_set(:@failure_cb, nil)
+
+      expect(subject.any_callbacks?).to be false
+    end
+  end
+
+  describe "#data_callback" do
+    it "changes state to use the data callback" do
+      subject.data_callback("data")
+      expect(subject.instance_variable_get(:@used_data_callback)).to be true
+    end
+
+    it "sets the data var when using the data_callback" do
+      subject.data_callback("data")
+      expect(subject.instance_variable_get(:@data)).to eq("data")
+    end
+  end
+
   describe "#send_request" do
     it "raising an error when 'send_request' is not overridden" do
-      expect{ subject.send_request }.to raise_error(RuntimeError, /inherit a Connector/)
+      expect { subject.send_request }.to raise_error(RuntimeError, /inherit a Connector/)
     end
 
     it "does not raise error when 'send_request' is overridden" do
-      new_sub = Class.new(subject.class){ def send_request; end }.new(options)
-      expect{ new_sub.send_request }.to_not raise_error
+      new_sub = Class.new(subject.class) { def send_request; end }.new(options)
+      expect { new_sub.send_request }.to_not raise_error
     end
   end
 
   describe '.new' do
     it 'assigns passed options and initializes success/failure callbacks' do
-      subject.options.should eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
-      subject.success_cb.should be_nil
-      subject.failure_cb.should be_nil
+      expect(subject.options).to eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
+      expect(subject.success_cb).to be_nil
+      expect(subject.failure_cb).to be_nil
     end
   end
 
   describe '#success_cb' do
     it 'allows setting the success callback and calling it' do
-      subject.success_cb.should be_nil
-      cb = proc {|res| raise res }
+      expect(subject.success_cb).to be_nil
+      cb = proc { |res| fail res }
       subject.success_cb = cb
-      subject.success_cb.should eq(cb)
+      expect(subject.success_cb).to eq(cb)
       expect { subject.success_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
 
   describe '#failure_cb' do
     it 'allows setting the failure callback and calling it' do
-      subject.failure_cb.should be_nil
-      cb = proc {|res| raise res }
+      expect(subject.failure_cb).to be_nil
+      cb = proc { |res| fail res }
       subject.failure_cb = cb
-      subject.failure_cb.should eq(cb)
+      expect(subject.failure_cb).to eq(cb)
       expect { subject.failure_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
 
+  describe '#request_bytes' do
+    let(:service) { Test::ResourceService }
+    let(:method) { :find }
+    let(:request) { '' }
+    let(:client_host) { 'myhost.myservice.com' }
+    let(:options) do
+      {
+        :service => service,
+        :method => method,
+        :request => request,
+        :client_host => client_host,
+        :timeout => 60,
+      }
+    end
+
+    let(:expected) do
+      ::Protobuf::Socketrpc::Request.new(
+        :service_name => service.name,
+        :method_name => 'find',
+        :request_proto => '',
+        :caller => client_host
+      )
+    end
+
+    before { allow(subject).to receive(:validate_request_type!).and_return(true) }
+    before { expect(subject).not_to receive(:failure) }
+
+    specify { expect(subject.request_bytes).to eq expected.encode }
+  end
+
+  describe '#request_caller' do
+    specify { expect(subject.request_caller).to eq ::Protobuf.client_host }
+
+    context 'when "client_host" option is given to initializer' do
+      let(:hostname) { 'myhost.myserver.com' }
+      let(:options) { { :client_host => hostname, :timeout => 60 } }
+
+      specify { expect(subject.request_caller).to_not eq ::Protobuf.client_host }
+      specify { expect(subject.request_caller).to eq hostname }
+    end
+  end
+
+  describe "#verify_callbacks" do
+    it "sets @failure_cb to #data_callback when no callbacks are defined" do
+      subject.verify_callbacks
+      expect(subject.instance_variable_get(:@failure_cb)).to eq(subject.method(:data_callback))
+    end
+
+    it "sets @success_cb to #data_callback when no callbacks are defined" do
+      subject.verify_callbacks
+      expect(subject.instance_variable_get(:@success_cb)).to eq(subject.method(:data_callback))
+    end
+
+    it "doesn't set @failure_cb when already defined" do
+      set_cb = -> { true }
+      subject.instance_variable_set(:@failure_cb, set_cb)
+      subject.verify_callbacks
+      expect(subject.instance_variable_get(:@failure_cb)).to eq(set_cb)
+      expect(subject.instance_variable_get(:@failure_cb)).to_not eq(subject.method(:data_callback))
+    end
+
+    it "doesn't set @success_cb when already defined" do
+      set_cb = -> { true }
+      subject.instance_variable_set(:@success_cb, set_cb)
+      subject.verify_callbacks
+      expect(subject.instance_variable_get(:@success_cb)).to eq(set_cb)
+      expect(subject.instance_variable_get(:@success_cb)).to_not eq(subject.method(:data_callback))
+    end
+
+  end
+
+  shared_examples "a ConnectorDisposition" do |meth, stats_meth, cb, *args|
+    let(:stats) { double("Object", :stop => true, :success => true, :failure => true) }
+    before { subject.stats = stats }
+
+    it "calls #complete before exit" do
+      expect(subject).to receive(:complete)
+      subject.method(meth).call(*args)
+    end
+
+    it "calls the #{cb} callback when provided" do
+      some_cb = double("Object")
+
+      subject.instance_variable_set("@#{cb}", some_cb)
+      expect(some_cb).to receive(:call).and_return(true)
+      subject.method(meth).call(*args)
+    end
+
+    it "calls the complete callback when provided" do
+      comp_cb = double("Object")
+
+      subject.instance_variable_set(:@complete_cb, comp_cb)
+      expect(comp_cb).to receive(:call).and_return(true)
+      subject.method(meth).call(*args)
+    end
+
+    it "calls method on stats" do
+      subject.stats = Class.new
+      expected_args = stats_meth == :failure ? args[0] : no_args
+      expect(subject.stats).to receive(stats_meth).once.with(expected_args)
+      allow(subject.stats).to receive(:stop)
+
+      subject.method(meth).call(*args)
+    end
+
+  end
+
+  it_behaves_like("a ConnectorDisposition", :failure, :failure, "failure_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :failure, :failure, "complete_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :succeed, :success, "complete_cb", "response")
+  it_behaves_like("a ConnectorDisposition", :succeed, :success, "success_cb", "response")
+  it_behaves_like("a ConnectorDisposition", :complete, :stop, "complete_cb")
+
 end