protobuf-cucumber 3.10.4

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+require "protobuf/zmq"
+
+::RSpec.describe ::Protobuf::Rpc::Connectors::Ping do
+  subject { described_class.new("google.com", 80) }
+
+  let(:host) { "google.com" }
+  let(:port) { 80 }
+
+  describe ".new" do
+    it "assigns host" do
+      expect(subject.host).to eq(host)
+    end
+
+    it "assigns port" do
+      expect(subject.port).to eq(port)
+    end
+  end
+
+  describe "#online?" do
+    it "closes the socket" do
+      socket = double(:close => nil, :setsockopt => nil)
+      allow(subject).to receive(:tcp_socket).and_return(socket)
+      expect(socket).to receive(:close)
+      expect(subject).to be_online
+    end
+
+    context "when a socket can connect" do
+      let(:socket) { double(:close => nil, :setsockopt => nil) }
+      before { allow(subject).to receive(:tcp_socket).and_return(socket) }
+
+      it "returns true" do
+        expect(subject).to be_online
+      end
+    end
+
+    context "when a socket error is raised" do
+      before { allow(subject).to receive(:tcp_socket).and_raise(::Errno::ECONNREFUSED) }
+
+      it "returns false" do
+        expect(subject).to_not be_online
+      end
+    end
+
+    context "when a select timeout is fired" do
+      let(:wait_writable_class) { ::Class.new(StandardError) { include ::IO::WaitWritable } }
+      before { expect_any_instance_of(::Socket).to receive(:connect_nonblock).and_raise(wait_writable_class) }
+
+      it "returns false" do
+        expect(::IO).to receive(:select).and_return(false)
+        expect(subject).to_not be_online
+      end
+    end
+  end
+
+  describe "#timeout" do
+    it "uses the default value" do
+      expect(subject.timeout).to eq(0.2)
+    end
+
+    context "when environment variable is set" do
+      before { ::ENV["PB_RPC_PING_PORT_TIMEOUT"] = "100" }
+
+      it "uses the environmet variable" do
+        expect(subject.timeout).to eq(0.1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'protobuf/socket'
+
+RSpec.shared_examples "a Protobuf Connector" do
+  subject { described_class.new({}) }
+
+  context "API" do
+    # Check the API
+    specify { expect(subject.respond_to?(:send_request, true)).to be true }
+    specify { expect(subject.respond_to?(:post_init, true)).to be true }
+    specify { expect(subject.respond_to?(:close_connection, true)).to be true }
+    specify { expect(subject.respond_to?(:error?, true)).to be true }
+  end
+end
+
+RSpec.describe Protobuf::Rpc::Connectors::Socket do
+  subject { described_class.new({}) }
+
+  it_behaves_like "a Protobuf Connector"
+
+  context "#read_response" do
+    let(:data) { "New data" }
+
+    it "fills the buffer with data from the socket" do
+      socket = StringIO.new("#{data.bytesize}-#{data}")
+      subject.instance_variable_set(:@socket, socket)
+      subject.instance_variable_set(:@stats, OpenStruct.new)
+      expect(subject).to receive(:parse_response).and_return(true)
+
+      subject.__send__(:read_response)
+      expect(subject.instance_variable_get(:@response_data)).to eq(data)
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'protobuf/zmq'
+
+RSpec.describe ::Protobuf::Rpc::Connectors::Zmq do
+  subject { described_class.new(options) }
+
+  let(:options) do
+    {
+      :service => "Test::Service",
+      :method => "find",
+      :timeout => 3,
+      :host => "127.0.0.1",
+      :port => "9400",
+    }
+  end
+
+  let(:socket_double) { double(::ZMQ::Socket, :connect => 0) }
+  let(:zmq_context_double) { double(::ZMQ::Context, :socket => socket_double) }
+
+  before do
+    allow(::ZMQ::Context).to receive(:new).and_return(zmq_context_double)
+    allow(socket_double).to receive(:setsockopt)
+  end
+
+  before(:all) do
+    @ping_port_before = ENV['PB_RPC_PING_PORT']
+  end
+
+  after(:all) do
+    ENV['PB_RPC_PING_PORT'] = @ping_port_before
+  end
+
+  describe "#lookup_server_uri" do
+    let(:service_directory) { double('ServiceDirectory', :running? => running?) }
+    let(:listing) { double('Listing', :address => '127.0.0.2', :port => 9399) }
+    let(:listings) { [listing] }
+    let(:running?) { true }
+
+    before { allow(subject).to receive(:service_directory).and_return(service_directory) }
+
+    context "when the service directory is running" do
+      it "searches the service directory" do
+        allow(service_directory).to receive(:all_listings_for).and_return(listings)
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.2:9399"
+      end
+
+      it "defaults to the options" do
+        allow(service_directory).to receive(:all_listings_for).and_return([])
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
+      end
+    end
+
+    context "when the service directory is not running" do
+      let(:running?) { false }
+
+      it "defaults to the options" do
+        allow(service_directory).to receive(:all_listings_for).and_return([])
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
+      end
+    end
+
+    it "checks if the server is alive" do
+      allow(service_directory).to receive(:all_listings_for).and_return([])
+      expect(subject).to receive(:host_alive?).with("127.0.0.1") { true }
+      expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
+    end
+
+    context "when no host is alive" do
+      it "raises an error" do
+        allow(service_directory).to receive(:all_listings_for).and_return(listings)
+        allow(subject).to receive(:host_alive?).and_return(false)
+        expect { subject.send(:lookup_server_uri) }.to raise_error(RuntimeError)
+      end
+    end
+
+  end
+
+  describe "#host_alive?" do
+    context "when the PB_RPC_PING_PORT is not set" do
+      before do
+        ENV.delete("PB_RPC_PING_PORT")
+      end
+
+      it "returns true" do
+        expect(subject.send(:host_alive?, "yip.yip")).to be true
+      end
+
+      it "does not attempt a connection" do
+        expect(TCPSocket).not_to receive(:new)
+        subject.send(:host_alive?, "blargh.com")
+      end
+    end
+
+    context "when the PB_RPC_PING_PORT is set" do
+      before do
+        ::ENV["PB_RPC_PING_PORT"] = "3307"
+      end
+
+      it "returns true when the connection succeeds" do
+        allow_any_instance_of(::Protobuf::Rpc::Connectors::Ping).to receive(:online?).and_return(true)
+        expect(subject.send(:host_alive?, "huzzah1.com")).to eq(true)
+      end
+
+      it "returns false when the connection fails" do
+        allow_any_instance_of(::Protobuf::Rpc::Connectors::Ping).to receive(:online?).and_return(false)
+        expect(subject.send(:host_alive?, "huzzah2.com")).to eq(false)
+      end
+    end
+  end
+end

data/spec/lib/protobuf/rpc/middleware/exception_handler_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Rpc::Middleware::ExceptionHandler do
+  let(:app) { proc { |env| env } }
+  let(:env) { Protobuf::Rpc::Env.new }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      expect(subject.call(env)).to eq env
+    end
+
+    context "when exceptions occur" do
+      let(:encoded_error) { error.encode }
+      let(:error) { Protobuf::Rpc::MethodNotFound.new('Boom!') }
+
+      before { allow(app).to receive(:call).and_raise(error, 'Boom!') }
+
+      it "rescues exceptions" do
+        expect { subject.call(env) }.not_to raise_exception
+      end
+
+      context "when exception is a Protobuf error" do
+        it "does not wrap the exception in a generic Protobuf error" do
+          stack_env = subject.call(env)
+
+          # Can't compare the error instances because the response has been
+          # raised and thus has a backtrace while the error does not.
+          expect(stack_env.response.class).to eq error.class
+        end
+
+        it "encodes the response" do
+          stack_env = subject.call(env)
+          expect(stack_env.encoded_response).to eq encoded_error
+        end
+      end
+
+      context "when exception is not a Protobuf error" do
+        let(:encoded_error) { error.encode }
+        let(:error) { Protobuf::Rpc::RpcFailed.new('Boom!') }
+
+        before { allow(app).to receive(:call).and_raise(RuntimeError, 'Boom!') }
+
+        it "wraps the exception in a generic Protobuf error" do
+          stack_env = subject.call(env)
+          expect(stack_env.response).to eq error
+        end
+
+        it "encodes the wrapped exception" do
+          stack_env = subject.call(env)
+          expect(stack_env.encoded_response).to eq encoded_error
+        end
+      end
+    end
+  end
+end

data/spec/lib/protobuf/rpc/middleware/logger_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Rpc::Middleware::Logger do
+  let(:app) { proc { |inner_env| inner_env } }
+  let(:env) do
+    Protobuf::Rpc::Env.new(
+      'client_host' => 'client_host.test.co',
+      'encoded_request' => request_wrapper.encode,
+      'encoded_response' => response_wrapper.encode,
+      'method_name' => method_name,
+      'request' => request,
+      'request_type' => rpc_method.request_type,
+      'response' => response,
+      'response_type' => rpc_method.response_type,
+      'rpc_method' => rpc_method,
+      'rpc_service' => service_class,
+      'service_name' => service_name,
+    )
+  end
+  let(:method_name) { :find }
+  let(:request) { request_type.new(:name => 'required') }
+  let(:request_type) { rpc_method.request_type }
+  let(:request_wrapper) do
+    ::Protobuf::Socketrpc::Request.new(
+      :service_name => service_name,
+      :method_name => method_name.to_s,
+      :request_proto => request,
+    )
+  end
+  let(:response_wrapper) { ::Protobuf::Socketrpc::Response.new(:response_proto => response) }
+  let(:response) { rpc_method.response_type.new(:name => 'required') }
+  let(:rpc_method) { service_class.rpcs[method_name] }
+  let(:rpc_service) { service_class.new(env) }
+  let(:service_class) { Test::ResourceService }
+  let(:service_name) { service_class.to_s }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env).and_return(env)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      expect(subject.call(env)).to eq env
+    end
+  end
+end

data/spec/lib/protobuf/rpc/middleware/request_decoder_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Rpc::Middleware::RequestDecoder do
+  let(:app) { proc { |env| env } }
+  let(:client_host) { 'client_host.test.co' }
+  let(:env) do
+    Protobuf::Rpc::Env.new(
+      'encoded_request' => encoded_request,
+      'log_signature' => 'log_signature',
+    )
+  end
+  let(:encoded_request) { request_wrapper.encode }
+  let(:method_name) { :find }
+  let(:request) { request_type.new(:name => 'required') }
+  let(:request_type) { rpc_method.request_type }
+  let(:request_wrapper) do
+    ::Protobuf::Socketrpc::Request.new(
+      :caller => client_host,
+      :service_name => service_name,
+      :method_name => method_name.to_s,
+      :request_proto => request,
+    )
+  end
+  let(:response_type) { rpc_method.response_type }
+  let(:rpc_method) { rpc_service.rpcs[method_name] }
+  let(:rpc_service) { Test::ResourceService }
+  let(:service_name) { rpc_service.to_s }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "decodes the request" do
+      stack_env = subject.call(env)
+      expect(stack_env.request).to eq request
+    end
+
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it "sets Env#client_host" do
+      stack_env = subject.call(env)
+      expect(stack_env.client_host).to eq client_host
+    end
+
+    it "sets Env#service_name" do
+      stack_env = subject.call(env)
+      expect(stack_env.service_name).to eq service_name
+    end
+
+    it "sets Env#method_name" do
+      stack_env = subject.call(env)
+      expect(stack_env.method_name).to eq method_name.to_sym
+    end
+
+    it "sets Env#request_type" do
+      stack_env = subject.call(env)
+      expect(stack_env.request_type).to eq request_type
+    end
+
+    it "sets Env#response_type" do
+      stack_env = subject.call(env)
+      expect(stack_env.response_type).to eq response_type
+    end
+
+    it "sets Env#rpc_method" do
+      stack_env = subject.call(env)
+      expect(stack_env.rpc_method).to eq rpc_method
+    end
+
+    it "sets Env#rpc_service" do
+      stack_env = subject.call(env)
+      expect(stack_env.rpc_service).to eq rpc_service
+    end
+
+    context "when decoding fails" do
+      before { allow(::Protobuf::Socketrpc::Request).to receive(:decode).and_raise(RuntimeError) }
+
+      it "raises a bad request data exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::BadRequestData)
+      end
+    end
+
+    context "when the RPC service is not defined" do
+      let(:request_wrapper) do
+        ::Protobuf::Socketrpc::Request.new(
+          :caller => client_host,
+          :service_name => 'NonexistantService',
+          :method_name => method_name.to_s,
+          :request_proto => request,
+        )
+      end
+
+      it "raises a bad request data exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::ServiceNotFound)
+      end
+    end
+
+    context "when RPC method is not defined" do
+      let(:request_wrapper) do
+        ::Protobuf::Socketrpc::Request.new(
+          :caller => client_host,
+          :service_name => service_name,
+          :method_name => 'foo',
+          :request_proto => request,
+        )
+      end
+
+      it "raises a bad request data exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::MethodNotFound)
+      end
+    end
+  end
+end

data/spec/lib/protobuf/rpc/middleware/response_encoder_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Rpc::Middleware::ResponseEncoder do
+  let(:app) { proc { |env| env.response = response; env } }
+  let(:env) do
+    Protobuf::Rpc::Env.new(
+      'response_type' => Test::Resource,
+      'log_signature' => 'log_signature',
+    )
+  end
+  let(:encoded_response) { response_wrapper.encode }
+  let(:response) { Test::Resource.new(:name => 'required') }
+  let(:response_wrapper) { ::Protobuf::Socketrpc::Response.new(:response_proto => response) }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "encodes the response" do
+      stack_env = subject.call(env)
+      expect(stack_env.encoded_response).to eq encoded_response
+    end
+
+    it "calls the stack" do
+      stack_env = subject.call(env)
+      expect(stack_env.response).to eq response
+    end
+
+    context "when response is responds to :to_hash" do
+      let(:app) { proc { |env| env.response = hashable; env } }
+      let(:hashable) { double('hashable', :to_hash => response.to_hash) }
+
+      it "sets Env#response" do
+        stack_env = subject.call(env)
+        expect(stack_env.response).to eq response
+      end
+    end
+
+    context "when response is responds to :to_proto" do
+      let(:app) { proc { |env| env.response = protoable; env } }
+      let(:protoable) { double('protoable', :to_proto => response) }
+
+      it "sets Env#response" do
+        stack_env = subject.call(env)
+        expect(stack_env.response).to eq response
+      end
+    end
+
+    context "when response is not a valid response type" do
+      let(:app) { proc { |env| env.response = "I'm not a valid response"; env } }
+
+      it "raises a bad response proto exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::BadResponseProto)
+      end
+    end
+
+    context "when response is a Protobuf error" do
+      let(:app) { proc { |env| env.response = error; env } }
+      let(:error) { Protobuf::Rpc::RpcError.new }
+      let(:response_wrapper) { error.to_response }
+
+      it "wraps and encodes the response" do
+        stack_env = subject.call(env)
+        expect(stack_env.encoded_response).to eq encoded_response
+      end
+    end
+
+    context "when encoding fails" do
+      before { allow_any_instance_of(::Protobuf::Socketrpc::Response).to receive(:encode).and_raise(RuntimeError) }
+
+      it "raises a bad request data exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::PbError)
+      end
+    end
+
+    context "when server exists in the env" do
+      let(:env) do
+        Protobuf::Rpc::Env.new(
+          'response_type' => Test::Resource,
+          'log_signature' => 'log_signature',
+          'server'        => 'itsaserver',
+        )
+      end
+
+      it "adds the servers to the response" do
+        expected_response = ::Protobuf::Socketrpc::Response.new(:response_proto => response, :server => 'itsaserver').encode
+        subject.call(env)
+        expect(env.encoded_response).to eq(expected_response)
+      end
+    end
+  end
+end