api_client 0.5.24-java → 0.5.25-java

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 = double
+    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/json_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Middlewares::Request::Json do
+  let(:app) { double }
+  let(:body) { {:some => :data} }
+  let(:env) do
+    {
+      :url => "http://api.twitter.com",
+      :request_headers => {},
+      :method => "post",
+      :body => body
+    }
+  end
+
+  subject { ApiClient::Connection::Middlewares::Request::Json.new(app) }
+
+  it "sets content type to json" do
+    app.should_receive(:call).
+      with(hash_including(:request_headers => {"Content-Type" => "application/json"}))
+
+    subject.call(env)
+  end
+
+  it "JSON encodes body" do
+    app.should_receive(:call).
+      with(hash_including(:body => MultiJson.dump(body)))
+
+    subject.call(env)
+  end
+end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe ApiClient::Connection::Middlewares::Request::Logger do
+  it "adds a oauth header to the request" do
+    app = double
+    io = StringIO.new
+    logger = Logger.new(io)
+    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)
+    io.string.should match("GET http://api.twitter.com")
+  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 = double
+    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,97 @@
+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
+
+      it "retains the original scope" do
+        @instance.original_scope = double
+        @instance.original_scope.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
+
+      it "retains the original scope" do
+        ApiClient::Resource::Base.stub(:update)
+        @instance.original_scope = double
+        @instance.original_scope.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
+
+      it "retains the original scope" do
+        @instance.original_scope = double
+        @instance.original_scope.should_receive(:create).with("name" => "Mike")
+        @instance.remote_create
+      end
+
+    end
+
+  end
+
+end

data/spec/api_client/resource/name_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ApiClient::Resource::NameResolver do
+  describe '.resolve' do
+    subject { described_class }
+
+    it 'changes My::Namespace::MyResouce to my_resource' do
+      subject.resolve('My::Namespace::MyResource').should == 'my_resource'
+    end
+
+    it 'changes Resource to resource' do
+      subject.resolve('Resource').should == 'resource'
+    end
+
+    it 'changes My::Resource to resoure' do
+      subject.resolve('My::Resource').should == 'resource'
+    end
+  end
+end

data/spec/api_client/resource/scope_spec.rb

@@ -0,0 +1,122 @@
+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 in raw mode" do
+      response = { "restful" => { "id" => 42 }}
+      @instance.should_receive(:get).with('/restfuls/1.json').and_return(response)
+      result = @instance.raw.find(1)
+      result.should == response
+    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 find_all to fetch many records in raw mode" do
+      response = [{ "restful" => { "id" => 42 } }, { "restful" => { "id" => 112 } }]
+      @instance.should_receive(:get).with('/restfuls.json', {}).and_return(response)
+      result = @instance.raw.find_all
+      result.should == response
+    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 in raw mode" do
+      response = { "restful" => { "id" => 42, "name" => "Foo" }}
+      @instance.should_receive(:post).with('/restfuls.json', {"restful" => {:name => "Foo"} }).and_return(response)
+      result = @instance.raw.create(:name => "Foo")
+      result.should == response
+    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 in raw mode" do
+      response = { "restful" => { "id" => 42, "name" => "Foo" }}
+      @instance.should_receive(:put).with('/restfuls/42.json', {"restful" => {:name => "Foo"} }).and_return(response)
+      result = @instance.raw.update(42, :name => "Foo")
+      result.should == response
+    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,204 @@
+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 "#raw_body" do
+
+    it "reads/writes non-hash body" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.raw_body('raw body string').should == instance
+      instance.raw_body.should == 'raw body string'
+    end
+
+    it "overwrites previous raw_body" do
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.raw_body('previous').raw_body('current')
+      instance.raw_body.should == 'current'
+    end
+
+    it "does request with raw body only if set, skips other params" do
+      connection = double
+      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, 'raw body string', {}).and_return(response)
+
+      result = instance.params({:skipped => 'params'}).raw_body('raw body string').request(:get, @path)
+      result.should == {"a"=> "1"}
+    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 = double
+      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 = double
+      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 = double
+      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 = double
+      instance = ApiClient::Scope.new(ApiClient::Base)
+      instance.stub(:connection).and_return(connection)
+      response = Faraday::Response.new(:body => '{"a": "1"}')
+      connection.should_receive(:get).twice.with(@path, @params, @headers).and_return(response)
+      result = instance.params(@params).headers(@headers).request(:get, @path, :raw => true)
+      result.should == response
+      result = instance.raw.params(@params).headers(@headers).request(:get, @path)
+      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 PATCH request" do
+      result = test_request :patch
+      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 = double
+        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