faraday 0.1.2 → 0.2.0

data/lib/faraday/adapter/mock_request.rb

@@ -1,120 +0,0 @@
-module Faraday
-  module Adapter
-    module MockRequest
-      extend Faraday::Connection::Options
-      def self.loaded?() false end
-
-      include Faraday::Error # ConnectionFailed
-
-      class Stubs
-        def initialize
-          # {:get => [Stub, Stub]}
-          @stack = {}
-          yield self if block_given?
-        end
-
-        def empty?
-          @stack.empty?
-        end
-
-        def match(request_method, path, data, request_headers)
-          return false if !@stack.key?(request_method)
-          stub = @stack[request_method].detect { |stub| stub.matches?(path, data, request_headers) }
-          @stack[request_method].delete(stub) if stub
-        end
-
-        def get(path, request_headers = {}, &block)
-          (@stack[:get] ||= []) << new_stub(path, {}, request_headers, block)
-        end
-
-        def delete(path, request_headers = {}, &block)
-          (@stack[:delete] ||= []) << new_stub(path, {}, request_headers, block)
-        end
-
-        def post(path, data, request_headers = {}, &block)
-          (@stack[:post] ||= []) << new_stub(path, data, request_headers, block)
-        end
-
-        def put(path, data, request_headers = {}, &block)
-          (@stack[:put] ||= []) << new_stub(path, data, request_headers, block)
-        end
-
-        def new_stub(path, data, request_headers, block)
-          status, response_headers, body = block.call
-          Stub.new(path, request_headers, status, response_headers, body, data)
-        end
-      end
-
-      class Stub < Struct.new(:path, :request_headers, :status, :response_headers, :body, :data)
-        def matches?(request_path, params, headers)
-          return false if request_path != path
-          return false if params != data
-          return true  if request_headers.empty?
-          request_headers.each do |key, value|
-            return false if headers[key] != value
-          end 
-          true
-        end
-      end
-
-      def initialize &block
-        super
-        configure(&block) if block
-      end
-
-      def configure
-        yield stubs
-      end
-
-      def stubs
-        @stubs ||= Stubs.new
-      end
-
-      def _get(uri, headers)
-        raise ConnectionFailed, "no stubbed requests" if stubs.empty?
-        if stub = @stubs.match(:get, uri.path, {}, headers)
-          response_class.new do |resp|
-            resp.headers = stub.response_headers
-            resp.process stub.body
-          end
-        else
-          nil
-        end
-      end
-
-      def _delete(uri, headers)
-        raise ConnectionFailed, "no stubbed requests" if stubs.empty?
-        if stub = @stubs.match(:delete, uri.path, {}, headers)
-          response_class.new do |resp|
-            resp.headers = stub.response_headers
-            resp.process stub.body
-          end
-        else
-          nil
-        end
-      end
-      def _post(uri, data, headers)
-        raise ConnectionFailed, "no stubbed requests" if stubs.empty?
-        if stub = @stubs.match(:post, uri.path, data, headers)
-          response_class.new do |resp|
-            resp.headers = stub.response_headers
-            resp.process stub.body
-          end
-        else
-          nil
-        end
-      end
-      def _put(uri, data, headers)
-        raise ConnectionFailed, "no stubbed requests" if stubs.empty?
-        if stub = @stubs.match(:put, uri.path, data, headers)
-          response_class.new do |resp|
-            resp.headers = stub.response_headers
-            resp.process stub.body
-          end
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/faraday/loadable.rb

@@ -1,13 +0,0 @@
-module Faraday
-  module Loadable
-    def self.extended mod
-      class << mod
-        attr_accessor :load_error
-      end
-    end
-
-    def self.loaded?
-      load_error.nil?
-    end
-  end
-end

data/lib/faraday/request/post_request.rb

@@ -1,30 +0,0 @@
-module Faraday
-  module Request
-    class PostRequest
-      extend Loadable
-
-      def initialize params, headers={}
-        @params = params
-        @headers = headers
-      end
-
-      def headers
-        @headers.merge('Content-Type' => 'application/x-www-form-urlencoded')
-      end
-
-      def body
-        create_post_params @params
-      end
-    
-     private
-      def create_post_params(params, base = "")
-        [].tap do |toreturn|
-          params.each_key do |key|
-            keystring = base == '' ? key : "#{base}[#{key}]"
-            toreturn << (params[key].kind_of?(Hash) ? create_post_params(params[key], keystring) : "#{keystring}=#{CGI.escape(params[key].to_s)}")
-          end
-        end.join('&')
-      end
-    end
-  end
-end

data/lib/faraday/request/yajl_request.rb

@@ -1,27 +0,0 @@
-module Faraday
-  module Request
-    class YajlRequest
-      extend Loadable
-
-      begin
-        require 'yajl'
-
-        def initialize params, headers={}
-          @params = params
-          @headers = headers
-        end
-
-        def headers
-          @headers.merge('Content-Type' => 'application/json')
-        end
-
-        # TODO streaming
-        def body
-          Yajl::Encoder.encode @params
-        end
-      rescue LoadError => e
-        self.load_error = e
-      end
-    end
-  end
-end

data/lib/faraday/response/yajl_response.rb

@@ -1,35 +0,0 @@
-module Faraday
-  class Response
-    class YajlResponse < Response
-      attr_reader :body
-
-      begin
-        require 'yajl'
-
-        def initialize(headers = nil, body = nil)
-          super
-          @parser = nil
-        end
-
-        def process(chunk)
-          if !@parser
-            @parser = Yajl::Parser.new
-            @parser.on_parse_complete = method(:object_parsed)
-          end
-          @parser << chunk
-        end
-
-        def processed!
-          @parser = nil
-        end
-
-        def object_parsed(obj)
-          @body = obj
-        end
-
-      rescue LoadError => e
-        self.load_error = e
-      end
-    end
-  end
-end

data/lib/faraday/test_connection.rb

@@ -1,5 +0,0 @@
-module Faraday
-  class TestConnection < Connection
-    include Faraday::Adapter::MockRequest
-  end
-end

data/test/adapter/typhoeus_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'helper'))
-
-if Faraday::Adapter::Typhoeus.loaded?
-  class TyphoeusTest < Faraday::TestCase
-    describe "#parse_response_headers" do
-      before do
-        @conn = Object.new.extend(Faraday::Adapter::Typhoeus)
-      end
-
-      it "leaves http status line out" do
-        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
-        assert_equal %w(content-type), headers.keys
-      end
-
-      it "parses lower-cased header name and value" do
-        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
-        assert_equal 'text/html', headers['content-type']
-      end
-
-      it "parses lower-cased header name and value with colon" do
-        headers = @conn.parse_response_headers("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n")
-        assert_equal 'http://sushi.com/', headers['location']
-      end
-    end
-  end
-end

data/test/adapter_test.rb

@@ -1,118 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-class AdapterTest < Faraday::TestCase
-  before do
-    @connection = Faraday::Connection.new(LIVE_SERVER)
-  end
-
-  Faraday::Adapter.loaded_adapters.each do |adapter|
-    describe "with #{adapter} adapter" do
-      before do
-        @connection.extend adapter
-      end
-
-      describe "#delete" do
-        it "retrieves the response body with YajlResponse" do
-          @connection.response_class = Faraday::Response::YajlResponse
-          assert_equal({'deleted' => true},
-            @connection.delete('delete_with_json').body)
-        end
-        
-        it "send url-encoded params" do
-          assert_equal('foobar', @connection.delete('delete_with_params', 'deleted' => 'foobar').body)
-        end
-      end
-
-      it "passes params" do
-        @connection.params = {:a => 1}
-        assert_equal "params[:a] == 1", @connection.get('params').body
-      end
-
-      it "passes headers" do
-        @connection.headers = {"X-Test" => 1}
-        assert_equal "env[HTTP_X_TEST] == 1", @connection.get('headers').body
-      end
-
-      it "retrieves the response body" do
-        assert_equal 'hello world', @connection.get('hello_world').body
-      end
-
-      describe "#put" do
-        it "sends params" do
-          assert_equal 'hello zack', @connection.put('hello', 'name' => 'zack').body
-        end
-
-        it "retrieves the response body with YajlResponse" do
-          @connection.response_class = Faraday::Response::YajlResponse
-          assert_equal({'name' => 'zack'},
-            @connection.put('echo_name', 'name' => 'zack').body)
-        end
-      end
-
-      describe "#post" do
-        it "sends params" do
-          assert_equal 'hello zack', @connection.post('hello', 'name' => 'zack').body
-        end
-
-        it "retrieves the response body with YajlResponse" do
-          @connection.response_class = Faraday::Response::YajlResponse
-          assert_equal({'name' => 'zack'},
-            @connection.post('echo_name', 'name' => 'zack').body)
-        end
-      end
-
-      describe "#get" do
-        it "raises on 404" do
-          assert_raise(Faraday::Error::ResourceNotFound) { @connection.get('/nothing') }
-        end
-        it "retrieves the response body" do
-          assert_equal 'hello world', @connection.get('hello_world').body
-        end
-
-        it "send url-encoded params" do
-          assert_equal('hello zack', @connection.get('hello', 'name' => 'zack').body)
-        end
-
-        it "retrieves the response body with YajlResponse" do
-          @connection.response_class = Faraday::Response::YajlResponse
-          assert_equal [1,2,3], @connection.get('json').body
-        end
-
-        it "retrieves the response headers" do
-          assert_equal 'text/html', @connection.get('hello_world').headers['content-type']
-        end
-      end
-    end
-
-    describe "async requests" do
-      before do
-        @connection.extend adapter
-      end
-
-      it "clears parallel manager after running a single request" do
-        assert !@connection.in_parallel?
-        resp = @connection.get('hello_world')
-        assert !@connection.in_parallel?
-        assert_equal 'hello world', @connection.get('hello_world').body
-      end
-
-      it "uses parallel manager to run multiple json requests" do
-        resp1, resp2 = nil, nil
-
-        @connection.response_class = Faraday::Response::YajlResponse
-        @connection.in_parallel do
-          resp1 = @connection.get('json')
-          resp2 = @connection.get('json')
-          assert @connection.in_parallel?
-          if adapter.supports_async?
-            assert_nil resp1.body
-            assert_nil resp2.body
-          end
-        end
-        assert !@connection.in_parallel?
-        assert_equal [1,2,3], resp1.body
-        assert_equal [1,2,3], resp2.body
-      end
-    end
-  end
-end

data/test/response_test.rb

@@ -1,34 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-class ResponseTest < Faraday::TestCase
-  describe "unloaded response class" do
-    it "is not allowed to be set" do
-      resp_class = Object.new
-      def resp_class.loaded?() false end
-      conn = Faraday::Connection.new
-      assert_raises ArgumentError do
-        conn.response_class = resp_class
-      end
-    end
-  end
-
-  describe "TestConnection#get with default Faraday::Response class" do
-    it "returns Faraday::Response" do
-      conn = Faraday::TestConnection.new do |stub|
-        stub.get('/hello') { [200, {}, 'hello world']}
-      end
-      resp = conn.get('/hello')
-      assert_equal 'hello world', resp.body
-    end
-  end
-
-  describe "TestConnection#get with Faraday::YajlResponse class" do
-    it "returns string body" do
-      conn = Faraday::TestConnection.new do |stub|
-        stub.get('/hello') { [200, {}, '[1,2,3]']}
-      end
-      conn.response_class = Faraday::Response::YajlResponse
-      assert_equal [1,2,3], conn.get('/hello').body
-    end
-  end
-end