edh 0.1

data/spec/cases/api_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe "EDH::Passport::API" do
+  before(:each) do
+    @service = EDH::Passport::API.new
+  end
+
+  it "doesn't include an access token if none was given" do
+    EDH.should_receive(:make_request).with(
+      anything,
+      hash_not_including('access_token' => 1),
+      anything,
+      anything
+    ).and_return(EDH::HTTPService::Response.new(200, "", ""))
+
+    @service.api('anything')
+  end
+
+  it "includes an access token if given" do
+    token = 'adfadf'
+    service = EDH::Passport::API.new token
+
+    EDH.should_receive(:make_request).with(
+      anything,
+      hash_including('access_token' => token),
+      anything,
+      anything
+    ).and_return(EDH::HTTPService::Response.new(200, "", ""))
+
+    service.api('anything')
+  end
+
+  it "has an attr_reader for access token" do
+    token = 'adfadf'
+    service = EDH::Passport::API.new token
+    service.access_token.should == token
+  end
+
+  it "gets the attribute of a EDH::HTTPService::Response given by the http_component parameter" do
+    http_component = :method_name
+
+    response = mock('Mock EDHResponse', :body => '', :status => 200)
+    result = stub("result")
+    response.stub(http_component).and_return(result)
+    EDH.stub(:make_request).and_return(response)
+
+    @service.api('anything', {}, 'get', :http_component => http_component).should == result
+  end
+
+  it "returns the entire response if http_component => :response" do
+    http_component = :response
+    response = mock('Mock EDHResponse', :body => '', :status => 200)
+    EDH.stub(:make_request).and_return(response)
+    @service.api('anything', {}, 'get', :http_component => http_component).should == response
+  end
+
+  it "turns arrays of non-enumerables into comma-separated arguments" do
+    args = [12345, {:foo => [1, 2, "3", :four]}]
+    expected = ["/12345", {:foo => "1,2,3,four"}, "get", {}]
+    response = mock('Mock EDHResponse', :body => '', :status => 200)
+    EDH.should_receive(:make_request).with(*expected).and_return(response)
+    @service.api(*args)
+  end
+
+  it "doesn't turn arrays containing enumerables into comma-separated strings" do
+    params = {:foo => [1, 2, ["3"], :four]}
+    args = [12345, params]
+    # we leave this as is -- the HTTP layer can either handle it appropriately
+    # (if appropriate behavior is defined)
+    # or raise an exception
+    expected = ["/12345", params, "get", {}]
+    response = mock('Mock EDHResponse', :body => '', :status => 200)
+    EDH.should_receive(:make_request).with(*expected).and_return(response)
+    @service.api(*args)
+  end
+
+  it "returns the body of the request as JSON if no http_component is given" do
+    response = stub('response', :body => 'body', :status => 200)
+    EDH.stub(:make_request).and_return(response)
+
+    json_body = mock('JSON body')
+    MultiJson.stub(:load).and_return([json_body])
+
+    @service.api('anything').should == json_body
+  end
+
+  it "executes an error checking block if provided" do
+    response = EDH::HTTPService::Response.new(200, '{}', {})
+    EDH.stub(:make_request).and_return(response)
+
+    yield_test = mock('Yield Tester')
+    yield_test.should_receive(:pass)
+
+    @service.api('anything', {}, "get") do |arg|
+      yield_test.pass
+      arg.should == response
+    end
+  end
+
+  it "raises an API error if the HTTP response code is greater than or equal to 500" do
+    EDH.stub(:make_request).and_return(EDH::HTTPService::Response.new(500, 'response body', {}))
+
+    lambda { @service.api('anything') }.should raise_exception(EDH::Passport::APIError)
+  end
+
+  it "handles rogue true/false as responses" do
+    EDH.should_receive(:make_request).and_return(EDH::HTTPService::Response.new(200, 'true', {}))
+    @service.api('anything').should be_true
+
+    EDH.should_receive(:make_request).and_return(EDH::HTTPService::Response.new(200, 'false', {}))
+    @service.api('anything').should be_false
+  end
+
+  describe "with regard to leading slashes" do
+    it "adds a leading / to the path if not present" do
+      path = "anything"
+      EDH.should_receive(:make_request).with("/#{path}", anything, anything, anything).and_return(EDH::HTTPService::Response.new(200, 'true', {}))
+      @service.api(path)
+    end
+
+    it "doesn't change the path if a leading / is present" do
+      path = "/anything"
+      EDH.should_receive(:make_request).with(path, anything, anything, anything).and_return(EDH::HTTPService::Response.new(200, 'true', {}))
+      @service.api(path)
+    end
+  end
+
+  describe "with an access token" do
+    before(:each) do
+      @api = EDH::Passport::API.new(@token)
+    end
+
+    it_should_behave_like "EDH RestAPI"
+  end
+
+  describe "without an access token" do
+    before(:each) do
+      @api = EDH::Passport::API.new
+    end
+
+    it_should_behave_like "EDH RestAPI"
+  end
+end

data/spec/cases/edh_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe EDH do
+
+  
+  it "has an http_service accessor" do
+    EDH.should respond_to(:http_service)
+    EDH.should respond_to(:http_service=)
+  end
+  
+  describe "constants" do
+    it "has a version" do
+      EDH.const_defined?("VERSION").should be_true
+    end
+
+    describe EDH::Passport do      
+      it "defines REST_SERVER" do
+        EDH::Passport::REST_SERVER.should == "passport.everydayhero.com/api/v1"
+      end
+    end
+  end
+  
+  context "for deprecated services" do
+    before :each do
+      @service = EDH.http_service
+    end
+    
+    after :each do
+      EDH.http_service = @service
+    end
+
+    it "invokes deprecated_interface if present" do
+      mock_service = stub("http service")
+      mock_service.should_receive(:deprecated_interface)
+      EDH.http_service = mock_service
+    end
+    
+    it "does not set the service if it's deprecated" do
+      mock_service = stub("http service")
+      mock_service.stub(:deprecated_interface)
+      EDH.http_service = mock_service
+      EDH.http_service.should == @service
+    end
+
+    it "sets the service if it's not deprecated" do
+      mock_service = stub("http service")
+      EDH.http_service = mock_service
+      EDH.http_service.should == mock_service
+    end
+  end
+
+  describe "make_request" do
+    it "passes all its arguments to the http_service" do
+      path = "foo"
+      args = {:a => 2}
+      verb = "get"
+      options = {:c => :d}
+      
+      EDH.http_service.should_receive(:make_request).with(path, args, verb, options)
+      EDH.make_request(path, args, verb, options)
+    end
+  end
+
+end

data/spec/cases/edh_test_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe EDHTest do
+  pending "should have tests, because the test suite depends on it"
+end

data/spec/cases/error_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe EDH::Passport::APIError do
+  it "is a EDH::EDHError" do
+    EDH::Passport::APIError.new(nil, nil).should be_a(EDH::EDHError)
+  end
+
+  [:pp_error_type, :pp_error_code, :pp_error_subcode, :pp_error_message, :http_status, :response_body].each do |accessor|
+    it "has an accessor for #{accessor}" do
+      EDH::Passport::APIError.instance_methods.map(&:to_sym).should include(accessor)
+      EDH::Passport::APIError.instance_methods.map(&:to_sym).should include(:"#{accessor}=")
+    end
+  end
+
+  it "sets http_status to the provided status" do
+    error_response = '{ "error": {"type": "foo", "other_details": "bar"} }'
+    EDH::Passport::APIError.new(400, error_response).response_body.should == error_response
+  end
+
+  it "sets response_body to the provided response body" do
+    EDH::Passport::APIError.new(400, '').http_status.should == 400
+  end
+
+  context "with an error_info hash" do
+    let(:error) { 
+      error_info = {
+        'type' => 'type',
+        'message' => 'message',
+        'code' => 1,
+        'error_subcode' => 'subcode'
+      }
+      EDH::Passport::APIError.new(400, '', error_info)
+    }
+
+    {
+      :pp_error_type => 'type',
+      :pp_error_message => 'message',
+      :pp_error_code => 1,
+      :pp_error_subcode => 'subcode'
+    }.each_pair do |accessor, value|
+      it "sets #{accessor} to #{value}" do
+        error.send(accessor).should == value
+      end
+    end
+
+    it "sets the error message \"type: error_info['type'], code: error_info['code'], error_subcode: error_info['error_subcode'], message: error_info['message'] [HTTP http_status]\"" do
+      error.message.should == "type: type, code: 1, error_subcode: subcode, message: message [HTTP 400]"
+    end
+  end
+
+  context "with an error_info string" do
+    it "sets the error message \"error_info [HTTP http_status]\"" do
+      error_info = "Passport is down."
+      error = EDH::Passport::APIError.new(400, '', error_info)
+      error.message.should == "Passport is down. [HTTP 400]"
+    end
+  end
+
+  context "with no error_info and a response_body containing error JSON" do
+    it "should extract the error info from the response body" do
+      response_body = '{ "error": { "type": "type", "message": "message", "code": 1, "error_subcode": "subcode" } }'
+      error = EDH::Passport::APIError.new(400, response_body)
+      {
+        :pp_error_type => 'type',
+        :pp_error_message => 'message',
+        :pp_error_code => 1,
+        :pp_error_subcode => 'subcode'
+      }.each_pair do |accessor, value|
+        error.send(accessor).should == value
+      end
+    end
+  end
+
+end
+
+describe EDH::EDHError do
+  it "is a StandardError" do
+     EDH::EDHError.new.should be_a(StandardError)
+  end
+end
+
+describe EDH::Passport::BadPassportResponse do
+  it "is a EDH::Passport::APIError" do
+     EDH::Passport::BadPassportResponse.new(nil, nil).should be_a(EDH::Passport::APIError)
+  end
+end
+
+describe EDH::Passport::ServerError do
+  it "is a EDH::Passport::APIError" do
+     EDH::Passport::ServerError.new(nil, nil).should be_a(EDH::Passport::APIError)
+  end
+end
+
+describe EDH::Passport::ClientError do
+  it "is a EDH::Passport::APIError" do
+     EDH::Passport::ClientError.new(nil, nil).should be_a(EDH::Passport::APIError)
+  end
+end
+
+describe EDH::Passport::AuthenticationError do
+  it "is a EDH::Passport::ClientError" do
+     EDH::Passport::AuthenticationError.new(nil, nil).should be_a(EDH::Passport::ClientError)
+  end
+end

data/spec/cases/http_service_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+
+describe "EDH::HTTPService" do
+  it "has a faraday_middleware accessor" do
+    EDH::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware)
+    EDH::HTTPService.methods.map(&:to_sym).should include(:faraday_middleware=)
+  end
+
+  it "has an http_options accessor" do
+    EDH::HTTPService.should respond_to(:http_options)
+    EDH::HTTPService.should respond_to(:http_options=)
+  end
+
+  it "sets http_options to {} by default" do
+    EDH::HTTPService.http_options.should == {}
+  end
+
+  describe "DEFAULT_MIDDLEWARE" do
+    before :each do
+      @builder = stub("Faraday connection builder")
+      @builder.stub(:request)
+      @builder.stub(:adapter)
+      @builder.stub(:use)
+    end
+
+    it "is defined" do
+      EDH::HTTPService.const_defined?("DEFAULT_MIDDLEWARE").should be_true
+    end
+
+    it "adds multipart" do
+      @builder.should_receive(:use).with(EDH::HTTPService::MultipartRequest)
+      EDH::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+
+    it "adds url_encoded" do
+      @builder.should_receive(:request).with(:url_encoded)
+      EDH::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+
+    it "uses the default adapter" do
+      adapter = :testing_now
+      Faraday.stub(:default_adapter).and_return(adapter)
+      @builder.should_receive(:adapter).with(adapter)
+      EDH::HTTPService::DEFAULT_MIDDLEWARE.call(@builder)
+    end
+  end
+
+  describe ".encode_params" do
+    it "returns an empty string if param_hash evaluates to false" do
+      EDH::HTTPService.encode_params(nil).should == ''
+    end
+
+    it "converts values to JSON if the value is not a String" do
+      val = 'json_value'
+      not_a_string = 'not_a_string'
+      not_a_string.stub(:is_a?).and_return(false)
+      MultiJson.should_receive(:dump).with(not_a_string).and_return(val)
+
+      string = "hi"
+
+      args = {
+        not_a_string => not_a_string,
+        string => string
+      }
+
+      result = EDH::HTTPService.encode_params(args)
+      result.split('&').find do |key_and_val|
+        key_and_val.match("#{not_a_string}=#{val}")
+      end.should be_true
+    end
+
+    it "escapes all values" do
+      args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
+
+      result = EDH::HTTPService.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        val.should == CGI.escape(args[key])
+      end
+    end
+
+    it "encodes parameters in alphabetical order" do
+      args = {:b => '2', 'a' => '1'}
+
+      result = EDH::HTTPService.encode_params(args)
+      result.split('&').map{|key_val| key_val.split('=')[0]}.should == ['a', 'b']
+    end
+
+    it "converts all keys to Strings" do
+      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+
+      result = EDH::HTTPService.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+      end
+    end
+  end
+
+  describe ".make_request" do
+    before :each do
+      # Setup stubs for make_request to execute without exceptions
+      @mock_body = stub('Typhoeus response body')
+      @mock_headers_hash = stub({:value => "headers hash"})
+      @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+      @mock_connection = stub("Faraday connection")
+      @mock_connection.stub(:get).and_return(@mock_http_response)
+      @mock_connection.stub(:post).and_return(@mock_http_response)
+      Faraday.stub(:new).and_return(@mock_connection)
+    end
+
+    describe "creating the Faraday connection" do
+      it "creates a Faraday connection using the server" do
+        server = "foo"
+        EDH::HTTPService.stub(:server).and_return(server)
+        Faraday.should_receive(:new).with(server, anything).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "anything")
+      end
+
+      it "merges EDH::HTTPService.http_options into the request params" do
+        http_options = {:a => 2, :c => "3"}
+        EDH::HTTPService.http_options = http_options
+        Faraday.should_receive(:new).with(anything, hash_including(http_options)).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "get")
+      end
+
+      it "merges any provided options into the request params" do
+        options = {:a => 2, :c => "3"}
+        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "get", options)
+      end
+
+      it "overrides EDH::HTTPService.http_options with any provided options for the request params" do
+        options = {:a => 2, :c => "3"}
+        http_options = {:a => :a}
+        EDH::HTTPService.stub(:http_options).and_return(http_options)
+
+        Faraday.should_receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "get", options)
+      end
+
+      it "allows you to set other verify modes if you really want" do
+        options = {:ssl => {:verify => :foo}}
+        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
+      end
+
+      it "calls server with the composite options" do
+        options = {:a => 2, :c => "3"}
+        http_options = {:a => :a}
+        EDH::HTTPService.stub(:http_options).and_return(http_options)
+        EDH::HTTPService.should_receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
+        EDH::HTTPService.make_request("anything", {}, "get", options)
+      end
+
+      it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
+        block = Proc.new {}
+        stub_const("EDH::HTTPService::DEFAULT_MIDDLEWARE", block)
+        EDH::HTTPService.stub(:faraday_middleware).and_return(nil)
+        Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "get")
+      end
+
+      it "uses the defined HTTPService.faraday_middleware block if defined" do
+        block = Proc.new { }
+        EDH::HTTPService.should_receive(:faraday_middleware).and_return(block)
+        Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", {}, "get")
+      end
+    end
+
+    it "makes a POST request if the verb isn't get" do
+      @mock_connection.should_receive(:post).and_return(@mock_http_response)
+      EDH::HTTPService.make_request("anything", {}, "anything")
+    end
+
+    it "includes the verb in the body if the verb isn't get" do
+      verb = "eat"
+      @mock_connection.should_receive(:post).with(anything, hash_including("method" => verb)).and_return(@mock_http_response)
+      EDH::HTTPService.make_request("anything", {}, verb)
+    end
+
+    it "makes a GET request if the verb is get" do
+      @mock_connection.should_receive(:get).and_return(@mock_http_response)
+      EDH::HTTPService.make_request("anything", {}, "get")
+    end
+
+    describe "for GETs" do
+      it "submits the arguments in the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        Faraday.should_receive(:new).with(anything, hash_including(:params => args)).and_return(@mock_connection)
+        EDH::HTTPService.make_request("anything", args, "get")
+      end
+
+      it "submits nothing to the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        @mock_connection.should_receive(:get).with(anything, {}).and_return(@mock_http_response)
+        EDH::HTTPService.make_request("anything", args, "get")
+      end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "GET: anything params: "
+        EDH::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+
+        EDH::HTTPService.make_request("anything", args, "get")
+      end
+    end
+
+    describe "for POSTs" do
+      it "submits the arguments in the body" do
+        # technically this is done for all requests, but you don't send GET requests with files
+        args = {"a" => :b, "c" => 3}
+        @mock_connection.should_receive(:post).with(anything, hash_including(args)).and_return(@mock_http_response)
+        EDH::HTTPService.make_request("anything", args, "post")
+      end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "POST: anything params: "
+        EDH::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+        EDH::HTTPService.make_request("anything", args, "post")
+      end
+    end
+  end
+
+  describe "deprecated options" do
+    before :each do
+      EDH::HTTPService.stub(:http_options).and_return({})
+      @service = EDH.http_service
+    end
+
+    after :each do
+      EDH.http_service = @service
+    end
+
+    describe "per-request options" do
+      before :each do
+        # Setup stubs for make_request to execute without exceptions
+        @mock_body = stub('Typhoeus response body')
+        @mock_headers_hash = stub({:value => "headers hash"})
+        @mock_http_response = stub("Faraday Response", :status => 200, :headers => @mock_headers_hash, :body => @mock_body)
+
+        @mock_connection = stub("Faraday connection")
+        @mock_connection.stub(:get).and_return(@mock_http_response)
+        @mock_connection.stub(:post).and_return(@mock_http_response)
+        Faraday.stub(:new).and_return(@mock_connection)
+      end
+
+      describe ":typhoeus_options" do
+        it "merges any typhoeus_options into options" do
+          typhoeus_options = {:a => 2}
+          Faraday.should_receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
+        end
+
+        it "deletes the typhoeus_options key" do
+          typhoeus_options = {:a => 2}
+          Faraday.should_receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
+        end
+      end
+
+      describe ":ca_path" do
+        it "sets any ca_path into options[:ssl]" do
+          ca_path = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_path => ca_path))).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
+        end
+
+        it "deletes the ca_path key" do
+          ca_path = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_path => ca_path)).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
+        end
+      end
+
+      describe ":ca_file" do
+        it "sets any ca_file into options[:ssl]" do
+          ca_file = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:ca_file => ca_file))).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
+        end
+
+        it "deletes the ca_file key" do
+          ca_file = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:ca_file => ca_file)).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
+        end
+      end
+
+      describe ":verify_mode" do
+        it "sets any verify_mode into options[:ssl]" do
+          verify_mode = :foo
+          Faraday.should_receive(:new).with(anything, hash_including(:ssl => hash_including(:verify_mode => verify_mode))).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
+        end
+
+        it "deletes the verify_mode key" do
+          verify_mode = :foo
+          Faraday.should_receive(:new).with(anything, hash_not_including(:verify_mode => verify_mode)).and_return(@mock_connection)
+          EDH::HTTPService.make_request("anything", {}, "get", :verify_mode => verify_mode)
+        end
+      end
+    end
+  end
+end