protobuffy 3.1.0

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

@@ -0,0 +1,161 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+describe Protobuf::Rpc::Service do
+
+  context 'class methods' do
+    subject { Test::ResourceService }
+
+    before :each do
+      reset_service_location Test::ResourceService
+    end
+
+    describe '.host' do
+      its(:host) { should eq described_class::DEFAULT_HOST }
+    end
+
+    describe '.host=' do
+      before { subject.host = 'mynewhost.com' }
+      its(:host) { should eq 'mynewhost.com' }
+    end
+
+    describe '.port' do
+      its(:port) { should eq described_class::DEFAULT_PORT }
+    end
+
+    describe '.port=' do
+      before { subject.port = 12345 }
+      its(:port) { should eq 12345 }
+    end
+
+    describe '.configure' do
+      context 'when providing a host' do
+        before { subject.configure(:host => 'mynewhost.com') }
+        its(:host) { should eq 'mynewhost.com' }
+      end
+
+      context 'when providing a port' do
+        before { subject.configure(:port => 12345) }
+        its(:port) { should 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 }
+      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 }
+      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 }
+      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
+      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 }
+    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
+          subject.rpc_method?(:delete).should 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
+        end
+      end
+    end
+  end
+
+  context 'instance methods' do
+    context 'when invoking a service call' do
+      before(:all) do
+        class ::NewTestService < Protobuf::Rpc::Service
+          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) {
+            Protobuf::Rpc::Env.new(
+              'request' => request,
+              'response_type' => response_type
+            )
+          }
+          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' }
+        end
+
+        context 'when using respond_with paradigm' do
+          let(:env) {
+            Protobuf::Rpc::Env.new(
+              'method_name' => :find_with_respond_with,
+              'request' => request
+            )
+          }
+
+          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' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'timecop'
+require 'active_support/core_ext/numeric/time'
+
+describe ::Protobuf::Rpc::Stat do
+
+  before(:all) do
+    unless defined?(BarService)
+      class BarService < ::Struct.new(:method_name); end
+    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
+          stats.to_s.should 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
+        stats.to_s.should 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
+          stats.to_s.should 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
+        stats.to_s.should eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/-"
+      end
+    end
+  end
+
+  describe "statsd_base_path" do
+    let(:stats) { described_class.new(:CLIENT) }
+    subject(:statsd_base_path) { stats.statsd_base_path }
+
+    before :each do
+      stats.service = 'Foo::BarService'
+      stats.method_name = 'find_bars'
+    end
+
+    it "should use correct base path" do
+      expect(statsd_base_path).to eq "rpc.foo.barservice.find_bars"
+    end
+  end
+
+  describe "#stop" do
+    let(:stats) { described_class.new(:CLIENT) }
+    let(:start_time) { Time.now - 3000 }
+    let(:end_time) { Time.now }
+    let(:service) { 'Foo::BarService' }
+    let(:method_name) { 'find_bars' }
+    let(:stats_path) { 'rpc.foo.barservice.find_bars' }
+
+    before :each do
+      stats.service = service
+      stats.method_name = method_name
+      stats.start_time = start_time
+      stats.end_time = end_time
+      stats.stub(:statsd_base_path).and_return(stats_path)
+    end
+
+    subject(:stop) { stats.stop }
+
+    context "when statsd_client hasn't been set" do
+      it "should not raise" do
+        expect{ stop }.not_to raise_error
+      end
+    end
+
+    context "when statsd_client has been set" do
+      let(:statsd_client) { double("Statsd::Client") }
+
+      before :each do
+        Protobuf::Rpc::Stat.statsd_client = statsd_client
+      end
+
+      after :each do
+        Protobuf::Rpc::Stat.statsd_client = nil
+      end
+
+      context "on success" do
+        before :each do
+          stats.success
+        end
+
+        it "should increment the proper stats" do
+          expect(statsd_client).to receive(:increment).with("#{stats_path}.success")
+          expect(statsd_client).to receive(:timing).with("#{stats_path}.time",
+                                                         end_time - start_time)
+
+          stop
+        end
+      end
+
+      context "on failure" do
+        let(:code) { 8 }
+
+        before :each do
+          stats.failure(code)
+        end
+
+        it "should increment the proper stats" do
+          expect(statsd_client).to receive(:increment).with("#{stats_path}.failure.total")
+          expect(statsd_client).to receive(:increment).with("#{stats_path}.failure.#{code}")
+          expect(statsd_client).to receive(:timing).with("#{stats_path}.time",
+                                                         end_time - start_time)
+
+          stop
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'protobuf'
+
+describe ::Protobuf do
+
+  describe '.client_host' do
+    after { ::Protobuf.instance_variable_set(:@_client_host, nil) }
+
+    subject { ::Protobuf.client_host }
+
+    context 'when client_host is not pre-configured' do
+      it { should eq `hostname`.chomp }
+    end
+
+    context 'when client_host is pre-configured' do
+      let(:hostname) { 'override.myhost.com' }
+      before { ::Protobuf.client_host = hostname }
+      it { should 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
+    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
+    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
+    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
+      described_class.gc_pause_server_request?.should be_false
+    end
+
+    it 'is settable' do
+      described_class.gc_pause_server_request = true
+      described_class.gc_pause_server_request?.should 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
+      described_class.print_deprecation_warnings?.should be_true
+    end
+
+    it 'is settable' do
+      described_class.print_deprecation_warnings = false
+      described_class.print_deprecation_warnings?.should 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
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'timeout'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development, :test
+require 'pry'
+
+$: << ::File.expand_path('../..', __FILE__)
+$: << ::File.expand_path('../support', __FILE__)
+
+require 'protobuf'
+require 'protobuf/rpc/server'
+require ::File.expand_path('../support/all', __FILE__)
+
+$: << ::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)
+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
+  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