and-son 0.7.0 → 0.8.0

data/lib/and-son/call_runner.rb

@@ -11,14 +11,17 @@ module AndSon
     DEFAULT_TIMEOUT = 60 # seconds
 
     attr_reader :host, :port
+    attr_reader :before_call_procs, :after_call_procs
     attr_accessor :timeout_value, :params_value, :logger_value
 
     def initialize(host, port)
       @host = host
       @port = port
-      @params_value = {}
+      @params_value  = {}
       @timeout_value = (ENV['ANDSON_TIMEOUT'] || DEFAULT_TIMEOUT).to_f
-      @logger_value = NullLogger.new
+      @logger_value  = NullLogger.new
+      @before_call_procs = []
+      @after_call_procs  = []
     end
 
     # chain runner methods by returning itself
@@ -29,10 +32,14 @@ module AndSon
       if !params.kind_of?(Hash)
         raise ArgumentError, "expected params to be a Hash instead of a #{params.class}"
       end
+      call_params = self.params_value.merge(params)
+
+      self.before_call_procs.each{ |p| p.call(name, call_params, self) }
       client_response = nil
       benchmark = Benchmark.measure do
-        client_response = self.call!(name, params)
+        client_response = call!(name, call_params)
       end
+      self.after_call_procs.each{ |p| p.call(name, call_params, self) }
 
       summary_line = SummaryLine.new({
         'time'    => RoundedTime.new(benchmark.real),
@@ -50,19 +57,6 @@ module AndSon
       end
     end
 
-    def call!(name, params)
-      call_params = self.params_value.merge(params)
-      AndSon::Connection.new(host, port).open do |connection|
-        connection.write(Sanford::Protocol::Request.new(name, call_params).to_hash)
-        connection.close_write
-        if !connection.peek(timeout_value).empty?
-          AndSon::Response.parse(connection.read(timeout_value))
-        else
-          raise AndSon::ConnectionClosedError.new
-        end
-      end
-    end
-
     def hash
       [ self.host,
         self.port,
@@ -77,6 +71,20 @@ module AndSon
     end
     alias :eql? :==
 
+    private
+
+    def call!(name, params)
+      AndSon::Connection.new(host, port).open do |connection|
+        connection.write(Sanford::Protocol::Request.new(name, params).to_hash)
+        connection.close_write
+        if !connection.peek(timeout_value).empty?
+          AndSon::Response.parse(connection.read(timeout_value))
+        else
+          raise AndSon::ConnectionClosedError.new
+        end
+      end
+    end
+
     module InstanceMethods
 
       # define methods here to allow configuring call runner params.  be sure to
@@ -99,6 +107,14 @@ module AndSon
         self.call_runner.tap{ |r| r.logger_value = passed_logger }
       end
 
+      def before_call(&block)
+        self.call_runner.tap{ |r| r.before_call_procs << block }
+      end
+
+      def after_call(&block)
+        self.call_runner.tap{ |r| r.after_call_procs << block }
+      end
+
       private
 
       def stringify_keys(hash)

data/lib/and-son/client.rb

@@ -56,20 +56,28 @@ module AndSon
   class TestClient
     include Client
 
-    attr_accessor :timeout_value, :params_value, :logger_value
     attr_reader :calls, :responses
+    attr_reader :before_call_procs, :after_call_procs
+    attr_accessor :timeout_value, :params_value, :logger_value
 
     def initialize(host, port)
       super
-      @params_value = {}
       @calls = []
       @responses = AndSon::StoredResponses.new
+
+      @params_value = {}
+      @before_call_procs = []
+      @after_call_procs  = []
     end
 
     def call(name, params = nil)
       params ||= {}
+      callback_params = self.params_value.merge(params)
+
       response = self.responses.get(name, params)
+      self.before_call_procs.each{ |p| p.call(name, callback_params, self) }
       self.calls << Call.new(name, params, response.protocol_response)
+      self.after_call_procs.each{ |p| p.call(name, callback_params, self) }
       if block_given?
         yield response.protocol_response
       else
@@ -79,12 +87,12 @@ module AndSon
 
     def call_runner; self; end
 
-    def add_response(*args, &block)
-      self.responses.add(*args, &block)
+    def add_response(name, &block)
+      self.responses.add(name, &block)
     end
 
-    def remove_response(*args)
-      self.responses.remove(*args)
+    def remove_responses(name)
+      self.responses.remove(name)
     end
 
     def reset

data/lib/and-son/stored_responses.rb

@@ -5,47 +5,58 @@ module AndSon
 
   class StoredResponses
 
-    RequestData = Struct.new(:name, :params)
-
     def initialize
-      @hash = Hash.new{ default_response_proc }
+      @hash = Hash.new{ |h, k| h[k] = Stub.new }
     end
 
-    def add(name, params = nil, &response_block)
-      request_data = RequestData.new(name, params || {})
-      @hash[request_data] = response_block
+    def add(name, &block)
+      @hash[name].tap{ |s| s.set_default_proc(&block) }
     end
 
-    def get(name, params = nil)
-      response_block = @hash[RequestData.new(name, params || {})]
-      response = handle_response_block(response_block)
+    def get(name, params)
+      response = @hash[name].call(params)
       AndSon::Response.new(response)
     end
 
-    def remove(name, params = nil)
-      @hash.delete(RequestData.new(name, params || {}))
+    def remove(name)
+      @hash.delete(name)
     end
 
     def remove_all
       @hash.clear
     end
 
-    private
+    class Stub
+      attr_reader :hash
 
-    def handle_response_block(response_block)
-      if response_block.arity == 0 || response_block.arity == -1
-        default_response.tap{ |r| r.data = response_block.call }
-      else
-        default_response.tap{ |r| response_block.call(r) }
+      def initialize
+        @default_proc = proc{ |r| r.data = Hash.new }
+        @hash = {}
       end
-    end
 
-    def default_response
-      Sanford::Protocol::Response.new(200, {})
-    end
+      def set_default_proc(&block)
+        @default_proc = block if block
+      end
+
+      def with(params, &block)
+        @hash[params] = block
+        self
+      end
+
+      def call(params)
+        block = @hash[params] || @default_proc
+        if block.arity == 0 || block.arity == -1
+          default_response.tap{ |r| r.data = block.call }
+        else
+          default_response.tap{ |r| block.call(r) }
+        end
+      end
 
-    def default_response_proc
-      proc{ |r| r.data = Hash.new }
+      private
+
+      def default_response
+        Sanford::Protocol::Response.new(200, {})
+      end
     end
 
   end

data/lib/and-son/version.rb

@@ -1,3 +1,3 @@
 module AndSon
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/test/support/{fake_server.rb → test_server.rb}

@@ -1,6 +1,6 @@
 require 'socket'
 
-class FakeServer
+class TestServer
 
   def initialize(port, options = nil)
     options ||= {}
@@ -16,7 +16,7 @@ class FakeServer
   end
 
   def run
-    server = TCPServer.new("localhost", @port)
+    server = TCPServer.new('127.0.0.1', @port)
     socket = server.accept
 
     if @closing_server
@@ -48,9 +48,9 @@ class FakeServer
     returned = handler.call(request.params)
   end
 
-  module Helper
+  module TestHelpers
 
-    def run_fake_server(server, &block)
+    def run_test_server(server, &block)
       begin
         thread = Thread.new{ server.run }
         yield
@@ -65,12 +65,12 @@ class FakeServer
 
     def start_closing_server(port, &block)
       server = FakeServer.new(port, :closing_server => true)
-      run_fake_server(server, &block)
+      run_test_server(server, &block)
     end
 
     def start_slow_server(port, &block)
       server = FakeServer.new(port, :slow => true)
-      run_fake_server(server, &block)
+      run_test_server(server, &block)
     end
 
   end

data/test/system/client_tests.rb

@@ -0,0 +1,205 @@
+require 'assert'
+require 'and-son/client'
+
+require 'test/support/test_server'
+
+module AndSon::Client
+
+  class SystemTests < Assert::Context
+    desc "AndSon::Client"
+    setup do
+      @host = '127.0.0.1'
+      @port = 12000
+    end
+
+  end
+
+  class UsingTestServerSetupTests < SystemTests
+    include TestServer::TestHelpers
+
+    setup do
+      @test_server = TestServer.new(@port)
+    end
+
+  end
+
+  class SuccessfulRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        [200, params['message']]
+      end
+      @client = AndSon.new(@host, @port)
+    end
+
+    should "return a 200 response" do
+      self.run_test_server(@test_server) do
+
+        params = { 'message' => Factory.string }
+        @client.call(@service_name, params) do |r|
+          assert_equal 200, r.code
+          assert_equal params['message'], r.data
+          assert_nil r.message
+        end
+
+      end
+    end
+
+  end
+
+  class BadRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service that returns a 400"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        [400, Factory.string]
+      end
+      @client = AndSon.new(@host, @port)
+    end
+
+    should "raise a bad request error" do
+      self.run_test_server(@test_server) do
+
+        assert_raises(AndSon::BadRequestError) do
+          @client.call(@service_name)
+        end
+
+      end
+    end
+
+  end
+
+  class NotFoundRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service that returns a 404"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        [404, Factory.string]
+      end
+      @client = AndSon.new(@host, @port)
+    end
+
+    should "raise a not found error" do
+      self.run_test_server(@test_server) do
+
+        assert_raises(AndSon::NotFoundError) do
+          @client.call(@service_name)
+        end
+
+      end
+    end
+
+  end
+
+  class ClientErrorRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service that returns a 4XX"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        code = Factory.integer(99) + 400
+        [code, Factory.string]
+      end
+      @client = AndSon.new(@host, @port)
+    end
+
+    should "raise a client error" do
+      self.run_test_server(@test_server) do
+
+        assert_raises(AndSon::ClientError) do
+          @client.call(@service_name)
+        end
+
+      end
+    end
+
+  end
+
+  class ServerErrorRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service that returns a 4XX"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        code = Factory.integer(99) + 500
+        [code, Factory.string]
+      end
+      @client = AndSon.new(@host, @port)
+    end
+
+    should "raise a server error" do
+      self.run_test_server(@test_server) do
+
+        assert_raises(AndSon::ServerError) do
+          @client.call(@service_name)
+        end
+
+      end
+    end
+
+  end
+
+  class TimeoutRequestTests < UsingTestServerSetupTests
+    desc "when making a request to a service that takes to long to respond"
+    setup do
+      @service_name = Factory.string
+      @test_server.add_handler(@service_name) do |params|
+        sleep 0.2
+        [200, Factory.string]
+      end
+      @client = AndSon.new(@host, @port).timeout(0.1)
+    end
+
+    should "raise a timeout error" do
+      self.run_test_server(@test_server) do
+
+        assert_raises(Sanford::Protocol::TimeoutError) do
+          @client.call(@service_name)
+        end
+
+      end
+    end
+
+  end
+
+  class StoredResponseTests < SystemTests
+    desc "with stored responses"
+    setup do
+      ENV['ANDSON_TEST_MODE'] = 'yes'
+
+      @client = AndSon.new(@host, @port)
+
+      @service_name   = Factory.string
+      @service_params = { Factory.string => Factory.string }
+      @response_data  = Factory.string
+
+      @client.add_response(@service_name){ |r| r.code = 500 }
+      @client.add_response(@service_name).with(@service_params){ @response_data }
+    end
+    teardown do
+      ENV.delete('ANDSON_TEST_MODE')
+    end
+
+    should "return the configured response when the name and params match" do
+      @client.call(@service_name, @service_params) do |r|
+        assert_equal @response_data, r.data
+      end
+    end
+
+    should "return a configured response when only the name matches" do
+      @client.call(@service_name, { Factory.string => Factory.string }) do |r|
+        assert_equal 500, r.code
+        assert_not_equal @response_data, r.data
+      end
+    end
+
+    should "return a default response when the name and params don't match" do
+      @client.call(Factory.string, { Factory.string => Factory.string }) do |r|
+        assert_equal 200, r.code
+        assert_nil r.message
+        assert_equal({}, r.data)
+      end
+    end
+
+  end
+
+end

data/test/unit/call_runner_tests.rb

@@ -29,6 +29,7 @@ class AndSon::CallRunner
     subject{ @call_runner }
 
     should have_readers :host, :port
+    should have_readers :before_call_procs, :after_call_procs
     should have_accessors :params_value, :timeout_value, :logger_value
     should have_imeths :call_runner
 
@@ -37,10 +38,12 @@ class AndSon::CallRunner
       assert_equal @port, subject.port
     end
 
-    should "default its params, timeout and logger" do
+    should "default its params, timeout, logger and callbacks" do
       assert_equal({}, subject.params_value)
       assert_equal 60, subject.timeout_value
       assert_instance_of NullLogger, subject.logger_value
+      assert_equal [], subject.before_call_procs
+      assert_equal [], subject.after_call_procs
     end
 
     should "return itself using `call_runner`" do
@@ -97,6 +100,7 @@ class AndSon::CallRunner
   class InstanceMethodsTests < InitTests
 
     should have_imeths :timeout, :params, :logger
+    should have_imeths :before_call, :after_call
 
     should "set its timeout value and return its call runner using `timeout`" do
       timeout_value = Factory.integer
@@ -136,6 +140,28 @@ class AndSon::CallRunner
       assert_same subject, result
     end
 
+    should "add a before call proc using `before_call`" do
+      callback = proc{ Factory.string }
+      result = subject.before_call(&callback)
+      assert_equal [callback], subject.before_call_procs
+
+      other_callback = proc{ Factory.string }
+      result = subject.before_call(&other_callback)
+      assert_equal 2, subject.before_call_procs.size
+      assert_equal other_callback, subject.before_call_procs.last
+    end
+
+    should "add an after call proc using `after_call`" do
+      callback = proc{ Factory.string }
+      result = subject.after_call(&callback)
+      assert_equal [callback], subject.after_call_procs
+
+      other_callback = proc{ Factory.string }
+      result = subject.after_call(&other_callback)
+      assert_equal 2, subject.after_call_procs.size
+      assert_equal other_callback, subject.after_call_procs.last
+    end
+
   end
 
   class CallSetupTests < InitTests
@@ -158,23 +184,35 @@ class AndSon::CallRunner
   class CallTests < CallSetupTests
     desc "call method"
     setup do
-      @call_bang_name = nil
-      @call_bang_params = nil
-      @call_bang_called = false
-      Assert.stub(@call_runner, :call!) do |name, params|
-        @call_bang_name = name
-        @call_bang_params = params
-        @call_bang_called = true
-        @response
-      end
+      @fake_connection = FakeConnection.new
+      @fake_connection.peek_data = Factory.string(1)
+      @fake_connection.read_data = @protocol_response.to_hash
+      Assert.stub(AndSon::Connection, :new).with(@host, @port){ @fake_connection }
     end
 
-    should "call `call!`" do
-      assert_false @call_bang_called
+    should "open a connection, write a request and close the write stream" do
       subject.call(@name, @params)
-      assert_equal @name, @call_bang_name
-      assert_equal @params, @call_bang_params
-      assert_true @call_bang_called
+
+      protocol_connection = @fake_connection.protocol_connection
+      exp = Sanford::Protocol::Request.new(@name, @params).to_hash
+      assert_equal exp, protocol_connection.write_data
+      assert_true protocol_connection.closed_write
+    end
+
+    should "build a response from reading the server response on the connection" do
+      response_data = subject.call(@name, @params)
+
+      protocol_connection = @fake_connection.protocol_connection
+      assert_equal @call_runner.timeout_value, protocol_connection.peek_timeout
+      assert_equal @call_runner.timeout_value, protocol_connection.read_timeout
+      assert_equal @response.data, response_data
+    end
+
+    should "raise a connection closed error if the server doesn't write a response" do
+      @fake_connection.peek_data = "" # simulate the server not writing a response
+      assert_raise(AndSon::ConnectionClosedError) do
+        subject.call(@name, @params)
+      end
     end
 
     should "return the response data when a block isn't provided" do
@@ -190,7 +228,71 @@ class AndSon::CallRunner
 
     should "default its params when they aren't provided" do
       subject.call(@name)
-      assert_equal({}, @call_bang_params)
+
+      protocol_connection = @fake_connection.protocol_connection
+      exp = Sanford::Protocol::Request.new(@name, {}).to_hash
+      assert_equal exp, protocol_connection.write_data
+    end
+
+    should "merge the passed params with its params value" do
+      subject.params({ Factory.string => Factory.string })
+      merged_params = subject.params_value.merge(@params)
+      subject.call(@name, @params)
+
+      protocol_connection = @fake_connection.protocol_connection
+      exp = Sanford::Protocol::Request.new(@name, merged_params).to_hash
+      assert_equal exp, protocol_connection.write_data
+    end
+
+    should "run before call procs" do
+      yielded_name    = nil
+      yielded_params  = nil
+      yielded_runner  = nil
+      subject.before_call do |name, params, call_runner|
+        yielded_name   = name
+        yielded_params = params
+        yielded_runner = call_runner
+      end
+
+      subject.call(@name, @params)
+      assert_equal @name,   yielded_name
+      assert_equal @params, yielded_params
+      assert_same subject, yielded_runner
+    end
+
+    should "run after call procs" do
+      yielded_name    = nil
+      yielded_params  = nil
+      yielded_runner  = nil
+      subject.after_call do |name, params, call_runner|
+        yielded_name   = name
+        yielded_params = params
+        yielded_runner = call_runner
+      end
+
+      subject.call(@name, @params)
+      assert_equal @name,   yielded_name
+      assert_equal @params, yielded_params
+      assert_same subject, yielded_runner
+    end
+
+    should "run callbacks in the correct order" do
+      n = 0
+      before_call_num = nil
+      after_call_num  = nil
+      call_num        = nil
+      subject.before_call{ before_call_num = n += 1 }
+      subject.after_call{ after_call_num = n += 1 }
+      # the connection should be created between the callbacks
+      Assert.stub(AndSon::Connection, :new).with(@host, @port) do
+        call_num = n += 1
+        @fake_connection
+      end
+
+      subject.call(@name, @params)
+      assert_equal 1, before_call_num
+      assert_equal 2, call_num
+      assert_equal 3, after_call_num
     end
 
     should "log a summary line of the call" do
@@ -211,45 +313,6 @@ class AndSon::CallRunner
 
   end
 
-  class CallBangTests < CallSetupTests
-    desc "the call! method"
-    setup do
-      @call_runner.params({ Factory.string => Factory.string })
-
-      @fake_connection = FakeConnection.new
-      @fake_connection.peek_data = Factory.string(1)
-      @fake_connection.read_data = @protocol_response.to_hash
-      Assert.stub(AndSon::Connection, :new).with(@host, @port){ @fake_connection }
-    end
-
-    should "open a connection, write a request and close the write stream" do
-      subject.call!(@name, @params)
-
-      protocol_connection = @fake_connection.protocol_connection
-      params = @call_runner.params_value.merge(@params)
-      expected = Sanford::Protocol::Request.new(@name, params).to_hash
-      assert_equal expected, protocol_connection.write_data
-      assert_true protocol_connection.closed_write
-    end
-
-    should "build a response from reading the server response on the connection" do
-      response = subject.call!(@name, @params)
-
-      protocol_connection = @fake_connection.protocol_connection
-      assert_equal @call_runner.timeout_value, protocol_connection.peek_timeout
-      assert_equal @call_runner.timeout_value, protocol_connection.read_timeout
-      assert_equal @response, response
-    end
-
-    should "raise a connection closed error if the server doesn't write a response" do
-      @fake_connection.peek_data = "" # simulate the server not writing a response
-      assert_raise(AndSon::ConnectionClosedError) do
-        subject.call!(@name, @params)
-      end
-    end
-
-  end
-
   class FakeConnection
     attr_reader :protocol_connection
 

data/test/unit/client_tests.rb

@@ -6,14 +6,14 @@ module AndSon::Client
   class UnitTests < Assert::Context
     desc "AndSon::Client"
     setup do
-      @current_timeout = ENV['ANDSON_TEST_MODE']
+      @current_test_mode = ENV['ANDSON_TEST_MODE']
       ENV['ANDSON_TEST_MODE'] = 'yes'
 
       @host = Factory.string
       @port = Factory.integer
     end
     teardown do
-      ENV['ANDSON_TEST_MODE'] = @current_timeout
+      ENV['ANDSON_TEST_MODE'] = @current_test_mode
     end
     subject{ AndSon::Client }
 
@@ -127,22 +127,23 @@ module AndSon::Client
       @params = { Factory.string => Factory.string }
 
       @client = AndSon::TestClient.new(@host, @port)
-      data = Factory.string
-      @client.add_response(@name, @params){ data }
-      @response = @client.responses.get(@name, @params)
     end
     subject{ @client }
 
-    should have_accessors :timeout_value, :params_value, :logger_value
     should have_readers :calls, :responses
-    should have_imeths :add_response, :remove_response, :reset
+    should have_readers :before_call_procs, :after_call_procs
+    should have_accessors :timeout_value, :params_value, :logger_value
+    should have_imeths :add_response, :remove_responses, :reset
 
-    should "default its params value" do
-      assert_equal({}, subject.params_value)
+    should "know its calls and stored responses" do
+      assert_equal [], subject.calls
+      assert_instance_of AndSon::StoredResponses, subject.responses
     end
 
-    should "know its stored responses" do
-      assert_instance_of AndSon::StoredResponses, subject.responses
+    should "default its params and callbacks" do
+      assert_equal({}, subject.params_value)
+      assert_equal [], subject.before_call_procs
+      assert_equal [], subject.after_call_procs
     end
 
     should "know its call runner" do
@@ -158,38 +159,106 @@ module AndSon::Client
       assert_instance_of AndSon::TestClient::Call, call
       assert_equal @name, call.request_name
       assert_equal @params, call.request_params
-      assert_equal @response.protocol_response, call.response
+      assert_instance_of Sanford::Protocol::Response, call.response
     end
 
-    should "return a stored response using `call`" do
-      assert_equal @response.data, subject.call(@name, @params)
+    should "return a stored response's data using `call`" do
+      exp = subject.responses.get(@name, @params)
+      assert_equal exp.data, subject.call(@name, @params)
     end
 
     should "yield a stored response using `call` with a block" do
       yielded = nil
       subject.call(@name, @params){ |response| yielded = response }
-      assert_equal @response.protocol_response, yielded
+      exp = subject.responses.get(@name, @params)
+      assert_equal exp.protocol_response, yielded
+    end
+
+    should "run before call procs" do
+      subject.params({ Factory.string => Factory.string })
+      yielded_name    = nil
+      yielded_params  = nil
+      yielded_runner  = nil
+      subject.before_call do |name, params, call_runner|
+        yielded_name   = name
+        yielded_params = params
+        yielded_runner = call_runner
+      end
+
+      subject.call(@name, @params)
+      assert_equal @name,   yielded_name
+      exp = subject.params_value.merge(@params)
+      assert_equal exp, yielded_params
+      assert_same subject, yielded_runner
+    end
+
+    should "run after call procs" do
+      subject.params({ Factory.string => Factory.string })
+      yielded_name    = nil
+      yielded_params  = nil
+      yielded_runner  = nil
+      subject.after_call do |name, params, call_runner|
+        yielded_name   = name
+        yielded_params = params
+        yielded_runner = call_runner
+      end
+
+      subject.call(@name, @params)
+      assert_equal @name,   yielded_name
+      exp = subject.params_value.merge(@params)
+      assert_equal exp, yielded_params
+      assert_same subject, yielded_runner
+    end
+
+    should "run callbacks in the correct order" do
+      n = 0
+      before_call_num = nil
+      after_call_num  = nil
+      subject.before_call{ before_call_num = n += 1 }
+      subject.after_call{ after_call_num = n += 1 }
+
+      subject.call(@name, @params)
+      assert_equal 1, before_call_num
+      assert_equal 2, after_call_num
     end
 
     should "allow adding/removing stored responses" do
       data = Factory.string
-      subject.add_response(@name, @params){ data }
+      subject.add_response(@name).with(@params){ data }
       response = subject.responses.get(@name, @params)
       assert_equal data, response.data
 
-      subject.remove_response(@name, @params)
+      subject.remove_responses(@name)
+      response = subject.responses.get(@name, @params)
+      assert_not_equal data, response.data
+    end
+
+    should "return a stored response stub using `add_response`" do
+      stub = subject.add_response(@name)
+      assert_instance_of AndSon::StoredResponses::Stub, stub
+
+      data = Factory.string
+      stub.with(@params){ data }
       response = subject.responses.get(@name, @params)
+      assert_equal data, response.data
+
+      response = subject.responses.get(@name, {
+        Factory.string => Factory.string
+      })
       assert_not_equal data, response.data
     end
 
     should "clear its calls and remove all its configured responses using `reset`" do
       subject.call(@name, @params)
-      assert_not_equal [], subject.calls
-      assert_equal @response, subject.responses.get(@name, @params)
+      data = Factory.string
+      subject.add_response(@name).with(@params){ data }
+
+      assert_not_empty subject.calls
+      assert_equal data, subject.responses.get(@name, @params).data
 
       subject.reset
-      assert_equal [], subject.calls
-      assert_not_equal @response, subject.responses.get(@name, @params)
+      assert_empty subject.calls
+      assert_not_equal data, subject.responses.get(@name, @params).data
     end
 
     should "be comparable" do

data/test/unit/stored_responses_tests.rb

@@ -17,42 +17,50 @@ class AndSon::StoredResponses
     should have_imeths :add, :get, :remove, :remove_all
 
     should "allow adding and getting responses with response data" do
-      subject.add(@name, @params){ @response_data }
-      protocol_response = subject.get(@name, @params).protocol_response
+      subject.add(@name){ @response_data }
+      protocol_response = subject.get(@name, {}).protocol_response
+
       assert_equal 200, protocol_response.code
       assert_nil protocol_response.status.message
       assert_equal @response_data, protocol_response.data
     end
 
-    should "allow adding and gettings responses being yielded a response" do
-      code = Factory.integer
+    should "allow adding and getting responses when yielded a response" do
+      code    = Factory.integer
       message = Factory.string
-      data = Factory.string
+      data    = Factory.string
 
       yielded = nil
-      subject.add(@name, @params) do |response|
+      subject.add(@name) do |response|
         yielded = response
-        response.code = code
+        response.code    = code
         response.message = message
-        response.data = data
+        response.data    = data
       end
-      protocol_response = subject.get(@name, @params).protocol_response
+      protocol_response = subject.get(@name, {}).protocol_response
 
       assert_instance_of Sanford::Protocol::Response, yielded
-      assert_equal code, protocol_response.code
+      assert_equal code,    protocol_response.code
       assert_equal message, protocol_response.message
-      assert_equal data, protocol_response.data
+      assert_equal data,    protocol_response.data
     end
 
-    should "allow adding and getting responses with no params" do
-      subject.add(@name){ @response_data }
-      protocol_response = subject.get(@name).protocol_response
-      assert_equal @response_data, protocol_response.data
-    end
+    should "return a stub when adding a response" do
+      stub = subject.add(@name)
+      assert_instance_of AndSon::StoredResponses::Stub, stub
 
-    should "return a default response for a name/params that isn't configured" do
+      stub.with(@params){ @response_data }
       response = subject.get(@name, @params)
+      assert_equal @response_data, response.data
+
+      response = subject.get(@name, {})
+      assert_not_equal @response_data, response.data
+    end
+
+    should "return a default response for a service that isn't configured" do
+      response = subject.get(@name, {})
       protocol_response = response.protocol_response
+
       assert_equal 200, protocol_response.code
       assert_nil protocol_response.status.message
       assert_equal({}, protocol_response.data)
@@ -62,41 +70,81 @@ class AndSon::StoredResponses
       called = false
       subject.add(@name){ called = true }
       assert_false called
-      subject.get(@name)
+      subject.get(@name, {})
       assert_true called
     end
 
-    should "allow removing a response" do
-      subject.add(@name, @params){ @response_data }
-      protocol_response = subject.get(@name, @params).protocol_response
-      assert_equal @response_data, protocol_response.data
-
-      subject.remove(@name, @params)
-      protocol_response = subject.get(@name, @params).protocol_response
-      assert_not_equal @response_data, protocol_response.data
-    end
-
-    should "allow removing a response without params" do
+    should "allow removing a stub" do
       subject.add(@name){ @response_data }
-      protocol_response = subject.get(@name).protocol_response
+      protocol_response = subject.get(@name, {}).protocol_response
       assert_equal @response_data, protocol_response.data
 
       subject.remove(@name)
-      protocol_response = subject.get(@name).protocol_response
+      protocol_response = subject.get(@name, {}).protocol_response
       assert_not_equal @response_data, protocol_response.data
     end
 
     should "allow removing all responses" do
-      subject.add(@name, @params){ @response_data }
       subject.add(@name){ @response_data }
+      other_name = Factory.string
+      subject.add(other_name){ @response_data }
 
       subject.remove_all
-      protocol_response = subject.get(@name, @params).protocol_response
+      protocol_response = subject.get(@name, {}).protocol_response
       assert_not_equal @response_data, protocol_response.data
-      protocol_response = subject.get(@name).protocol_response
+      protocol_response = subject.get(other_name, {}).protocol_response
       assert_not_equal @response_data, protocol_response.data
     end
 
   end
 
+  class StubTests < UnitTests
+    desc "Stub"
+    setup do
+      @stub = Stub.new
+    end
+    subject{ @stub }
+
+    should have_readers :hash
+    should have_imeths :set_default_proc, :with, :call
+
+    should "default its default response proc" do
+      response = subject.call(@params)
+      assert_equal({}, response.data)
+    end
+
+    should "allow settings its default proc" do
+      data = Factory.string
+      subject.set_default_proc{ |r| r.data = data }
+      response = subject.call(@params)
+      assert_equal data, response.data
+    end
+
+    should "allow setting responses for specific params" do
+      response = subject.call(@params)
+      assert_equal({}, response.data)
+
+      data = Factory.string
+      subject.with(@params){ |r| r.data = data }
+      response = subject.call(@params)
+      assert_equal data, response.data
+    end
+
+    should "yield a response when a response block expects an arg" do
+      yielded = nil
+      subject.with(@params){ |r| yielded = r }
+      exp = Sanford::Protocol::Response.new(200, {})
+      assert_equal exp, subject.call(@params)
+      assert_equal exp, yielded
+    end
+
+    should "set a response data when the response block doesn't expect an arg" do
+      data = Factory.string
+      subject.with(@params){ data  }
+      exp = Sanford::Protocol::Response.new(200, data)
+      assert_equal exp, subject.call(@params)
+    end
+
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: and-son
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 63
   prerelease: 
   segments: 
   - 0
-  - 7
+  - 8
   - 0
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-09-29 00:00:00 Z
+date: 2014-12-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -74,8 +74,8 @@ files:
 - lib/and-son/version.rb
 - test/helper.rb
 - test/support/factory.rb
-- test/support/fake_server.rb
-- test/system/making_requests_tests.rb
+- test/support/test_server.rb
+- test/system/client_tests.rb
 - test/unit/and-son_tests.rb
 - test/unit/call_runner_tests.rb
 - test/unit/client_tests.rb
@@ -117,8 +117,8 @@ summary: Simple Sanford client for Ruby.
 test_files: 
 - test/helper.rb
 - test/support/factory.rb
-- test/support/fake_server.rb
-- test/system/making_requests_tests.rb
+- test/support/test_server.rb
+- test/system/client_tests.rb
 - test/unit/and-son_tests.rb
 - test/unit/call_runner_tests.rb
 - test/unit/client_tests.rb

data/test/system/making_requests_tests.rb

@@ -1,194 +0,0 @@
-require 'assert'
-require 'and-son'
-
-require 'test/support/fake_server'
-
-class MakingRequestsTests < Assert::Context
-  include FakeServer::Helper
-
-  desc "making a request that"
-  setup do
-    @fake_server = FakeServer.new(12000)
-  end
-
-  class SuccessTests < MakingRequestsTests
-    desc "returns a successful response"
-    setup do
-      @fake_server.add_handler('echo'){|params| [ 200, params['message'] ] }
-    end
-
-    should "get a 200 response with the parameter echoed back" do
-      self.run_fake_server(@fake_server) do
-
-        client = AndSon.new('localhost', 12000)
-        client.call('echo', :message => 'test') do |response|
-          assert_equal 200,     response.status.code
-          assert_equal nil,     response.status.message
-          assert_equal 'test',  response.data
-        end
-
-      end
-    end
-
-  end
-
-  class WithStoredResponsesTests < MakingRequestsTests
-    desc "is stored with and-son and with testing ENV var set"
-    setup do
-      ENV['ANDSON_TEST_MODE'] = 'yes'
-    end
-    teardown do
-      ENV.delete('ANDSON_TEST_MODE')
-    end
-
-    should "return the registered response" do
-      client = AndSon.new('localhost', 12000)
-      client.add_response('echo', 'message' => 'test'){ 'test' }
-
-      client.call('echo', 'message' => 'test') do |response|
-        assert_equal 200,     response.code
-        assert_equal nil,     response.status.message
-        assert_equal 'test',  response.data
-      end
-    end
-
-  end
-
-  class AuthorizeTests < MakingRequestsTests
-    setup do
-      @fake_server.add_handler('authorize_it') do |params|
-        if params['api_key'] == 12345
-          [ 200, params['data'] ]
-        else
-          [ 401, params['data'] ]
-        end
-      end
-    end
-
-    should "get a 200 response when api_key is passed with the correct value" do
-      self.run_fake_server(@fake_server) do
-
-        client = AndSon.new('localhost', 12000).params({ 'api_key' => 12345 })
-        client.call('authorize_it', { 'data' => 'holla' }) do |response|
-          assert_equal 200,     response.status.code
-          assert_equal nil,     response.status.message
-          assert_equal 'holla', response.data
-        end
-
-      end
-    end
-
-    should "get a 401 response when api_key isn't passed" do
-      self.run_fake_server(@fake_server) do
-
-        client = AndSon.new('localhost', 12000)
-        client.call('authorize_it', { 'data' => 'holla' }) do |response|
-          assert_equal 401,     response.status.code
-          assert_equal nil,     response.status.message
-          assert_equal 'holla', response.data
-        end
-
-      end
-    end
-
-  end
-
-  class Failure400Tests < MakingRequestsTests
-    desc "when a request fails with a 400"
-    setup do
-      @fake_server.add_handler('400'){|params| [ 400, false ] }
-    end
-
-    should "raise a bad request error" do
-      self.run_fake_server(@fake_server) do
-
-        assert_raises(AndSon::BadRequestError) do
-          client = AndSon.new('localhost', 12000)
-          client.call('400')
-        end
-
-      end
-    end
-
-  end
-
-  class Failure404Tests < MakingRequestsTests
-    desc "when a request fails with a 404"
-    setup do
-      @fake_server.add_handler('404'){|params| [ 404, false ] }
-    end
-
-    should "raise a not found error" do
-      self.run_fake_server(@fake_server) do
-
-        assert_raises(AndSon::NotFoundError) do
-          client = AndSon.new('localhost', 12000)
-          client.call('404')
-        end
-
-      end
-    end
-
-  end
-
-  class Failure4xxTests < MakingRequestsTests
-    desc "when a request fails with a 4xx"
-    setup do
-      @fake_server.add_handler('4xx'){|params| [ 402, false ] }
-    end
-
-    should "raise a client error" do
-      self.run_fake_server(@fake_server) do
-
-        assert_raises(AndSon::ClientError) do
-          client = AndSon.new('localhost', 12000)
-          client.call('4xx')
-        end
-
-      end
-    end
-
-  end
-
-  class Failure5xxTests < MakingRequestsTests
-    desc "when a request fails with a 5xx"
-    setup do
-      @fake_server.add_handler('5xx'){|params| [ 500, false ] }
-    end
-
-    should "raise a server error" do
-      self.run_fake_server(@fake_server) do
-
-        assert_raises(AndSon::ServerError) do
-          client = AndSon.new('localhost', 12000)
-          client.call('5xx')
-        end
-
-      end
-    end
-
-  end
-
-  class TimeoutErrorTests < MakingRequestsTests
-    desc "when a request takes to long to respond"
-    setup do
-      @fake_server.add_handler('forever') do |params|
-        sleep 0.2
-        [ 200, true ]
-      end
-    end
-
-    should "raise a timeout error" do
-      self.run_fake_server(@fake_server) do
-
-        assert_raises(Sanford::Protocol::TimeoutError) do
-          client = AndSon.new('localhost', 12000)
-          client.timeout(0.1).call('forever')
-        end
-
-      end
-    end
-
-  end
-
-end