api_resource 0.4.1 → 0.4.2

data/spec/lib/callbacks_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ApiResource
+
+describe "Should put callbacks around save, create, update, and destroy by default" do
+  
+  before(:all) do
+    # This defines all the callbacks to check and see if they are fired
+    TestResource.class_eval <<-EOE, __FILE__, __LINE__ + 1
+      attr_accessor :s_val, :c_val, :u_val, :d_val
+      before_save :bs_cb; after_save :as_cb
+      before_create :bc_cb; after_create :ac_cb
+      before_update :bu_cb; after_update :au_cb
+      before_destroy :bd_cb; after_destroy :ad_cb
+      
+      def bs_cb
+        @s_val = 1
+      end
+      def as_cb
+        @s_val += 1
+      end
+      def bc_cb
+        @c_val = 1
+      end
+      def ac_cb
+       @c_val += 1
+      end
+      def bu_cb
+        @u_val = 1
+      end
+      def au_cb
+        @u_val += 1
+      end
+      def bd_cb
+        @d_val = 1
+      end
+      def ad_cb
+        @d_val += 1
+      end
+    EOE
+  end
+  
+  it "should fire save and create callbacks when saving a new record" do
+    tr = TestResource.new(:name => "Ethan", :age => 20)
+    tr.save.should be_true
+    tr.s_val.should eql(2)
+    tr.c_val.should eql(2)
+    tr.u_val.should be_nil
+  end
+  
+  it "should fire save and update callbacks when updating a record" do
+    tr = TestResource.new(:id => 1, :name => "Ethan", :age => 20)
+    tr.name = "Test"
+    tr.age = 21
+    tr.save.should be_true
+    tr.s_val.should eql(2)
+    tr.c_val.should be_nil
+    tr.u_val.should eql(2)
+  end
+  
+  it "should only fire destroy callbacks when destroying a record" do
+    tr = TestResource.new(:id => 1, :name => "Ethan", :age => 20)
+    tr.destroy.should be_true
+    tr.d_val.should eql(2)
+    tr.s_val.should be_nil   
+  end
+  
+end

data/spec/lib/connection_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ApiResource
+
+describe Connection do
+  
+  it "should be able to set the token directly on ApiResource" do
+    ApiResource.token = "123"
+    ApiResource::Base.token.should eql "123"
+  end
+  
+  it "should be able to set a default token value, which is passed through each request" do
+    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {"Accept"=>"application/json", "Lifebooker-Token" => "abc"}).returns(ApiResource::Mocks::MockResponse.new({}))
+    ApiResource::Base.token = "abc"
+    TestResource.find(1)
+  end
+
+  it "should set the Lifebooker-Token if one is present for GET requests" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {"Accept"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+
+    ApiResource::Base.token = token
+
+    TestResource.connection.get("/test_resources/1.json")
+  end
+
+  it "should set the Lifebooker-Token if one is present for DELETE requests" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Mocks::Connection.expects(:delete).with("/test_resources/1.json", {"Accept"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+
+    ApiResource::Base.token = token
+
+    TestResource.connection.delete("/test_resources/1.json")
+  end
+
+  it "should set the Lifebooker-Token if one is present for :head requests" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Mocks::Connection.expects(:head).with("/test_resources/1.json", {"Accept"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+
+    ApiResource::Base.token = token
+
+    TestResource.connection.head("/test_resources/1.json")
+  end
+
+  it "should set the Lifebooker-Token if one is present for POST requests" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Mocks::Connection.expects(:post).with("/test_resources/1.json", {}, {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+
+    ApiResource::Base.token = token
+
+    TestResource.connection.post("/test_resources/1.json")
+  end
+
+  it "should set the Lifebooker-Token if one is present for PUT requests" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Mocks::Connection.expects(:put).with("/test_resources/1.json", {}, {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+
+    ApiResource::Base.token = token
+
+    TestResource.connection.put("/test_resources/1.json")
+  end
+
+  it "should set its headers upon initialization" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Base.token = token
+
+    TestResource.connection.headers.include?("Lifebooker-Token").should eql true
+    TestResource.connection.headers["Lifebooker-Token"] = token
+  end
+
+  it "should reset headers upon initialization" do
+    token = Kernel.rand(100000).to_s
+    ApiResource::Base.token = token
+
+    TestResource.connection.headers.include?("Lifebooker-Token").should eql true
+    TestResource.connection.headers["Lifebooker-Token"] = token
+  end
+  
+  it "should be able to set a token for a given block" do
+    ApiResource::Base.token = "123456"
+    begin
+      ApiResource.with_token("testing") do
+        ApiResource::Base.token.should eql "testing"
+        raise "AAAH"
+      end
+    rescue => e
+      # should still reset the token
+    end
+    ApiResource::Base.token.should eql "123456"
+  end
+  
+  it "should provider a method to regenerate its connection" do
+    conn = ApiResource::Base.connection
+    conn.should be ApiResource::Base.connection
+    ApiResource.reset_connection
+    conn.should_not be ApiResource::Base.connection
+  end
+  
+  context "No Mocks" do
+    before(:all) do
+      ApiResource::Mocks.remove
+    end
+    after(:all) do
+      ApiResource::Mocks.init
+      ApiResource.timeout = 10
+      ApiResource.open_timeout = 10
+    end
+    it "should be able to set a timeout for its connection" do
+      ApiResource.timeout = 1
+      ApiResource.timeout.should eql 1
+      ApiResource.open_timeout = 1
+      ApiResource.open_timeout.should eql 1
+
+      ApiResource::Base.connection.send(:http, "/test").options[:timeout].should eql 1
+      ApiResource::Base.connection.send(:http, "/test").options[:open_timeout].should eql 1
+      
+      ApiResource.timeout = 100
+      ApiResource::Base.connection.send(:http, "/test").options[:timeout].should eql 100
+
+    end
+    
+    it "should time out if RestClient takes too long" do
+      
+      # hopefully google won't actually respond this fast :)
+      ApiResource.timeout = 0.001
+      ApiResource::Base.site = "http://www.google.com"
+      lambda{
+        ApiResource::Base.connection.get("/")
+      }.should raise_error(ApiResource::RequestTimeout)
+      
+    end
+    
+  end
+  
+
+  
+end

data/spec/lib/local_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'json'
+
+include ApiResource
+
+describe "Local" do
+  
+  it "should not go to the server to fetch a resource definition" do
+    ApiResource::Connection.any_instance.expects(:get).never
+    class MyTestResource < ApiResource::Local
+      scope :test, {:test => true}
+    end
+    mtr = MyTestResource.new
+    # should still have scopes
+    MyTestResource.reload_class_attributes
+    mtr.scopes.should_not be_blank
+    
+  end
+  
+end

data/spec/lib/mocks_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'json'
+
+include ApiResource
+
+describe Mocks, :focus do
+  
+  # we set up the mocks in spec helper, so we can just assert this
+  it "should hijack the connection" do
+    ApiResource::Mocks::Interface.any_instance.expects(:get).once.returns(
+      ApiResource::Mocks::MockResponse.new({}, {:headers => {"Content-type" => "application/json"}, :status_code => 200})
+    )
+    TestResource.reload_class_attributes
+  end
+  
+  it "should allow the user to raise errors for invalid responsed" do
+    old_err_status = ApiResource.raise_missing_definition_error 
+    ApiResource::Base.raise_missing_definition_error = true
+    
+    lambda {
+      class MyNewInvalidResource < ApiResource::Base; end
+      MyNewInvalidResource.new 
+    }.should raise_error(ApiResource::ResourceNotFound)
+    
+    ApiResource.raise_missing_definition_error = old_err_status
+  end
+
+  it "should merge params for a request" do
+    resp = ApiResource::Base.connection.get(
+      "/mock_with_block/1?#{{:test => "abc"}.to_query}"
+    )
+    resp["id"].should eql "1"
+    resp["test"].should eql "abc"
+  end
+
+  context "Mock Request" do
+    context "Initialize" do 
+      it "should correctly assign blank params" do
+        request = ApiResource::Mocks::MockRequest.new(:get, "/authenticate.json?token=")
+        request.params.should eql({"token" => ""})
+      end
+
+      it "should handle nested params" do
+        params = {
+          "a" => {
+            "b" => ["c", "d"]
+          }
+        }
+        request = ApiResource::Mocks::MockRequest.new(
+          :get, "/authenticate.json?#{params.to_query}"
+        )
+
+        request.params.should eql(params)
+
+      end
+
+      it "should parse true and false values into booleans" do
+
+        params = {
+          "a" => true,
+          "b" => false
+        }
+        request = ApiResource::Mocks::MockRequest.new(
+          :get, "/authenticate.json?#{params.to_query}"
+        )
+
+        request.params.should eql(params)
+
+      end
+
+    end
+  end
+  
+end

data/spec/lib/model_errors_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ApiResource
+
+describe "Saving Resources with errors" do
+  
+  before(:all) do
+    ErrorResource.include_root_in_json = true
+  end
+  
+  context "Remote Errors" do
+  
+    it "should be able to handle errors as a hash" do
+      t = ErrorResource.new(:name => "Ethan", :age => 12)
+      t.save.should be_false
+      t.errors.should_not be_nil
+      t.errors['name'].should_not be_nil
+    end
+  
+    it "should be able to handle errors as full messages" do
+      t = ErrorFullMessageResource.new(:name => "Ethan", :age => 12)
+      t.save.should be_false
+      t.errors.should_not be_nil
+      t.errors['name'].should_not be_nil
+    end
+    
+  end
+  
+end

data/spec/lib/prefixes_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe "With Prefixes" do
+
+  let(:prefix_model) do
+    PrefixModel.new({:foreign_key_id => "123", :name => "test"})
+  end
+
+  before(:each) do
+    PrefixModel.reload_class_attributes
+  end
+
+  context ".find" do
+
+    it "should use the prefix to find a single record when given as a param" do
+      PrefixModel.connection.expects(:get)
+        .with(
+          "/foreign/123/prefix_models/456.json",
+          instance_of(Hash)
+        )
+        .returns({})
+      PrefixModel.find(456, :params => {:foreign_key_id => 123})
+    end
+
+    it "should not use the prefix to find a single record when not given as a param to avoid automatic failure" do
+      PrefixModel.connection.expects(:get)
+        .with(
+          "/prefix_models/456.json",
+          instance_of(Hash)
+        )
+        .returns({})
+      PrefixModel.find(456)
+    end
+  end
+
+  context "#create" do
+
+    it "should use the prefix to create a new record" do
+      prefix_model.send(:connection).expects(:post)
+        .with(
+          "/foreign/123/prefix_models.json", 
+          {"prefix_model" => {"name" => "test"}}.to_json,
+          instance_of(Hash)
+        )
+      prefix_model.save
+    end
+
+  end
+
+  context "#first" do
+
+    it "should use the prefix to find records" do
+      prefix_model.send(:connection).expects(:get)
+        .with(
+          "/foreign/123/prefix_models.json", 
+          instance_of(Hash)
+        )
+        .returns([])
+      PrefixModel.first(:params => {:foreign_key_id => 123})
+    end
+
+    it "should not use the prefix to find records when not given as a param to avoid automatic failure" do
+      prefix_model.send(:connection).expects(:get)
+        .with(
+          "/prefix_models.json", 
+          instance_of(Hash)
+        )
+        .returns([])
+      PrefixModel.first
+    end
+
+  end
+
+  context "#destroy" do
+
+    it "should use the prefix to destroy a record" do
+
+      prefix_model.id = 456
+      prefix_model.send(:connection).expects(:delete)
+        .with(
+          "/foreign/123/prefix_models/456.json",
+          instance_of(Hash)
+        )
+      prefix_model.destroy
+
+    end
+
+  end
+
+  context "#update" do
+
+    it "should use the prefix to update a record" do
+      prefix_model.id = 456
+      prefix_model.name = "changed name"
+      prefix_model.send(:connection).expects(:put)
+        .with(
+          "/foreign/123/prefix_models/456.json", 
+          {"prefix_model" => {"name" => "changed name"}}.to_json,
+          instance_of(Hash)
+        )
+      prefix_model.save
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+require 'rubygems'
+require 'spork'
+#uncomment the following line to use spork with the debugger
+#require 'spork/ext/ruby-debug'
+
+Spork.prefork do
+  # Loading more in this block will cause your tests to run faster. However,
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
+
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
+  require 'bundler'
+  require 'api_resource'
+  require 'simplecov'
+
+
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+  end
+
+  # Requires supporting files with custom matchers and macros, etc,
+  # in ./support/ and its subdirectories.
+  Bundler.require(:default, :development)
+  Debugger.start
+
+  # Requires supporting files with custom matchers and macros, etc,
+  # in ./support/ and its subdirectories.
+  #ApiResource.load_mocks_and_factories
+  ApiResource.site = 'http://localhost:3000'
+  ApiResource.format = :json
+  ApiResource.load_mocks_and_factories
+
+  ApiResource.logger.level = Log4r::INFO
+
+  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+
+
+  RSpec.configure do |config|
+    config.mock_with :mocha
+  end
+
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+
+end
+
+# --- Instructions ---
+# Sort the contents of this file into a Spork.prefork and a Spork.each_run
+# block.
+#
+# The Spork.prefork block is run only once when the spork server is started.
+# You typically want to place most of your (slow) initializer code in here, in
+# particular, require'ing any 3rd-party gems that you don't normally modify
+# during development.
+#
+# The Spork.each_run block is run each time you run your specs.  In case you
+# need to load files that tend to change during development, require them here.
+# With Rails, your application modules are loaded automatically, so sometimes
+# this block can remain empty.
+#
+# Note: You can modify files loaded *from* the Spork.each_run block without
+# restarting the spork server.  However, this file itself will not be reloaded,
+# so if you change any of the code inside the each_run block, you still need to
+# restart the server.  In general, if you have non-trivial code in this file,
+# it's advisable to move it into a separate file so you can easily edit it
+# without restarting spork.  (For example, with RSpec, you could move
+# non-trivial code into a file spec/support/my_helper.rb, making sure that the
+# spec/support/* files are require'd from inside the each_run block.)
+#
+# Any code that is left outside the two blocks will be run during preforking
+# *and* during each_run -- that's probably not what you want.
+#
+# These instructions should self-destruct in 10 seconds.  If they don't, feel
+# free to delete them.