lib/and-son/client.rb in and-son-0.1.1 vs lib/and-son/client.rb in and-son-0.2.1

@@ -1,9 +1,10 @@
 require 'ostruct'
 require 'sanford-protocol'
 require 'and-son/connection'
 require 'and-son/response'
+require 'and-son/stored_responses'
 
 module AndSon
 
   module CallRunnerMethods
 
@@ -29,49 +30,64 @@
       hash.inject({}){|h, (k, v)| h.merge({ k.to_s => v }) }
     end
 
   end
 
-  class Client < Struct.new(:host, :port, :version)
+  class Client
     include CallRunnerMethods
 
     DEFAULT_TIMEOUT = 60 #seconds
 
+    attr_reader :host, :port, :version, :responses
+
+    def initialize(host, port, version)
+      @host, @port, @version = host, port, version
+      @responses = AndSon::StoredResponses.new
+    end
+
     # proxy the call method to the call runner
     def call(*args, &block); self.call_runner.call(*args, &block); end
 
     def call_runner
       # always start with this default CallRunner
       CallRunner.new({
-        :host    => host,
-        :port    => port,
-        :version => version,
+        :host     => host,
+        :port     => port,
+        :version  => version,
         :timeout_value => (ENV['ANDSON_TIMEOUT'] || DEFAULT_TIMEOUT).to_f,
-        :params_value  => {}
+        :params_value  => {},
+        :responses     => @responses,
       })
     end
   end
 
-  class CallRunner < OpenStruct # {:host, :port, :version, :timeout_value, :params_value}
+  class CallRunner < OpenStruct
+    # {:host, :port, :version, :timeout_value, :params_value, :responses}
     include CallRunnerMethods
 
     # chain runner methods by returning itself
     def call_runner; self; end
 
-    def call(name, params = {})
+    def call(name, params = nil)
+      params ||= {}
       if !params.kind_of?(Hash)
-        raise ArgumentError, "expected params to be a Hash instead of a #{hash.class}"
+        raise ArgumentError, "expected params to be a Hash instead of a #{params.class}"
       end
+      client_response = self.responses.find(name, params) if ENV['ANDSON_TEST_MODE']
+      client_response ||= self.call!(name, params)
+
+      if block_given?
+        yield client_response.protocol_response
+      else
+        client_response.data
+      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(version, name, call_params).to_hash)
-        client_response = AndSon::Response.parse(connection.read(timeout_value))
-
-        if block_given?
-          yield client_response.protocol_response
-        else
-          client_response.data
-        end
+        AndSon::Response.parse(connection.read(timeout_value))
       end
     end
 
   end