api_resource 0.4.0 → 0.4.1

data/spec/lib/callbacks_spec.rb

@@ -1,68 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,45 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'json'
-
-include ApiResource
-
-describe Mocks 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
-    end
-  end
-  
-end

data/spec/lib/model_errors_spec.rb

@@ -1,29 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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.