active_rest_client 0.9.58

data/lib/active_rest_client/result_iterator.rb

@@ -0,0 +1,66 @@
+module ActiveRestClient
+  class ResultIterator
+    include Enumerable
+
+    attr_accessor :_status
+    attr_reader :items
+
+    def initialize(status = nil)
+      @_status = status
+      @items = []
+    end
+
+    def <<(item)
+      @items << item
+    end
+
+    def size
+      @items.size
+    end
+
+    def index(value)
+      @items.index(value)
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def each
+      @items.each do |el|
+        yield el
+      end
+    end
+
+    def last
+      @items.last
+    end
+
+    def [](key)
+      @items[key]
+    end
+
+    def shuffle
+      @items = @items.shuffle
+      self
+    end
+
+    def parallelise(method=nil)
+      collected_responses = []
+      threads = []
+      @items.each do |item|
+        threads << Thread.new do
+          ret = item.send(method) if method
+          ret = yield(item) if block_given?
+          Thread.current[:response] = ret
+        end
+      end
+      threads.each do |t|
+        t.join
+        collected_responses << t[:response]
+      end
+      collected_responses
+    end
+
+  end
+end

data/lib/active_rest_client/validation.rb

@@ -0,0 +1,60 @@
+module ActiveRestClient
+  module Validation
+    module ClassMethods
+      def validates(field_name, options={}, &block)
+        @_validations ||= []
+        @_validations << {field_name:field_name, options:options, block:block}
+      end
+
+      def _validations
+        @_validations ||= []
+        @_validations
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def valid?
+      @errors = Hash.new {|h,k| h[k] = []}
+      self.class._validations.each do |validation|
+        value = self.send(validation[:field_name])
+        validation[:options].each do |type, options|
+          if type == :presence
+            if value.nil?
+              @errors[validation[:field_name]] << "must be present"
+            end
+          elsif type == :length
+            if options[:within]
+              @errors[validation[:field_name]] << "must be within range #{options[:within]}" unless options[:within].include?(value.to_s.length )
+            end
+            if options[:minimum]
+              @errors[validation[:field_name]] << "must be at least #{options[:minimum]} characters long" unless value.to_s.length >= options[:minimum]
+            end
+            if options[:maximum]
+              @errors[validation[:field_name]] << "must be no more than #{options[:minimum]} characters long" unless value.to_s.length <= options[:maximum]
+            end
+          elsif type == :numericality
+            numeric = (true if Float(value) rescue false)
+            @errors[validation[:field_name]] << "must be numeric" unless numeric
+          elsif type == :minimum && !value.nil?
+            @errors[validation[:field_name]] << "must be at least #{options}" unless value.to_f >= options.to_f
+          elsif type == :maximum && !value.nil?
+            @errors[validation[:field_name]] << "must be no more than #{options}" unless value.to_f <= options.to_f
+          end
+        end
+        if validation[:block]
+          validation[:block].call(self, validation[:field_name], value)
+        end
+      end
+      @errors.empty?
+    end
+
+    def errors
+      @errors ||= Hash.new {|h,k| h[k] = []}
+      @errors
+    end
+  end
+
+end

data/lib/active_rest_client/version.rb

@@ -0,0 +1,3 @@
+module ActiveRestClient
+  VERSION = "0.9.58"
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+class EmptyExample < ActiveRestClient::Base
+  whiny_missing true
+end
+
+class TranslatorExample
+  def self.all(object)
+    ret = {}
+    ret["first_name"] = object["name"]
+    ret
+  end
+end
+
+class AlteringClientExample < ActiveRestClient::Base
+  translator TranslatorExample
+  base_url "http://www.example.com"
+
+  get :all, "/all", fake:"{\"name\":\"Billy\"}"
+  get :list, "/list", fake:"{\"name\":\"Billy\", \"country\":\"United Kingdom\"}"
+  get :iterate, "/iterate", fake:"{\"name\":\"Billy\", \"country\":\"United Kingdom\"}"
+  get :find, "/find/:id"
+end
+
+class RecordResponseExample < ActiveRestClient::Base
+  base_url "http://www.example.com"
+
+  record_response do |url, response|
+    raise Exception.new("#{url}|#{response.body}")
+  end
+
+  get :all, "/all"
+end
+
+describe ActiveRestClient::Base do
+  it 'should instantiate a new descendant' do
+    expect{EmptyExample.new}.to_not raise_error(Exception)
+  end
+
+  it "should not instantiate a new base class" do
+    expect{ActiveRestClient::Base.new}.to raise_error(Exception)
+  end
+
+  it "should save attributes passed in constructor" do
+    client = EmptyExample.new(:test => "Something")
+    expect(client._attributes[:test]).to be_a(String)
+  end
+
+  it "should allow attribute reading using missing method names" do
+    client = EmptyExample.new(:test => "Something")
+    expect(client.test).to eq("Something")
+  end
+
+  it "should allow attribute reading using [] array notation" do
+    client = EmptyExample.new(:test => "Something")
+    expect(client["test"]).to eq("Something")
+  end
+
+  it "allows iteration over attributes using each" do
+    client = AlteringClientExample.iterate
+    expect(client).to be_respond_to(:each)
+    keys = []
+    values = []
+    client.each do |key, value|
+      keys << key ; values << value
+    end
+    expect(keys).to eq(%i{name country})
+    expect(values).to eq(["Billy", "United Kingdom"])
+  end
+
+  it "should automatically parse ISO 8601 format dates" do
+    t = Time.now
+    client = EmptyExample.new(:test => t.iso8601)
+    expect(client["test"]).to be_an_instance_of(DateTime)
+    expect(client["test"].to_s).to eq(t.to_datetime.to_s)
+  end
+
+  it "should store attributes set using missing method names and mark them as dirty" do
+    client = EmptyExample.new()
+    client.test = "Something"
+    expect(client.test.to_s).to eq("Something")
+    expect(client).to be_dirty
+  end
+
+  it "should store attribute set using []= array notation and mark them as dirty" do
+    client = EmptyExample.new()
+    client["test"] = "Something"
+    expect(client["test"].to_s).to eq("Something")
+    expect(client).to be_dirty
+  end
+
+  it "should overwrite attributes already set and mark them as dirty" do
+    client = EmptyExample.new(:hello => "World")
+    client._clean!
+    expect(client).to_not be_dirty
+
+    client.hello = "Everybody"
+    expect(client).to be_dirty
+  end
+
+  it 'should respond_to? attributes defined in the response' do
+    client = EmptyExample.new(:hello => "World")
+    client.respond_to?(:hello).should be_true
+    client.respond_to?(:world).should be_false
+  end
+
+  it "should save the base URL for the API server" do
+    class BaseExample < ActiveRestClient::Base
+      base_url "https://www.example.com/api/v1"
+    end
+    expect(BaseExample.base_url).to eq("https://www.example.com/api/v1")
+  end
+
+  it "should allow changing the base_url while running" do
+    class OutsideBaseExample < ActiveRestClient::Base ; end
+
+    ActiveRestClient::Base.base_url = "https://www.example.com/api/v1"
+    expect(OutsideBaseExample.base_url).to eq("https://www.example.com/api/v1")
+
+    ActiveRestClient::Base.base_url = "https://www.example.com/api/v2"
+    expect(OutsideBaseExample.base_url).to eq("https://www.example.com/api/v2")
+  end
+
+  it "should include the Mapping module" do
+    expect(EmptyExample).to respond_to(:_calls)
+    expect(EmptyExample).to_not respond_to(:_non_existant)
+  end
+
+  it "should be able to easily clean all attributes" do
+    client = EmptyExample.new(hello:"World", goodbye:"Everyone")
+    expect(client).to be_dirty
+    client._clean!
+    expect(client).to_not be_dirty
+  end
+
+  it "should not overly pollute the instance method namespace to reduce chances of clashing (<10 instance methods)" do
+    instance_methods = EmptyExample.instance_methods - Object.methods
+    instance_methods = instance_methods - instance_methods.grep(/^_/)
+    expect(instance_methods.size).to be < 10
+  end
+
+  it "should raise an exception for missing attributes if whiny_missing is enabled" do
+    expect{EmptyExample.new.first_name}.to raise_error(ActiveRestClient::NoAttributeException)
+  end
+
+  it "should be able to lazy instantiate an object from a prefixed lazy_ method call" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+    example = AlteringClientExample.lazy_find(1)
+    expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
+    expect(example.first_name).to eq("Billy")
+  end
+
+  it "should be able to lazy instantiate an object from a prefixed lazy_ method call from an instance" do
+    ActiveRestClient::Connection.any_instance.should_receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+    example = AlteringClientExample.new.lazy_find(1)
+    expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
+    expect(example.first_name).to eq("Billy")
+  end
+
+  context "accepts a Translator to reformat JSON" do
+    it "should log a deprecation warning when using a translator" do
+      ActiveRestClient::Logger.should_receive(:warn) do |message|
+        expect(message).to start_with("DEPRECATION")
+      end
+      Proc.new do
+        class DummyExample < ActiveRestClient::Base
+          translator TranslatorExample
+        end
+      end.call
+    end
+
+    it "should call Translator#method when calling the mapped method if it responds to it" do
+      TranslatorExample.should_receive(:all).with(an_instance_of(Hash)).and_return({})
+      AlteringClientExample.all
+    end
+
+    it "should not raise errors when calling Translator#method if it does not respond to it" do
+      expect {AlteringClientExample.list}.to_not raise_error
+    end
+
+    it "should translate JSON returned through the Translator" do
+      ret = AlteringClientExample.all
+      expect(ret.first_name).to eq("Billy")
+      expect(ret.name).to be_nil
+    end
+
+    it "should return original JSON for items that aren't handled by the Translator" do
+      ret = AlteringClientExample.list
+      expect(ret.name).to eq("Billy")
+      expect(ret.first_name).to be_nil
+    end
+  end
+
+  context "directly call a URL, rather than via a mapped method" do
+    it "should be able to directly call a URL" do
+      ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      EmptyExample._request("http://api.example.com/")
+    end
+
+    it "runs filters as usual" do
+      ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      EmptyExample.should_receive(:_filter_request).with(any_args)
+      EmptyExample._request("http://api.example.com/")
+    end
+
+    it "should make an HTTP request" do
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      EmptyExample._request("http://api.example.com/")
+    end
+
+    it "should map the response from the directly called URL in the normal way" do
+      ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      example = EmptyExample._request("http://api.example.com/")
+      expect(example.first_name).to eq("Billy")
+    end
+
+    it "should be able to lazy load a direct URL request" do
+      ActiveRestClient::Request.any_instance.should_receive(:do_request).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      example = EmptyExample._lazy_request("http://api.example.com/")
+      expect(example).to be_an_instance_of(ActiveRestClient::LazyLoader)
+      expect(example.first_name).to eq("Billy")
+    end
+
+    it "should be able to specify a method and parameters for the call" do
+      ActiveRestClient::Connection.any_instance.should_receive(:post).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      EmptyExample._request("http://api.example.com/", :post, {id:1234})
+    end
+
+    it "should be able to use mapped methods to create a request to pass in to _lazy_request" do
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with('/find/1', anything).and_return(OpenStruct.new(status:200, headers:{}, body:"{\"first_name\":\"Billy\"}"))
+      request = AlteringClientExample._request_for(:find, :id => 1)
+      example = AlteringClientExample._lazy_request(request)
+      expect(example.first_name).to eq("Billy")
+    end
+  end
+
+  context "Recording a response" do
+    it "calls back to the record_response callback with the url and response body" do
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with(any_args).and_return(OpenStruct.new(status:200, headers:{}, body:"Hello world"))
+      expect{RecordResponseExample.all}.to raise_error(Exception, "/all|Hello world")
+
+    end
+  end
+
+end

data/spec/lib/caching_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe ActiveRestClient::Caching do
+  before :each do
+    ActiveRestClient::Base._reset_caching!
+  end
+
+  context "Configuration of caching" do
+    it "should not have caching enabled by default" do
+      class CachingExample1
+        include ActiveRestClient::Caching
+      end
+      expect(CachingExample1.perform_caching).to be_false
+    end
+
+    it "should be able to have caching enabled without affecting ActiveRestClient::Base" do
+      class CachingExample2
+        include ActiveRestClient::Caching
+      end
+      CachingExample2.perform_caching true
+      expect(CachingExample2.perform_caching).to be_true
+      expect(ActiveRestClient::Base.perform_caching).to be_false
+    end
+
+    it "should be possible to enable caching for all objects" do
+      class CachingExample3 < ActiveRestClient::Base ; end
+      ActiveRestClient::Base._reset_caching!
+
+      expect(ActiveRestClient::Base.perform_caching).to be_false
+
+      ActiveRestClient::Base.perform_caching = true
+      expect(ActiveRestClient::Base.perform_caching).to be_true
+      expect(EmptyExample.perform_caching).to be_true
+
+      ActiveRestClient::Base._reset_caching!
+    end
+
+    it "should use Rails.cache if available" do
+      begin
+        class Rails
+          def self.cache
+            true
+          end
+        end
+        expect(ActiveRestClient::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
+      ActiveRestClient::Base.cache_store = cache_store
+      expect(ActiveRestClient::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{ ActiveRestClient::Base.cache_store = CachingExampleCacheStore2.new }.to raise_error
+      expect{ ActiveRestClient::Base.cache_store = CachingExampleCacheStore3.new }.to raise_error
+      expect{ ActiveRestClient::Base.cache_store = CachingExampleCacheStore4.new }.to 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 < ActiveRestClient::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 = ActiveRestClient::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        etag:@etag)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", hash_including("If-None-Match" => @etag)).and_return(OpenStruct.new(status:304, headers:{}))
+      ret = Person.all
+      expect(ret.first_name).to eq("Johnny")
+    end
+
+    it "should read from the cache store, and not call the server if there's a hard expiry" do
+      cached_response = ActiveRestClient::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        expires:Time.now + 30)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      ActiveRestClient::Connection.any_instance.should_not_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 = ActiveRestClient::CachedResponse.new(
+        status:200,
+        result:@cached_object,
+        expires:Time.now + 30)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      ActiveRestClient::Connection.any_instance.should_not_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 < ActiveRestClient::Base ; end
+      object = ActiveRestClient::ResultIterator.new(200)
+      object << CachingExample3.new(first_name:"Johnny")
+      object << CachingExample3.new(first_name:"Billy")
+      etag = "6527914a91e0c5769f6de281f25bd891"
+      cached_response = ActiveRestClient::CachedResponse.new(
+        status:200,
+        result:object,
+        etag:@etag,
+        expires:Time.now + 30)
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(cached_response)
+      ActiveRestClient::Connection.any_instance.should_not_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
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
+      CachingExampleCacheStore5.any_instance.should_not_receive(:write)
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{}))
+      ret = Person.all
+    end
+
+    it "should write the response to the cache if there's an etag" do
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
+      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(ActiveRestClient::CachedResponse), {})
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{etag:"1234567890"}))
+      ret = Person.all
+    end
+
+    it "should write the response to the cache if there's a hard expiry" do
+      CachingExampleCacheStore5.any_instance.should_receive(:read).once.with("Person:/").and_return(nil)
+      CachingExampleCacheStore5.any_instance.should_receive(:write).once.with("Person:/", an_instance_of(ActiveRestClient::CachedResponse), an_instance_of(Hash))
+      ActiveRestClient::Connection.any_instance.should_receive(:get).with("/", an_instance_of(Hash)).and_return(OpenStruct.new(status:200, body:"{\"result\":true}", headers:{expires:(Time.now + 30).rfc822}))
+      ret = Person.all
+    end
+
+  end
+
+end