and-son 0.6.1 → 0.7.0

data/test/unit/call_runner_tests.rb

@@ -0,0 +1,287 @@
+require 'assert'
+require 'and-son/call_runner'
+
+require 'sanford-protocol/fake_connection'
+
+class AndSon::CallRunner
+
+  class UnitTests < Assert::Context
+    desc "AndSon::CallRunner"
+    setup do
+      @host = Factory.string
+      @port = Factory.integer
+
+      @call_runner_class = AndSon::CallRunner
+    end
+    subject{ @call_runner_class }
+
+    should "include the call runner instance methods" do
+      assert_includes AndSon::CallRunner::InstanceMethods, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @call_runner = @call_runner_class.new(@host, @port)
+    end
+    subject{ @call_runner }
+
+    should have_readers :host, :port
+    should have_accessors :params_value, :timeout_value, :logger_value
+    should have_imeths :call_runner
+
+    should "know its host and port" do
+      assert_equal @host, subject.host
+      assert_equal @port, subject.port
+    end
+
+    should "default its params, timeout and logger" do
+      assert_equal({}, subject.params_value)
+      assert_equal 60, subject.timeout_value
+      assert_instance_of NullLogger, subject.logger_value
+    end
+
+    should "return itself using `call_runner`" do
+      assert_same subject, subject.call_runner
+    end
+
+    should "be comparable" do
+      matching = @call_runner_class.new(@host, @port)
+      assert_equal matching, subject
+
+      not_matching = @call_runner_class.new(Factory.string, @port)
+      assert_not_equal not_matching, subject
+      not_matching = @call_runner_class.new(@host, Factory.integer)
+      assert_not_equal not_matching, subject
+      params = { Factory.string => Factory.string }
+      not_matching = @call_runner_class.new(@host, @port).params(params)
+      assert_not_equal not_matching, subject
+      not_matching = @call_runner_class.new(@host, @port).logger(Factory.string)
+      assert_not_equal not_matching, subject
+      not_matching = @call_runner_class.new(@host, @port).timeout(Factory.integer)
+      assert_not_equal not_matching, subject
+    end
+
+    should "be hash comparable" do
+      assert_equal subject.call_runner.hash, subject.hash
+
+      matching = @call_runner_class.new(@host, @port)
+      assert_true subject.eql?(matching)
+      not_matching = @call_runner_class.new(Factory.string, Factory.integer)
+      assert_false subject.eql?(not_matching)
+    end
+
+  end
+
+  class InitWithTimeoutEnvVarTests < UnitTests
+    desc "when init with the timeout env var set"
+    setup do
+      @current_timeout = ENV['ANDSON_TIMEOUT']
+      ENV['ANDSON_TIMEOUT'] = Factory.integer.to_s
+
+      @call_runner = @call_runner_class.new(@host, @port)
+    end
+    teardown do
+      ENV['ANDSON_TIMEOUT'] = @current_timeout
+    end
+    subject{ @call_runner }
+
+    should "set its timeout value using the env var" do
+      assert_equal ENV['ANDSON_TIMEOUT'].to_f, subject.timeout_value
+    end
+
+  end
+
+  class InstanceMethodsTests < InitTests
+
+    should have_imeths :timeout, :params, :logger
+
+    should "set its timeout value and return its call runner using `timeout`" do
+      timeout_value = Factory.integer
+      result = subject.timeout(timeout_value)
+      assert_equal timeout_value, subject.timeout_value
+      assert_same subject, result
+    end
+
+    should "update its params value and return its call runner using `params`" do
+      params_value = { Factory.string => Factory.string }
+      result = subject.params(params_value)
+      assert_equal params_value, subject.params_value
+      assert_same subject, result
+
+      new_key = Factory.string
+      new_value = Factory.string
+      subject.params({ new_key => new_value })
+      assert_equal 2, subject.params_value.keys.size
+      assert_equal new_value, subject.params_value[new_key]
+    end
+
+    should "stringify any values passed to `params`" do
+      key = Factory.string
+      value = Factory.string
+      subject.params({ key.to_sym => value })
+      assert_equal({ key => value }, subject.params_value)
+    end
+
+    should "raise an argument error when `params` is not passed a hash" do
+      assert_raises(ArgumentError){ subject.params(Factory.string) }
+    end
+
+    should "set its logger value and return its call runner using `logger`" do
+      logger_value = Factory.string
+      result = subject.logger(logger_value)
+      assert_equal logger_value, subject.logger_value
+      assert_same subject, result
+    end
+
+  end
+
+  class CallSetupTests < InitTests
+    setup do
+      @name = Factory.string
+      @params = { Factory.string => Factory.string }
+
+      @logger_spy = LoggerSpy.new
+      @call_runner.logger(@logger_spy)
+
+      @protocol_response = Sanford::Protocol::Response.new(
+        [200, Factory.string],
+        Factory.string
+      )
+      @response = AndSon::Response.new(@protocol_response)
+    end
+
+  end
+
+  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
+    end
+
+    should "call `call!`" do
+      assert_false @call_bang_called
+      subject.call(@name, @params)
+      assert_equal @name, @call_bang_name
+      assert_equal @params, @call_bang_params
+      assert_true @call_bang_called
+    end
+
+    should "return the response data when a block isn't provided" do
+      result = subject.call(@name, @params)
+      assert_equal @response.data, result
+    end
+
+    should "yield the protocol response when a block is provided" do
+      yielded = nil
+      subject.call(@name, @params){ |response| yielded = response }
+      assert_equal @protocol_response, yielded
+    end
+
+    should "default its params when they aren't provided" do
+      subject.call(@name)
+      assert_equal({}, @call_bang_params)
+    end
+
+    should "log a summary line of the call" do
+      subject.call(@name, @params)
+      assert_match /\A\[AndSon\]/, @logger_spy.output
+      assert_match /time=\d+.\d+/, @logger_spy.output
+      assert_match /status=#{@protocol_response.code}/, @logger_spy.output
+      host_and_port = "#{@host}:#{@port}"
+      assert_match /host=#{host_and_port.inspect}/, @logger_spy.output
+      assert_match /service=#{@name.inspect}/, @logger_spy.output
+      regex = Regexp.new(Regexp.escape("params=#{@params.inspect}"))
+      assert_match regex, @logger_spy.output
+    end
+
+    should "raise an argument error when not passed a hash for params" do
+      assert_raises(ArgumentError){ subject.call(@name, Factory.string) }
+    end
+
+  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
+
+    def initialize
+      @protocol_connection = Sanford::Protocol::FakeConnection.new
+    end
+
+    def open
+      yield @protocol_connection if block_given?
+    ensure
+      @protocol_connection.close if @protocol_connection
+    end
+
+    def peek_data=(value)
+      @protocol_connection.peek_data = value
+    end
+
+    def read_data=(value)
+      @protocol_connection.read_data = value
+    end
+  end
+
+  class LoggerSpy
+    attr_reader :output
+
+    def initialize
+      @output = ""
+    end
+
+    def info(message)
+      @output += "#{message}\n"
+    end
+  end
+
+end

data/test/unit/client_tests.rb

@@ -1,135 +1,270 @@
 require 'assert'
 require 'and-son/client'
 
-require 'and-son/stored_responses'
-require 'test/support/fake_connection'
-require 'test/support/fake_server'
-
-class AndSon::Client
+module AndSon::Client
 
   class UnitTests < Assert::Context
-    include FakeServer::Helper
-
     desc "AndSon::Client"
     setup do
-      @host, @port = '0.0.0.0', 8000
-      @client = AndSon::Client.new(@host, @port)
+      @current_timeout = ENV['ANDSON_TEST_MODE']
+      ENV['ANDSON_TEST_MODE'] = 'yes'
+
+      @host = Factory.string
+      @port = Factory.integer
     end
-    subject{ @client }
+    teardown do
+      ENV['ANDSON_TEST_MODE'] = @current_timeout
+    end
+    subject{ AndSon::Client }
 
-    should have_imeths :host, :port, :responses
-    should have_imeths :call_runner, :call, :timeout, :logger, :params
+    should have_imeths :new
 
-    should "know its default call runner" do
-      default_runner = subject.call_runner
+    should "return an and-son client using `new`" do
+      ENV.delete('ANDSON_TEST_MODE')
+      client = subject.new(@host, @port)
+      assert_instance_of AndSon::AndSonClient, client
+    end
 
-      assert_equal @host, default_runner.host
-      assert_equal @port, default_runner.port
-      assert_equal 60.0, default_runner.timeout_value
-      assert_instance_of AndSon::NullLogger, default_runner.logger_value
+    should "return a test client using `new` in test mode" do
+      client = subject.new(@host, @port)
+      assert_instance_of AndSon::TestClient, client
     end
 
-    should "override the default call runner timeout with an env var" do
-      prev = ENV['ANDSON_TIMEOUT']
-      ENV['ANDSON_TIMEOUT'] = '20'
+  end
 
-      assert_equal 20.0, subject.call_runner.timeout_value
+  class MixinTests < UnitTests
+    desc "as a mixin"
+    setup do
+      @client_class = Class.new do
+        include AndSon::Client
+      end
+    end
+    subject{ @client_class }
 
-      ENV['ANDSON_TIMEOUT'] = prev
+    should "include the call runner instance methods" do
+      assert_includes AndSon::CallRunner::InstanceMethods, subject
     end
 
-    should "return a CallRunner with a timeout value set #timeout" do
-      runner = subject.timeout(10)
+  end
 
-      assert_kind_of AndSon::CallRunner, runner
-      assert_respond_to :call, runner
-      assert_equal 10.0, runner.timeout_value
+  class InitTests < MixinTests
+    desc "when init"
+    setup do
+      @client = @client_class.new(@host, @port)
     end
+    subject{ @client }
 
-    should "return a CallRunner with params_value set using #params and stringify " \
-           "the params hash" do
-      runner = subject.params({ :api_key => 12345 })
+    should have_readers :host, :port
 
-      assert_kind_of AndSon::CallRunner, runner
-      assert_respond_to :call, runner
-      assert_equal({ "api_key" => 12345 }, runner.params_value)
+    should "know its host and port" do
+      assert_equal @host, subject.host
+      assert_equal @port, subject.port
     end
 
-    should "return a CallRunner with a logger value set #logger" do
-      runner = subject.logger(logger = Logger.new(STDOUT))
+  end
 
-      assert_kind_of AndSon::CallRunner, runner
-      assert_respond_to :call, runner
-      assert_equal logger, runner.logger_value
+  class AndSonClientTests < UnitTests
+    desc "AndSonClient"
+    setup do
+      @client = AndSon::AndSonClient.new(@host, @port)
     end
+    subject{ @client }
 
-    should "raise an ArgumentError when #params is not passed a Hash" do
-      assert_raises(ArgumentError) do
-        subject.params('test')
-      end
+    should have_imeths :call, :call_runner
+
+    should "know its call runner" do
+      runner = subject.call_runner
+      assert_instance_of AndSon::CallRunner, runner
+      assert_equal subject.host, runner.host
+      assert_equal subject.port, runner.port
+      assert_not_same runner, subject.call_runner
+    end
+
+    should "be comparable" do
+      matching = AndSon::AndSonClient.new(@host, @port)
+      assert_equal matching, subject
+
+      not_matching = AndSon::AndSonClient.new(Factory.string, Factory.integer)
+      assert_not_equal not_matching, subject
     end
-    should "track its stored responses" do
-      assert_kind_of AndSon::StoredResponses, subject.responses
+
+    should "be hash comparable" do
+      assert_equal subject.call_runner.hash, subject.hash
+
+      matching = AndSon::AndSonClient.new(@host, @port)
+      assert_true subject.eql?(matching)
+      not_matching = AndSon::AndSonClient.new(Factory.string, Factory.integer)
+      assert_false subject.eql?(not_matching)
     end
 
   end
 
-  class CallTest < UnitTests
-    desc "call"
+  class AndSonClientCallTests < AndSonClientTests
+    desc "call method"
     setup do
-      @connection = AndSon::Connection.new('localhost', 12001)
-      @response = AndSon::Response.parse({ 'status' => [200] })
-      @fake_connection = FakeConnection.new
-      Assert.stub(AndSon::Connection, :new){ @connection }
+      @call_runner_spy = CallRunnerSpy.new
+      Assert.stub(AndSon::CallRunner, :new){ @call_runner_spy }
+
+      @service_name = Factory.string
+      @service_params = { Factory.string => Factory.string }
+      @response_block = proc{ Factory.string }
+
+      @response = subject.call(@service_name, @service_params, &@response_block)
     end
 
-    should "write a request to the connection" do
-      Assert.stub(@connection, :open) do |&block|
-        block.call(@fake_connection)
-        @response
-      end
+    should "call `call` on its call runner and return its response" do
+      assert_equal [@service_name, @service_params], @call_runner_spy.call_args
+      assert_equal @response_block, @call_runner_spy.call_block
+      assert_equal @call_runner_spy.call_response, @response
+    end
+
+  end
 
-      client = AndSon::Client.new('localhost', 12001).call('echo', {
-        :message => 'test'
-      })
+  class TestClientTests < UnitTests
+    desc "TestClient"
+    setup do
+      @name = Factory.string
+      @params = { Factory.string => Factory.string }
 
-      request_data = @fake_connection.written.first
-      assert_equal 'echo',                  request_data['name']
-      assert_equal({ 'message' => 'test' }, request_data['params'])
+      @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 "close the write stream" do
-      Assert.stub(@connection, :open) do |&block|
-        block.call(@fake_connection)
-        @response
-      end
+    should have_accessors :timeout_value, :params_value, :logger_value
+    should have_readers :calls, :responses
+    should have_imeths :add_response, :remove_response, :reset
+
+    should "default its params value" do
+      assert_equal({}, subject.params_value)
+    end
 
-      client = AndSon::Client.new('localhost', 12001).call('echo', {
-        :message => 'test'
-      })
+    should "know its stored responses" do
+      assert_instance_of AndSon::StoredResponses, subject.responses
+    end
 
-      assert @fake_connection.write_stream_closed?
+    should "know its call runner" do
+      subject
     end
 
-    should "raise an ArgumentError when #call is not passed a Hash for params" do
-      client = AndSon::Client.new('localhost', 12001)
-      runner = client.timeout(0.1) # in case it actually tries to make the request
+    should "store each call made in its `calls`" do
+      assert_equal [], subject.calls
+      subject.call(@name, @params)
+      assert_equal 1, subject.calls.size
 
-      assert_raises(ArgumentError) do
-        runner.call('something', 'test')
-      end
+      call = subject.calls.last
+      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
     end
 
-    should "raise a ConnectionClosedError when the server closes the connection" do
-      self.start_closing_server(12001) do
-        client = AndSon::Client.new('localhost', 12001)
+    should "return a stored response using `call`" do
+      assert_equal @response.data, subject.call(@name, @params)
+    end
 
-        assert_raises(AndSon::ConnectionClosedError) do
-          client.call('anything')
-        end
-      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
+    end
+
+    should "allow adding/removing stored responses" do
+      data = Factory.string
+      subject.add_response(@name, @params){ data }
+      response = subject.responses.get(@name, @params)
+      assert_equal data, response.data
+
+      subject.remove_response(@name, @params)
+      response = subject.responses.get(@name, @params)
+      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)
+
+      subject.reset
+      assert_equal [], subject.calls
+      assert_not_equal @response, subject.responses.get(@name, @params)
+    end
+
+    should "be comparable" do
+      matching = AndSon::TestClient.new(@host, @port)
+      assert_equal matching, subject
+
+      not_matching = AndSon::TestClient.new(Factory.string, @port)
+      assert_not_equal not_matching, subject
+      not_matching = AndSon::TestClient.new(@host, Factory.integer)
+      assert_not_equal not_matching, subject
+      params = { Factory.string => Factory.string }
+      not_matching = AndSon::TestClient.new(@host, @port).params(params)
+      assert_not_equal not_matching, subject
+      not_matching = AndSon::TestClient.new(@host, @port).logger(Factory.string)
+      assert_not_equal not_matching, subject
+      not_matching = AndSon::TestClient.new(@host, @port).timeout(Factory.integer)
+      assert_not_equal not_matching, subject
+    end
+
+    should "be hash comparable" do
+      assert_equal subject.call_runner.hash, subject.hash
+
+      matching = AndSon::TestClient.new(@host, @port)
+      assert_true subject.eql?(matching)
+      not_matching = AndSon::TestClient.new(Factory.string, Factory.integer)
+      assert_false subject.eql?(not_matching)
     end
 
   end
 
+  class TestClientInstanceMethodsTests < TestClientTests
+
+    should "set its timeout value and return its call runner using `timeout`" do
+      timeout_value = Factory.integer
+      result = subject.timeout(timeout_value)
+      assert_equal timeout_value, subject.timeout_value
+      assert_same subject, result
+    end
+
+    should "update its params value and return its call runner using `params`" do
+      params_value = { Factory.string => Factory.string }
+      result = subject.params(params_value)
+      assert_equal params_value, subject.params_value
+      assert_same subject, result
+
+      new_key = Factory.string
+      new_value = Factory.string
+      subject.params({ new_key => new_value })
+      assert_equal 2, subject.params_value.keys.size
+      assert_equal new_value, subject.params_value[new_key]
+    end
+
+    should "set its logger value and return its call runner using `logger`" do
+      logger_value = Factory.string
+      result = subject.logger(logger_value)
+      assert_equal logger_value, subject.logger_value
+      assert_same subject, result
+    end
+
+  end
+
+  class CallRunnerSpy
+    attr_reader :call_args, :call_block, :call_response
+
+    def initialize
+      @call_args = []
+      @call_block = nil
+      @call_response = Factory.string
+    end
+
+    def call(*args, &block)
+      @call_args = args
+      @call_block = block
+      @call_response
+    end
+  end
+
 end