api_client 0.1.0

data/spec/api_client/connection/oauth_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Oauth do
+
+  it "adds basic middlewares to faraday" do
+    instance = ApiClient::Connection::Oauth.new("http://google.com")
+    instance.handler.builder.handlers.collect(&:name).should == [
+      "ApiClient::Connection::Middlewares::Request::OAuth",
+      "Faraday::Request::UrlEncoded",
+      "Faraday::Adapter::NetHttp"
+    ]
+  end
+
+  it "adds the logger middlewares to faraday if ApiClient.logger is available" do
+    logger = mock
+    ApiClient.stub(:logger).and_return(logger)
+    instance = ApiClient::Connection::Oauth.new("http://google.com")
+    instance.handler.builder.handlers.collect(&:name).should == [
+      "ApiClient::Connection::Middlewares::Request::Logger",
+      "ApiClient::Connection::Middlewares::Request::OAuth",
+      "Faraday::Request::UrlEncoded",
+      "Faraday::Adapter::NetHttp"
+    ]
+
+  end
+
+end

data/spec/api_client/connection/request/logger_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Middlewares::Request::Logger do
+
+  it "adds a oauth header to the request" do
+    app      = mock
+    logger   = FakeLogger.new
+    instance = ApiClient::Connection::Middlewares::Request::Logger.new(app, logger)
+    env = {
+      :url => "http://api.twitter.com",
+      :request_headers => {},
+      :method => 'get'
+    }
+    app.should_receive(:call).with(env)
+    instance.call(env)
+    logger.history.first.should == "GET http://api.twitter.com: 0.0000 seconds"
+  end
+
+end

data/spec/api_client/connection/request/oauth_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Middlewares::Request::OAuth do
+
+  it "adds a oauth header to the request" do
+    app = mock
+    options = {
+      :token => 'TOKEN',
+      :token_secret => 'SECRET',
+      :consumer_key => 'CONSUMER_KEY',
+      :consumer_secret => 'CONSUMER_SECRET'
+    }
+    instance = ApiClient::Connection::Middlewares::Request::OAuth.new(app, options)
+    env = {
+      :url => "http://api.twitter.com",
+      :request_headers => {}
+    }
+    app.should_receive(:call).with(env)
+
+    instance.call(env)
+    env[:request_headers]['Authorization'].should match("OAuth")
+    env[:request_headers]['User-Agent'].should match("ApiClient gem")
+
+  end
+
+end

data/spec/api_client/resource/base_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe ApiClient::Resource::Base do
+
+  describe '.scope' do
+
+    it "is an instance of ApiClient::Resource::Scope" do
+      ApiClient::Resource::Base.scope.should be_an_instance_of(ApiClient::Resource::Scope)
+    end
+
+  end
+
+
+  describe "persistence" do
+
+    before do
+      @instance = ApiClient::Resource::Base.new
+      @instance.id = 42
+      @instance.name = "Mike"
+    end
+
+    describe '#persisted?' do
+
+      it "returns true if id is present, false otherwise" do
+        @instance.id = 42
+        @instance.persisted?.should == true
+        @instance.id = nil
+        @instance.persisted?.should == false
+      end
+
+    end
+
+    describe '#save' do
+
+      it "creates a record if not persisted" do
+        @instance.id = nil
+        @instance.should_receive(:remote_create)
+        @instance.save
+      end
+
+      it "updates a record if not persisted" do
+        @instance.id = 42
+        @instance.should_receive(:remote_update)
+        @instance.save
+      end
+
+    end
+
+    describe "#destroy" do
+
+      it "delegates the destroy to the class" do
+        ApiClient::Resource::Base.should_receive(:destroy).with(42)
+        @instance.destroy
+      end
+
+    end
+
+    describe "#remote_update" do
+
+      it "delegates the update to the class" do
+        ApiClient::Resource::Base.should_receive(:update).with(42, "name" => "Mike")
+        @instance.remote_update
+      end
+
+    end
+
+    describe "#remote_create" do
+
+      it "delegates the create to the class" do
+        ApiClient::Resource::Base.should_receive(:create).with("name" => "Mike")
+        @instance.remote_create
+      end
+
+    end
+
+  end
+
+end

data/spec/api_client/resource/scope_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe ApiClient::Resource::Scope do
+
+  describe "restful requests" do
+
+    class Restful < ApiClient::Resource::Base
+    end
+
+    class Restful2 < ApiClient::Resource::Base
+      namespace false
+    end
+
+    class Restful3 < ApiClient::Resource::Base
+      prefix "v1"
+    end
+
+    before do
+      @instance  = ApiClient::Resource::Scope.new(Restful)
+    end
+
+    it "performs a find to fetch one record" do
+      response = { "restful" => { "id" => 42 }}
+      @instance.should_receive(:get).with('/restfuls/1.json').and_return(response)
+      result = @instance.find(1)
+      result.should be_an_instance_of(Restful)
+      result.id.should == 42
+    end
+
+    it "performs a find to fetch one record with a prefix if provided" do
+      @instance  = ApiClient::Resource::Scope.new(Restful3)
+      response = { "restful3" => { "id" => 42 }}
+      @instance.should_receive(:get).with('/v1/restful3s/1.json').and_return(response)
+      result = @instance.find(1)
+      result.should be_an_instance_of(Restful3)
+      result.id.should == 42
+    end
+
+    it "performs a find_all to fetch many records" do
+      response = [{ "restful" => { "id" => 42 } }, { "restful" => { "id" => 112 } }]
+      @instance.should_receive(:get).with('/restfuls.json', {}).and_return(response)
+      result = @instance.find_all
+
+      result.should be_an_instance_of(Array)
+      result.first.should be_an_instance_of(Restful)
+      result.first.id.should == 42
+      result.last.should be_an_instance_of(Restful)
+      result.last.id.should == 112
+    end
+
+    it "performs a create to create a new record" do
+      response = { "restful" => { "id" => 42, "name" => "Foo" }}
+      @instance.should_receive(:post).with('/restfuls.json', {"restful" => {:name => "Foo"} }).and_return(response)
+      result = @instance.create(:name => "Foo")
+      result.should be_an_instance_of(Restful)
+      result.id.should == 42
+    end
+
+    it "performs a create to create a new record skipping the namespace if it is not present" do
+      @instance  = ApiClient::Resource::Scope.new(Restful2)
+      response = { "id" => 42, "name" => "Foo" }
+      @instance.should_receive(:post).with('/restful2s.json', {:name => "Foo"} ).and_return(response)
+      result = @instance.create(:name => "Foo")
+      result.should be_an_instance_of(Restful2)
+      result.id.should == 42
+    end
+
+    it "performs a update to update an existing record" do
+      response = { "restful" => { "id" => 42, "name" => "Foo" }}
+      @instance.should_receive(:put).with('/restfuls/42.json', {"restful" => {:name => "Foo"} }).and_return(response)
+      result = @instance.update(42, :name => "Foo")
+      result.should be_an_instance_of(Restful)
+      result.id.should == 42
+    end
+
+    it "performs a update to update an existing record skipping the namespace if it is not present" do
+      @instance  = ApiClient::Resource::Scope.new(Restful2)
+      response = { "id" => 42, "name" => "Foo" }
+      @instance.should_receive(:put).with('/restful2s/42.json', {:name => "Foo"} ).and_return(response)
+      result = @instance.update(42, :name => "Foo")
+      result.should be_an_instance_of(Restful2)
+      result.id.should == 42
+    end
+
+
+
+    it "performs a destroy to remove a record" do
+      response = { "restful" => { "id" => 42, "name" => "Foo" }}
+      @instance.should_receive(:delete).with('/restfuls/42.json').and_return(response)
+      result = @instance.destroy(42)
+      result.should == true
+    end
+
+  end
+
+end

data/spec/api_client/scope_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+
+describe ApiClient::Scope do
+
+  describe 'default_scopes' do
+
+    it "runs the default scopes defined in the scopeable" do
+      class DefaultScopeTest < ApiClient::Base
+        always do
+          params :foo => 1
+        end
+      end
+      instance = ApiClient::Scope.new(DefaultScopeTest)
+      instance.params.should == { :foo => 1 }
+    end
+  end
+
+  describe "#params" do
+
+    it "reads/writes the params and chains nicely" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.params(:foo => 1).params(:moo => 10).should == instance
+      instance.params.should == { :foo => 1, :moo => 10 }
+    end
+
+  end
+
+  describe "#headers" do
+
+    it "reads/writes the headers and chains nicely" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.headers(:foo => 1).headers(:moo => 10).should == instance
+      instance.headers.should == { :foo => 1, :moo => 10 }
+    end
+
+  end
+
+  describe "#options" do
+
+    it "reads/writes the headers and chains nicely" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.options(:foo => 1).options(:moo => 10).should == instance
+      instance.options.should == { :foo => 1, :moo => 10 }
+    end
+
+  end
+
+  describe "connection" do
+
+    it "retuns the connection based on the adapter" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.connection.should be_an_instance_of ApiClient::Connection::Basic
+    end
+
+    it "raises an error if adapter was not found" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      lambda {
+        instance.adapter("foo").connection
+      }.should raise_error
+    end
+
+    it "executes connection hooks" do
+      AConnectionHook = mock
+      class ScopeConnectionHooksTest < ApiClient::Base
+      end
+      ScopeConnectionHooksTest.connection_hooks = [AConnectionHook]
+      instance = ApiClient::Scope.new(ScopeConnectionHooksTest)
+      AConnectionHook.should_receive(:call)
+      instance.connection
+    end
+
+  end
+
+  describe "requests" do
+
+    before do
+      @path    = "somepath"
+      @params  = { :foo => 1 }
+      @headers = { 'token' => 'A' }
+    end
+
+    def test_request(method)
+      connection = mock
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.stub(:connection).and_return(connection)
+      response = Faraday::Response.new(:body => '{"a": "1"}')
+      connection.should_receive(method).with(@path, @params, @headers).and_return(response)
+      instance.params(@params).headers(@headers).send(method, @path)
+    end
+
+    it "can make any request" do
+      connection = mock
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.stub(:connection).and_return(connection)
+      response = Faraday::Response.new(:body => '{"a": "1"}')
+      connection.should_receive(:get).with(@path, @params, @headers).and_return(response)
+      result = instance.params(@params).headers(@headers).request(:get, @path)
+      result.should == {"a"=> "1"}
+    end
+
+    it "can make any request and get a raw response" do
+      connection = mock
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.stub(:connection).and_return(connection)
+      response = Faraday::Response.new(:body => '{"a": "1"}')
+      connection.should_receive(:get).with(@path, @params, @headers).and_return(response)
+      result = instance.params(@params).headers(@headers).request(:get, @path, :raw => true)
+      result.should == response
+    end
+
+    it "makes a GET request" do
+      result = test_request :get
+      result.should == {"a"=> "1"}
+    end
+
+    it "makes a POST request" do
+      result = test_request :post
+      result.should == {"a"=> "1"}
+    end
+
+    it "makes a PUT request" do
+      result = test_request :put
+      result.should == {"a"=> "1"}
+    end
+
+    it "makes a PUT request" do
+      result = test_request :delete
+      result.should == {"a"=> "1"}
+    end
+
+    describe "fetch" do
+
+      it "performs a get and builds an object" do
+        connection = mock
+        instance = ApiClient::Scope.new(ApiClient::Base)
+        instance.stub(:connection).and_return(connection)
+        response = Faraday::Response.new(:body => '{"id": 42}')
+        connection.should_receive(:get).with(@path, @params, @headers).and_return(response)
+        result = instance.params(@params).headers(@headers).fetch(@path)
+        result.should be_an_instance_of(ApiClient::Base)
+        result.id.should == 42
+      end
+
+    end
+
+  end
+
+  describe "dynamic delegation of scopeable singleton methods" do
+
+    it "dynamically delegates and properly scopes" do
+      class DynamicDelegationTest < ApiClient::Base
+        def self.some_method
+          self.scope.params
+        end
+      end
+      scope = ApiClient::Scope.new(DynamicDelegationTest)
+      scope.params(:param => "aaa").some_method.should == { :param => "aaa" }
+    end
+
+    it "raises an error if scopeable does not implement the method" do
+      scope = ApiClient::Scope.new(ApiClient::Base)
+      lambda {
+        scope.some_method_the_class_does_not_have
+      }.should raise_error(NoMethodError)
+    end
+
+  end
+
+
+end

data/spec/api_client/utils_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe ApiClient::Utils do
+
+  describe '.deep_merge' do
+
+    it "merges two hashes updating the first one" do
+      hash_a = { :a => 1, :b => 2  }
+      hash_b = { :b => 3, :c => 45 }
+      ApiClient::Utils.deep_merge hash_a, hash_b
+      hash_a.should == { :a => 1, :b => 3, :c=>45 }
+      hash_b.should == { :b => 3, :c => 45 }
+    end
+
+    it "deeply merges two hashes recursively" do
+      hash_a = { :a => { :foo => 2, :boo => { :wat => 'wat' } }, :b => 2  }
+      hash_b = { :b => 3, :c => 45, :a => { :boo => { :wat => "WAT????" } } }
+      ApiClient::Utils.deep_merge hash_a, hash_b
+      hash_a.should == { :a => { :foo => 2, :boo => { :wat => 'WAT????' } }, :b => 3, :c => 45  }
+    end
+
+    it "require correct key type" do
+      hash_a = { :a  => 1 }
+      hash_b = { 'a' => 2 }
+      ApiClient::Utils.deep_merge hash_a, hash_b
+      hash_a.should == { :a => 1, 'a' => 2 }
+
+    end
+
+  end
+
+end