protobuf 2.0.0.rc3 → 2.0.0.rc4

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

@@ -5,14 +5,13 @@ describe Protobuf::Rpc::Client do
   before(:each) do
     load 'protobuf/evented.rb'
     ::Protobuf::Rpc::Connector.connector_for_client(true)
-    ::Test::ResourceService.configure(::Test::ResourceService::DEFAULT_LOCATION)
   end
 
   context "when using fiber based calls" do
-    it "waits for response when running synchronously" do
+    it "waits for response" do
       EventMachine.fiber_run do
         StubServer.new(:delay => 3) do |server|
-          client = Test::ResourceService.client(:async => false)
+          client = Test::ResourceService.client
           start = now
 
           client.find(:name => "Test Name", :active => true) do |c|
@@ -33,24 +32,11 @@ describe Protobuf::Rpc::Client do
       end
     end
 
-    it "doesn't wait for response when running async call inside fiber" do
-      EventMachine.fiber_run do
-        StubServer.new(:delay => 3) do |server|
-          client = Test::ResourceService.client(:async => true)
-          start = now
-          client.find(:name => "Test Name", :active => true)
-
-          (now - start).should_not be_within(server.options.delay* 0.10).of(server.options.delay)
-        end
-        EM.stop
-      end
-    end
-
-    it "throws and error when synchronous code is attempted without 'EventMachine.fiber_run'" do
+    it "throws and error when call is attempted without 'EventMachine.fiber_run'" do
       subject = Proc.new do
         EventMachine.run do
           StubServer.new(:delay => 1) do |server|
-            client = Test::ResourceService.client(:async => false)
+            client = Test::ResourceService.client
             client.find(:name => "Test Name", :active => true)
           end
         end
@@ -64,7 +50,7 @@ describe Protobuf::Rpc::Client do
       test_proc = Proc.new do
         EventMachine.fiber_run do
           StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:timeout => 1)
             client.find(:name => "Test Name", :active => true) do |cl|
               cl.on_success {}
               cl.on_failure {|f| error = f}
@@ -83,7 +69,7 @@ describe Protobuf::Rpc::Client do
       it "throws a timeout when client timeout is exceeded" do
         subject = Proc.new do
           StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:timeout => 1)
             client.find(:name => "Test Name", :active => true)
           end
         end
@@ -96,7 +82,7 @@ describe Protobuf::Rpc::Client do
 
         subject = Proc.new do
           StubServer.new(:delay => 2) do |server|
-            client = Test::ResourceService.client(:async => false, :timeout => 1)
+            client = Test::ResourceService.client(:timeout => 1)
             client.find(:name => "Test Name", :active => true) do |c|
               c.on_failure do |f|
                 failure_message = f.message
@@ -114,6 +100,7 @@ describe Protobuf::Rpc::Client do
   end
 
   context 'when creating a client from a service' 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))
@@ -130,26 +117,15 @@ describe Protobuf::Rpc::Client do
       updated_client.options[:port].should eq(54321)
     end
 
-    it 'should be able to define the syncronicity of the client request' do
-      client = Test::ResourceService.client(:async => false)
-      client.options[:async].should be_false
-      client.async?.should be_false
-
-      client = Test::ResourceService.client(:async => true)
-      client.options[:async].should be_true
-      client.async?.should be_true
-    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)
     end
 
     it 'should have a hard default for host and port on a service that has not been configured' do
-      reset_service_location Test::ResourceService
       client = Test::ResourceService.client
-      client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_LOCATION[:host])
-      client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_LOCATION[:port])
+      client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_HOST)
+      client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_PORT)
     end
 
   end
@@ -165,30 +141,6 @@ describe Protobuf::Rpc::Client do
       client.should_receive(:send_request).and_return(nil)
       expect { client.find(nil) }.to_not raise_error
     end
-
-    it 'raises a NameError when accessing a var that does not exist' do
-      pending
-    end
-
-    it 'should be able to set and get local variables within client response blocks' do
-      outer_value = 'OUTER'
-      inner_value = 'INNER'
-      client = Test::ResourceService.client(:async => true)
-
-      EM.should_receive(:reactor_running?).and_return(true)
-      EM.stub!(:next_tick) do
-        client.success_cb.call(inner_value)
-      end
-
-      client.find(nil) do |c|
-        c.on_success do |response|
-          outer_value.should eq('OUTER')
-          outer_value = response
-        end
-      end
-      outer_value.should eq(inner_value)
-    end
-
   end
 
   context 'when receiving request objects' do

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Protobuf::Rpc::Connectors::Base do
 
   let(:opts) do
-    { async: false, timeout: 60 }
+    { :timeout => 60 }
   end
 
   subject { Protobuf::Rpc::Connectors::Base.new(opts) }
@@ -47,42 +47,4 @@ describe Protobuf::Rpc::Connectors::Base do
     end
   end
 
-  describe '#async?' do
-    context 'when provided options[:async] is false' do
-      let(:opts) do
-        { async: false, timeout: 60 }
-      end
-
-      subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-
-      it 'returns false' do
-        subject.async?.should be_false
-      end
-    end
-
-    context 'when provided options[:async] is true' do
-      let(:opts) do
-        { async: true, timeout: 60 }
-      end
-
-      subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-
-      it 'returns true' do
-        subject.async?.should be_true
-      end
-    end
-
-    context 'when options doesn\'t denote async' do
-      let(:opts) do
-        { timeout: 60 }
-      end
-
-      subject { Protobuf::Rpc::Connectors::Base.new(opts) }
-
-      it 'returns false' do
-        subject.async?.should be_false
-      end
-    end
-  end
-
 end

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

@@ -88,8 +88,7 @@ describe Protobuf::Rpc::Connectors::Common do
 
     it "calls #complete before exit" do
       stats = double("Object")
-      stats.stub(:end) { true }
-      stats.stub(:log_stats) { true }
+      stats.stub(:stop) { true }
       subject.stats = stats
 
       subject.should_receive(:complete)
@@ -98,8 +97,7 @@ describe Protobuf::Rpc::Connectors::Common do
 
     it "calls the #{cb} callback when provided" do
       stats = double("Object")
-      stats.stub(:end) { true }
-      stats.stub(:log_stats) { true }
+      stats.stub(:stop) { true }
       subject.stats = stats
       _cb = double("Object")
 
@@ -110,8 +108,7 @@ describe Protobuf::Rpc::Connectors::Common do
 
     it "calls the complete callback when provided" do
       stats = double("Object")
-      stats.stub(:end) { true }
-      stats.stub(:log_stats) { true }
+      stats.stub(:stop) { true }
       subject.stats = stats
       comp_cb = double("Object")
 

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

@@ -33,16 +33,4 @@ describe Protobuf::Rpc::Connectors::Socket do
       subject.instance_variable_get(:@response_data).should eq(data)
     end
   end
-
-  context "#check_async" do
-    it "raises an error when trying to execute asynchronously" do
-      conn = described_class.new(:async => true)
-      expect{ conn.__send__(:check_async) }.to raise_error
-    end
-
-    it "allows execution when synchronous" do
-      conn = described_class.new(:async => false)
-      expect{ conn.__send__(:check_async) }.to_not raise_error
-    end
-  end
 end

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

@@ -18,10 +18,5 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     ::ZMQ::Context.stub(:new).and_return(zmq_context_mock)
   end
 
-  it 'raises if async is true' do
-    expect {
-      described_class.new(async: true).send_request
-    }.to raise_error
-  end
-
+  pending
 end

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

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'protobuf/rpc/service_dispatcher'
+
+describe Protobuf::Rpc::ServiceDispatcher do
+  let(:service_name) { 'Test::ResourceService' }
+  let(:method_name) { 'find' }
+  let(:request) { Test::ResourceFindRequest.new(:name => 'resource') }
+  let(:request_bytes) { request.to_s }
+  let(:response) { Test::Resource.new }
+  let(:wrapper) do
+    Protobuf::Socketrpc::Request.new({ :service_name => service_name,
+                                       :method_name => method_name,
+                                       :request_proto => request_bytes })
+
+  end
+
+  subject { described_class.new(wrapper) }
+
+  context 'creating a new dispatcher' do
+    its(:service) { should be_instance_of service_name.constantize }
+    its(:callable_method) { should be_a(Method) }
+    its(:outer_request) { should eq wrapper }
+    its(:error) { should be_nil }
+
+    context 'when service name is not a valid constant' do
+      let(:service_name) { 'FlibbityGibbit' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::ServiceNotFound) }
+    end
+
+    context 'when method is not defined by the service' do
+      let(:method_name) { 'holly_hooby_whaty' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::MethodNotFound) }
+    end
+
+    context 'when method is defined but is not an rpc method' do
+      before do
+        class Test::Resource
+          def non_rpc_method; end
+        end
+      end
+
+      let(:method_name) { 'non_rpc_method' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::MethodNotFound) }
+    end
+  end
+
+  describe '#invoke!' do
+    context 'regular invocation' do
+      before { subject.callable_method.should_receive(:call) }
+      before { subject.service.stub(:response).and_return(response) }
+      before { subject.invoke! }
+      its(:response) { should be_instance_of Test::Resource }
+      its(:success?) { should be_true }
+    end
+
+    context 'when service responds with' do
+      context 'a hash object' do
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return({ :name => 'returned' }) }
+        before { subject.invoke! }
+        its(:success?) { should be_true }
+        its(:response) { should eq Test::Resource.new(:name => 'returned') }
+      end
+
+      context 'a type not identified by the rpc definition' do
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return("I'm not a valid response") }
+        before { subject.invoke! }
+        its(:error) { should be_instance_of(Protobuf::Rpc::BadResponseProto) }
+      end
+    end
+
+    context 'when service invokes rpc failed callback' do
+      before(:all) do
+        class Test::ResourceService
+          rpc :find_with_rpc_failed, Test::ResourceFindRequest, Test::Resource
+          def find_with_rpc_failed
+            rpc_failed('Find failed')
+          end
+        end
+      end
+
+      let(:method_name) { 'find_with_rpc_failed' }
+      before { subject.service.find_with_rpc_failed }
+
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::RpcFailed) }
+    end
+  end
+
+end

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

@@ -3,75 +3,162 @@ require 'spec/support/test/resource_service'
 
 describe Protobuf::Rpc::Service do
 
-  context 'when configuring' do
+  context 'class methods' do
+    subject { Test::ResourceService }
+
     before :each do
       reset_service_location Test::ResourceService
     end
 
-    it 'should have a default location configured' do
-      Test::ResourceService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
-      Test::ResourceService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
+    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
 
-    it "should be able to pre-configure a service location for clients" do
-      Test::ResourceService.located_at 'google.com:12345'
-      client = Test::ResourceService.client
-      client.options[:host].should == 'google.com'
-      client.options[:port].should == 12345
+    describe '.port=' do
+      before { subject.port = 12345 }
+      its(:port) { should eq 12345 }
     end
 
-    context 'configuring host' do
-      before(:each) { Test::ResourceService.configure :host => 'somehost.com' }
-      after(:each) { Test::ResourceService.configure :host => '127.0.0.1' }
+    describe '.configure' do
+      context 'when providing a host' do
+        before { subject.configure(:host => 'mynewhost.com') }
+        its(:host) { should eq 'mynewhost.com' }
+      end
 
-      it 'should be able to configure and read the host' do
-        Test::ResourceService.host.should == 'somehost.com'
+      context 'when providing a port' do
+        before { subject.configure(:port => 12345) }
+        its(:port) { should eq 12345 }
       end
     end
 
-    it 'should be able to configure and read the port' do
-      Test::ResourceService.configure :port => 12345
-      Test::ResourceService.port.should == 12345
+    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
 
-    it 'should skip configuring location if the location passed does not match host:port syntax' do
-      invalid_locations = [nil, 'myhost:', ':9939', 'badhost123']
-      invalid_locations.each do |location|
-        Test::ResourceService.located_at location
-        Test::ResourceService.host.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:host]
-        Test::ResourceService.port.should == Protobuf::Rpc::Service::DEFAULT_LOCATION[:port]
+    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
-  end
 
-  context 'when server calls the service method' do
+    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
 
-    before(:all) do
-      class ::NewTestService < Protobuf::Rpc::Service
-        rpc :bad_method, Test::ResourceFindRequest, Test::Resource
-        rpc :bad_var, Test::ResourceFindRequest, Test::Resource
-        def bad_method
-          hash = {}
-          hash[:one].explode
+    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
-        def bad_var
-          invalidvar
+      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
 
-    it 'raises an undefined method name error when calling a method on a non-existant object' do
-      expect {
-        req = mock('RequestWrapper', :request_proto => Test::ResourceFindRequest.new(:name => 'mmeh').to_s)
-        ::NewTestService.new.bad_method(req)
-      }.to raise_error(NoMethodError)
-    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
 
-    it 'raises a name error when accessing a non-existant object' do
-      expect {
-        req = mock('RequestWrapper', :request_proto => Test::ResourceFindRequest.new(:name => 'mmeh').to_s)
-        ::NewTestService.new.bad_var(req)
-      }.to raise_error(NameError)
+          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) do
+        Test::ResourceFindRequest.new(:name => 'resource')
+      end
+
+      let(:response) do
+        Test::Resource.new
+      end
+
+
+      context 'when calling the rpc method' do
+        context 'when response is implied' do
+          subject { NewTestService.new(:find_with_implied_response, request.serialize_to_string) }
+
+          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
+          subject { NewTestService.new(:find_with_respond_with, request.serialize_to_string) }
+
+          before { subject.find_with_respond_with }
+          its(:response) { should be_a(Test::Resource) }
+          specify { subject.response.name.should eq 'Custom response' }
+        end
+      end
+
+      context 'when calling rpc_failed in the method' do
+        subject { NewTestService.new(:find_with_rpc_failed, request.serialize_to_string) }
+
+        it 'invokes the rpc_failed callback with the error' do
+          error = nil
+          subject.on_rpc_failed(lambda { |err| error = err })
+          subject.find_with_rpc_failed
+          error.should eq 'This is a failed endpoint'
+          subject.response.name.should eq 'Name will still be set'
+        end
+      end
     end
 
   end