flexirest 1.2.0

data/spec/lib/caching_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Flexirest::Caching do
+  before :each do
+    Flexirest::Base._reset_caching!
+  end
+
+  context "Configuration of caching" do
+    it "should not have caching enabled by default" do
+      class CachingExample1
+        include Flexirest::Caching
+      end
+      expect(CachingExample1.perform_caching).to be_falsey
+    end
+
+    it "should be able to have caching enabled without affecting Flexirest::Base" do
+      class CachingExample2
+        include Flexirest::Caching
+      end
+      CachingExample2.perform_caching true
+      expect(CachingExample2.perform_caching).to be_truthy
+      expect(Flexirest::Base.perform_caching).to be_falsey
+    end
+
+    it "should be possible to enable caching for all objects" do
+      class CachingExample3 < Flexirest::Base ; end
+      Flexirest::Base._reset_caching!
+
+      expect(Flexirest::Base.perform_caching).to be_falsey
+
+      Flexirest::Base.perform_caching = true
+      expect(Flexirest::Base.perform_caching).to be_truthy
+      expect(CachingExample3.perform_caching).to be_truthy
+
+      Flexirest::Base._reset_caching!
+    end
+
+    it "should use Rails.cache if available" do
+      begin
+        class Rails
+          def self.cache
+            true
+          end
+        end
+        expect(Flexirest::Base.cache_store).to eq(true)
+      ensure
+        Object.send(:remove_const, :Rails) if defined?(Rails)
+      end
+
+    end
+
+    it "should use a custom cache store if a valid one is manually set" do
+      class CachingExampleCacheStore1
+        def read(key) ; end
+        def write(key, value, options={}) ; end
+        def fetch(key, &block) ; end
+      end
+      cache_store = CachingExampleCacheStore1.new
+      Flexirest::Base.cache_store = cache_store
+      expect(Flexirest::Base.cache_store).to eq(cache_store)
+    end
+
+    it "should error if you try to use a custom cache store that doesn't match the required interface" do
+      class CachingExampleCacheStore2
+        def write(key, value, options={}) ; end
+        def fetch(key, &block) ; end
+      end
+      class CachingExampleCacheStore3
+        def read(key) ; end
+        def fetch(key, &block) ; end
+      end
+      class CachingExampleCacheStore4
+        def read(key) ; end
+        def write(key, value, options={}) ; end
+      end
+
+      expect{ Flexirest::Base.cache_store = CachingExampleCacheStore2.new }.to raise_error
+      expect{ Flexirest::Base.cache_store = CachingExampleCacheStore3.new }.to raise_error
+      expect{ Flexirest::Base.cache_store = CachingExampleCacheStore4.new }.to raise_error
+    end
+
+    it "should allow you to remove the custom cache store" do
+      expect{ Flexirest::Base.cache_store = nil }.to_not raise_error
+    end
+  end
+
+  context "Reading/writing to the cache" do
+    before :each do
+      Object.send(:remove_const, :CachingExampleCacheStore5) if defined?(CachingExampleCacheStore5)
+      class CachingExampleCacheStore5
+        def read(key) ; end
+        def write(key, value, options={}) ; end
+        def fetch(key, &block) ; end
+      end
+
+      class Person < Flexirest::Base
+        perform_caching true
+        base_url "http://www.example.com"
+        get :all, "/"
+      end
+
+      Person.cache_store = CachingExampleCacheStore5.new
+
+      @etag = "6527914a91e0c5769f6de281f25bd891"
+      @cached_object = Person.new(first_name:"Johnny")
+    end
+
+    it "should read from the cache store, to check for an etag" do
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        etag:@etag)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(Flexirest::Connection).to receive(:get){ |connection, path, options|
+        expect(path).to eq('/')
+        expect(options[:headers]).to include("If-None-Match" => @etag)
+      }.and_return(::FaradayResponseMock.new(OpenStruct.new(status:304, response_headers:{})))
+      ret = Person.all
+      expect(ret.first_name).to eq("Johnny")
+    end
+
+    it 'queries the server when the cache has expired' do
+      cached_response = Flexirest::CachedResponse.new(
+        status: 200,
+        result: @cached_object,
+        etag: @etag
+      )
+      allow_any_instance_of(CachingExampleCacheStore5).to receive(:read).and_return(Marshal.dump(cached_response))
+      new_name = 'Pete'
+      response_body = Person.new(first_name: new_name).to_json
+      response = ::FaradayResponseMock.new(double(status: 200, response_headers: {}, body: response_body))
+      allow_any_instance_of(Flexirest::Connection).to(
+        receive(:get){ |connection, path, options|
+          expect(path).to eq('/')
+          expect(options[:headers]).to include('If-None-Match' => @etag)
+        }.and_return(response))
+
+      result = Person.all
+
+      expect(result.first_name).to eq new_name
+    end
+
+    it "should read from the cache store, and not call the server if there's a hard expiry" do
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        expires:Time.now + 30)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(Flexirest::Connection).not_to receive(:get)
+      ret = Person.all
+      expect(ret.first_name).to eq("Johnny")
+    end
+
+    it "should read from the cache store and restore to the same object" do
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        expires:Time.now + 30)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(Flexirest::Connection).not_to receive(:get)
+      p = Person.new(first_name:"Billy")
+      ret = p.all({})
+      expect(ret.first_name).to eq("Johnny")
+    end
+
+    it "should restore a result iterator from the cache store, if there's a hard expiry" do
+      class CachingExample3 < Flexirest::Base ; end
+      object = Flexirest::ResultIterator.new(double(status: 200))
+      object << CachingExample3.new(first_name:"Johnny")
+      object << CachingExample3.new(first_name:"Billy")
+      etag = "6527914a91e0c5769f6de281f25bd891"
+      cached_response = Flexirest::CachedResponse.new(
+        status:200,
+        result:object,
+        etag:etag,
+        expires:Time.now + 30)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(Marshal.dump(cached_response))
+      expect_any_instance_of(Flexirest::Connection).not_to receive(:get)
+      ret = Person.all
+      expect(ret.first.first_name).to eq("Johnny")
+      expect(ret._status).to eq(200)
+    end
+
+    it "should not write the response to the cache unless if has caching headers" do
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).not_to receive(:write)
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{}))
+      Person.all
+    end
+
+    it "should write the response to the cache if there's an etag" do
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), {})
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{etag:"1234567890"})))
+      Person.perform_caching true
+      Person.all
+    end
+
+    it "should write the response to the cache if there's a hard expiry" do
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(status:200, body:"{\"result\":true}", response_headers:{expires:(Time.now + 30).rfc822})))
+      Person.perform_caching = true
+      Person.all
+    end
+
+    it "should not write the response to the cache if there's an invalid expiry" do
+      expect_any_instance_of(CachingExampleCacheStore5).to receive(:read).once.with("Person:/").and_return(nil)
+      expect_any_instance_of(CachingExampleCacheStore5).to_not receive(:write).once.with("Person:/", an_instance_of(String), an_instance_of(Hash))
+      expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:"0"}))
+      Person.perform_caching = true
+      Person.all
+    end
+
+  end
+
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe Flexirest::Configuration do
+  before :each do
+    Object.send(:remove_const, :ConfigurationExample) if defined?(ConfigurationExample)
+    Flexirest::Base._reset_configuration!
+
+    class ConfigurationExample
+      include Flexirest::Configuration
+      base_url "http://www.example.com"
+      username "john"
+      password "smith"
+      request_body_type :json
+    end
+
+    class ConfigurationExampleBare
+      include Flexirest::Configuration
+    end
+  end
+
+  it "should default to non-whiny missing methods" do
+    class UnusuedConfigurationExample1
+      include Flexirest::Configuration
+    end
+    expect(UnusuedConfigurationExample1.whiny_missing).to be_falsey
+  end
+
+  it "should allow whiny missing methods to be enabled" do
+    ConfigurationExample.whiny_missing true
+    expect(ConfigurationExample.whiny_missing).to be_truthy
+  end
+
+  it "should remember the set base_url" do
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+  end
+
+  it "should remember the set base_url on a class, overriding a general one" do
+    Flexirest::Base.base_url = "http://general.example.com"
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+  end
+
+  it "should remove a trailing slash from a globally configured base_url" do
+    Flexirest::Base.base_url = "http://general.example.com/"
+    expect(ConfigurationExample.base_url).to eq("http://www.example.com")
+    Flexirest::Base.base_url = ""
+  end
+
+  it "should remember the set base_url on the base class if a more specific one hasn't been set" do
+    Flexirest::Base.base_url = "http://general.example.com"
+    expect(ConfigurationExampleBare.base_url).to eq("http://general.example.com")
+    Flexirest::Base.base_url = ""
+  end
+
+  it "should remove a trailing slash from a specific class configured base_url" do
+    class ConfigurationExample2
+      include Flexirest::Configuration
+      base_url "http://specific.example.com/"
+    end
+    expect(ConfigurationExample2.base_url).to eq("http://specific.example.com")
+  end
+
+  it "should remember the set username" do
+    expect(ConfigurationExample.username).to eq("john")
+  end
+
+  it "should remember the set username on a class, overriding a general one" do
+    Flexirest::Base.username = "bill"
+    expect(ConfigurationExample.username).to eq("john")
+    Flexirest::Base.username = nil
+  end
+
+  it "should escape the username" do
+    Flexirest::Base.username = "bill@example.com"
+    expect(Flexirest::Base.username).to eq("bill%40example.com")
+    Flexirest::Base.username = nil
+  end
+
+  it "should not doubly escape the username" do
+    Flexirest::Base.username = "bill%40example.com"
+    expect(Flexirest::Base.username).to_not eq("bill%2540example.com")
+    Flexirest::Base.username = nil
+  end
+
+  it "should remember the set password" do
+    expect(ConfigurationExample.password).to eq("smith")
+  end
+
+  it "should remember the set password on a class, overriding a general one" do
+    Flexirest::Base.password = "bloggs"
+    expect(ConfigurationExample.password).to eq("smith")
+    Flexirest::Base.password = nil
+  end
+
+  it "should escape the password" do
+    Flexirest::Base.password = "something@else"
+    expect(Flexirest::Base.password).to eq("something%40else")
+    Flexirest::Base.password = nil
+  end
+
+  it "should not doubly escape the password" do
+    Flexirest::Base.password = "something%40else"
+    expect(Flexirest::Base.password).to_not eq("something%2540else")
+    Flexirest::Base.password = nil
+  end
+
+  it "should default to a form_encoded request_body_type" do
+    expect(Flexirest::Base.request_body_type).to eq(:form_encoded)
+  end
+
+  it "should remember the request_body_type" do
+    expect(ConfigurationExample.request_body_type).to eq(:json)
+  end
+
+  it "should remember the set base_url on a class, overriding a general one" do
+    Flexirest::Base.request_body_type = :unknown
+    expect(Flexirest::Base.request_body_type).to eq(:unknown)
+    expect(ConfigurationExample.request_body_type).to eq(:json)
+  end
+
+  it "should default to non-lazy loading" do
+    class LazyLoadingConfigurationExample1
+      include Flexirest::Configuration
+    end
+    expect(LazyLoadingConfigurationExample1.lazy_load?).to be_falsey
+  end
+
+  it "should be able to switch on lazy loading" do
+    class LazyLoadingConfigurationExample2
+      include Flexirest::Configuration
+      lazy_load!
+    end
+    expect(LazyLoadingConfigurationExample2.lazy_load?).to be_truthy
+  end
+
+  describe 'api auth' do
+    context 'default' do
+      it "should be false using_api_auth?" do
+        expect(Flexirest::Base.using_api_auth?).to be_falsey
+      end
+    end
+
+    context 'setting api auth credentials' do
+      before(:each) do
+        ConfigurationExample.api_auth_credentials('id123', 'secret123')
+      end
+
+      it "should remember setting using_api_auth?" do
+        expect(ConfigurationExample.using_api_auth?).to be_truthy
+      end
+
+      it "should remember setting api_auth_access_id" do
+        expect(ConfigurationExample.api_auth_access_id).to eq('id123')
+      end
+
+      it "should remember setting api_auth_secret_key" do
+        expect(ConfigurationExample.api_auth_secret_key).to eq('secret123')
+      end
+
+      it "should inherit api_auth_credentials when not set" do
+        class ConfigurationExtension < ConfigurationExample
+        end
+        expect(ConfigurationExtension.api_auth_access_id).to eq('id123')
+        expect(ConfigurationExtension.api_auth_secret_key).to eq('secret123')
+      end
+
+      it "should override inherited api_auth_credentials when set" do
+        class ConfigurationExtension2 < ConfigurationExample
+        end
+        ConfigurationExtension2.api_auth_credentials('id456', 'secret456')
+        expect(ConfigurationExtension2.api_auth_access_id).to eq('id456')
+        expect(ConfigurationExtension2.api_auth_secret_key).to eq('secret456')
+      end
+    end
+  end
+
+  it "should default to non-verbose loggingg" do
+    class VerboseConfigurationExample1
+      include Flexirest::Configuration
+    end
+    expect(VerboseConfigurationExample1.verbose).to be_falsey
+  end
+
+  it "should be able to switch on verbose logging" do
+    class VerboseConfigurationExample2
+      include Flexirest::Configuration
+      verbose!
+    end
+    class VerboseConfigurationExample3
+      include Flexirest::Configuration
+      verbose true
+    end
+    expect(VerboseConfigurationExample2.verbose).to be_truthy
+    expect(VerboseConfigurationExample3.verbose).to be_truthy
+  end
+
+  it "should store a translator given" do
+    expect{ ConfigurationExample.send(:translator) }.to_not raise_error
+    ConfigurationExample.send(:translator, String.new)
+    expect(ConfigurationExample.translator).to respond_to(:length)
+  end
+
+  it "should store a proxy given" do
+    expect{ ConfigurationExample.send(:proxy) }.to_not raise_error
+    ConfigurationExample.send(:proxy, String.new)
+    expect(ConfigurationExample.proxy).to respond_to(:length)
+  end
+
+  describe "faraday_config" do
+    let(:faraday_double){double(:faraday).as_null_object}
+
+    it "should use default adapter if no other block set" do
+      expect(faraday_double).to receive(:adapter).with(Faraday.default_adapter)
+      ConfigurationExample.faraday_config.call(faraday_double)
+    end
+
+    it "should us set adapter if no other block set" do
+      ConfigurationExample.adapter = :net_http
+
+      expect(faraday_double).to receive(:adapter).with(:net_http)
+
+      ConfigurationExample.faraday_config.call(faraday_double)
+    end
+
+    it "should use the adapter of the passed in faraday_config block" do
+      ConfigurationExample.faraday_config {|faraday| faraday.adapter(:rack)}
+
+      expect(faraday_double).to receive(:adapter).with(:rack)
+
+      ConfigurationExample.faraday_config.call(faraday_double)
+    end
+
+  end
+
+end