remotable 0.1.2 → 0.2.0

data/test/bespoke_test.rb

@@ -0,0 +1,197 @@
+require "test_helper"
+require "remotable"
+require "support/bespoke"
+require "rr"
+
+
+class BespokeTest < ActiveSupport::TestCase
+  include RR::Adapters::TestUnit
+  
+  
+  teardown do
+    def model.new_resource
+      BespokeResource.new
+    end
+    def model.find_by(remote_attr, value)
+      nil
+    end
+  end
+  
+  
+  
+  # ========================================================================= #
+  # Finding                                                                   #
+  # ========================================================================= #
+  
+  test "should be able to find resources by different attributes" do
+    new_tenant_slug = "not_found"
+    assert_equal 0, BespokeTenant.where(:slug => new_tenant_slug).count,
+      "There's not supposed to be a BespokeTenant with the slug #{new_tenant_slug}."
+    
+    def model.find_by(attribute, value)
+      BespokeResource.new(:slug => value)
+    end
+    
+    new_tenant = BespokeTenant.find_by_slug(new_tenant_slug)
+    assert_not_nil new_tenant, "A remote @tenant was not found with the slug #{new_tenant_slug.inspect}"
+  end
+  
+  test "should create a record locally when fetching a new remote resource" do
+    new_tenant_slug = "17"
+    assert_equal 0, BespokeTenant.where(:slug => new_tenant_slug).count,
+      "There's not supposed to be a BespokeTenant with the slug #{new_tenant_slug}."
+    
+    def model.find_by(attribute, value)
+      BespokeResource.new(:slug => value)
+    end
+    
+    assert_difference "BespokeTenant.count", +1 do
+      new_tenant = BespokeTenant.find_by_slug(new_tenant_slug)
+      assert_not_nil new_tenant, "A remote tenant was not found with the id #{new_tenant_slug.inspect}"
+    end
+  end
+  
+  test "if a resource is neither local nor remote, raise an exception with the bang method" do
+    new_tenant_slug = "not_found3"
+    assert_equal 0, BespokeTenant.where(:slug => new_tenant_slug).count,
+      "There's not supposed to be a BespokeTenant with the slug #{new_tenant_slug}."
+    
+    assert_raises ActiveRecord::RecordNotFound do
+      BespokeTenant.find_by_slug!(new_tenant_slug)
+    end
+  end
+  
+  
+  
+  # ========================================================================= #
+  # Updating                                                                 #
+  # ========================================================================= #
+  
+  test "should update a record remotely when updating one locally" do
+    @tenant = Factory(:bespoke_tenant)
+    new_name = "Totally Wonky"
+    
+    # RemoteTenant.run_simulation do |s|
+    #   s.show(@tenant.remote_id, {
+    #     :id => @tenant.remote_id,
+    #     :slug => @tenant.slug,
+    #     :church_name => @tenant.name
+    #   })
+    #   s.update(@tenant.remote_id)
+    #   
+    #   @tenant.nosync = false
+    #   @tenant.name = "Totally Wonky"
+    #   assert_equal true, @tenant.any_remote_changes?
+    #   
+    #   @tenant.save!
+    #   
+    #   pending "Not sure how to test that an update happened"
+    # end
+  end
+  
+  test "should fail to update a record locally when failing to update one remotely" do
+    @tenant = Factory(:bespoke_tenant, :nosync => false)
+    
+    def model.find_by(attribute, value)
+      BespokeResource.new(attribute => value)
+    end
+    
+    def resource.save
+      false
+    end
+    
+    def resource.errors
+      {:name => ["is already taken"]}
+    end
+    
+    @tenant.name = "Totally Wonky"
+    assert_raises(ActiveRecord::RecordInvalid) do
+      @tenant.save!
+    end
+    assert_equal ["is already taken"], @tenant.errors[:name]
+  end
+  
+  
+  
+  
+  # ========================================================================= #
+  # Creating                                                                  #
+  # ========================================================================= #
+  
+  test "should create a record remotely when creating one locally" do
+    @tenant = BespokeTenant.new({
+      :slug => "brand_new",
+      :name => "Brand New"
+    })
+    
+    assert_nil @tenant.remote_resource
+    @tenant.save!
+    assert_not_nil @tenant.remote_resource
+  end
+  
+  test "should fail to create a record locally when failing to create one remotely" do
+    @tenant = BespokeTenant.new({
+      :slug => "brand_new",
+      :name => "Brand New"
+    })
+    
+    def model.new_resource
+      resource = BespokeResource.new
+      def resource.save; false; end
+      def resource.errors; {:name => ["is already taken"]}; end
+      resource
+    end
+    
+    assert_raises(ActiveRecord::RecordInvalid) do
+      @tenant.save!
+    end
+    
+    assert_equal ["is already taken"], @tenant.errors[:name]
+  end
+  
+  
+  
+  # ========================================================================= #
+  # Destroying                                                                #
+  # ========================================================================= #
+  
+  test "should destroy a record remotely when destroying one locally" do
+    @tenant = Factory(:bespoke_tenant, :nosync => false)
+    mock(resource).destroy { true }
+    @tenant.destroy
+  end
+  
+  test "should fail to destroy a record locally when failing to destroy one remotely" do
+    @tenant = Factory(:bespoke_tenant, :nosync => false)
+    mock(resource).destroy { raise StandardError }
+    assert_raises(StandardError) do
+      @tenant.destroy
+    end
+  end
+  
+  test "should delete a local record when a remote record has been deleted" do
+    @tenant = Factory(:bespoke_tenant, :expires_at => 1.year.ago)
+    
+    def model.find_by(remote_attr, value)
+      nil
+    end
+    
+    assert_difference "BespokeTenant.count", -1 do
+      @tenant = BespokeTenant.find_by_slug(@tenant.slug)
+      assert_equal nil, @tenant
+    end
+  end
+  
+  
+  
+private
+  
+  def model
+    BespokeTenant.remote_model
+  end
+  
+  def resource
+    @tenant.remote_resource
+  end
+  
+end

data/test/factories/tenants.rb

@@ -5,3 +5,11 @@ Factory.define :tenant do |f|
   f.expires_at 100.years.from_now
   f.nosync true
 end
+
+Factory.define :bespoke_tenant do |f|
+  f.sequence(:slug) { |n| "test#{n}" }
+  f.name "Test"
+  f.sequence(:remote_id)
+  f.expires_at 100.years.from_now
+  f.nosync true
+end

data/test/remotable_test.rb

@@ -1,7 +1,6 @@
 require "test_helper"
 require "remotable"
-require "support/active_resource"
-require "active_resource_simulator"
+require "support/bespoke"
 
 
 class RemotableTest < ActiveSupport::TestCase
@@ -19,290 +18,83 @@ class RemotableTest < ActiveSupport::TestCase
   end
   
   test "should be able to generate paths for with different attributes" do
-    assert_equal "/api/accounts/by_slug/value.json",   RemoteTenant.path_for(:slug, "value")
-    assert_equal "/api/accounts/by_nombre/value.json", RemoteTenant.path_for(:name, "value")
+    assert_equal "by_slug/value",   Tenant.remote_path_for(:slug, "value")
+    assert_equal "by_nombre/value", Tenant.remote_path_for(:name, "value")
   end
   
-  
-  
-  test "should be able to find resources by different attributes" do
-    new_tenant_slug = "not_found"
-    
-    assert_equal 0, Tenant.where(:slug => new_tenant_slug).count,
-      "There's not supposed to be a Tenant with the slug #{new_tenant_slug}."
-    
-    assert_difference "Tenant.count", +1 do
-      RemoteTenant.run_simulation do |s|
-        s.show(nil, {
-          :id => 46,
-          :slug => new_tenant_slug,
-          :church_name => "Not Found"
-        }, :path => "/api/accounts/by_slug/#{new_tenant_slug}.json")
-        
-        new_tenant = Tenant.find_by_slug(new_tenant_slug)
-        assert_not_nil new_tenant, "A remote tenant was not found with the slug #{new_tenant_slug.inspect}"
-      end
-    end
-  end
-  
-  test "should be able to find resources with the bang method" do
-    new_tenant_slug = "not_found2"
-    
-    assert_equal 0, Tenant.where(:slug => new_tenant_slug).count,
-      "There's not supposed to be a Tenant with the slug #{new_tenant_slug}."
-    
-    assert_difference "Tenant.count", +1 do
-      RemoteTenant.run_simulation do |s|
-        s.show(nil, {
-          :id => 46,
-          :slug => new_tenant_slug,
-          :church_name => "Not Found"
-        }, :path => "/api/accounts/by_slug/#{new_tenant_slug}.json")
-        
-        new_tenant = Tenant.find_by_slug!(new_tenant_slug)
-        assert_not_nil new_tenant, "A remote tenant was not found with the slug #{new_tenant_slug.inspect}"
-      end
-    end
-  end
-  
-  test "if a resource is neither local nor remote, raise an exception with the bang method" do
-    new_tenant_slug = "not_found3"
-    
-    assert_equal 0, Tenant.where(:slug => new_tenant_slug).count,
-      "There's not supposed to be a Tenant with the slug #{new_tenant_slug}."
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(nil, nil, :status => 404, :path => "/api/accounts/by_slug/#{new_tenant_slug}.json")
-      
-      assert_raises ActiveRecord::RecordNotFound do
-        Tenant.find_by_slug!(new_tenant_slug)
-      end
-    end
+  test "should be able to generate paths for composite keys" do
+    assert_equal "groups/5/tenants/test",   RemoteWithCompositeKey.remote_path_for([:group_id, :slug], 5, "test")
   end
   
   
   
-  test "should be able to find resources by different attributes and specify a path" do
-    new_tenant_name = "JohnnyG"
-    
-    assert_equal 0, Tenant.where(:name => new_tenant_name).count,
-      "There's not supposed to be a Tenant with the name #{new_tenant_name}."
-    
-    assert_difference "Tenant.count", +1 do
-      RemoteTenant.run_simulation do |s|
-        s.show(nil, {
-          :id => 46,
-          :slug => "not_found",
-          :church_name => new_tenant_name
-        }, :path => "/api/accounts/by_nombre/#{new_tenant_name}.json")
-        
-        new_tenant = Tenant.find_by_name(new_tenant_name)
-        assert_not_nil new_tenant, "A remote tenant was not found with the name #{new_tenant_name.inspect}"
-      end
-    end
+  test "should support temporary models" do
+    assert_nil BespokeTenant.find_by_slug("404")
+    assert_not_nil BespokeTenant.with_remote_model(BespokeModel2.new) { BespokeTenant.find_by_slug("404") }
+    assert_nil BespokeTenant.find_by_slug("405")
   end
   
-  
-  
-  test "should create a record locally when fetching a new remote resource" do
-    new_tenant_id = 17
-    
-    assert_equal 0, Tenant.where(:remote_id => new_tenant_id).count,
-      "There's not supposed to be a Tenant with the id #{new_tenant_id}."
-    
-    assert_difference "Tenant.count", +1 do
-      RemoteTenant.run_simulation do |s|
-        s.show(new_tenant_id, {
-          :id => new_tenant_id,
-          :slug => "not_found",
-          :church_name => "Not Found"
-        })
-        
-        new_tenant = Tenant.find_by_remote_id(new_tenant_id)
-        assert_not_nil new_tenant, "A remote tenant was not found with the id #{new_tenant_id.inspect}"
-      end
-    end
+  test "should support temporary models and chainable syntax" do
+    assert_nil BespokeTenant.find_by_slug("404")
+    assert_not_nil BespokeTenant.with_remote_model(BespokeModel2.new).find_by_slug("404")
+    assert_nil BespokeTenant.find_by_slug("405")
   end
   
   
   
-  test "should not fetch a remote record when a local record is not expired" do
-    tenant = Factory(:tenant, :expires_at => 100.years.from_now)
-    unexpected_name = "Totally Wonky"
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => unexpected_name
-      })
-      
-      tenant = Tenant.find_by_remote_id(tenant.remote_id)
-      assert_not_equal unexpected_name, tenant.name
-    end
-  end
-  
-  
+  # ========================================================================= #
+  # Finders                                                                   #
+  # ========================================================================= #
   
-  test "should fetch a remote record when a local record is expired" do
-    tenant = Factory(:tenant, :expires_at => 1.year.ago)
-    unexpected_name = "Totally Wonky"
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => unexpected_name
-      })
-      
-      tenant = Tenant.find_by_remote_id(tenant.remote_id)
-      assert_equal unexpected_name, tenant.name
-    end
+  test "should create expected finders" do
+    assert_equal true, Tenant.respond_to?(:find_by_name)
+    assert_equal true, Tenant.respond_to?(:find_by_slug)
+    assert_equal true, RemoteWithoutKey.respond_to?(:find_by_id)
+    assert_equal true, RemoteWithCompositeKey.respond_to?(:find_by_group_id_and_slug)
   end
   
-  
-  
-  test "should delete a local record when a remote record has been deleted" do
-    tenant = Factory(:tenant, :expires_at => 1.year.ago)
-    
-    assert_difference "Tenant.count", -1 do
-      RemoteTenant.run_simulation do |s|
-        s.show(tenant.remote_id, nil, :status => 404)
-        
-        tenant = Tenant.find_by_remote_id(tenant.remote_id)
-        assert_equal nil, tenant
-      end
-    end
+  test "should recognize a finder method with a single key" do
+    method_details = RemoteWithKey.recognize_remote_finder_method(:find_by_slug)
+    assert_not_equal false, method_details
+    assert_equal :slug, method_details[:remote_key]
   end
   
-  
-  
-  test "should update a record remotely when updating one locally" do
-    tenant = Factory(:tenant)
-    new_name = "Totally Wonky"
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => tenant.name
-      })
-      s.update(tenant.remote_id)
-      
-      tenant.nosync = false
-      tenant.name = "Totally Wonky"
-      assert_equal true, tenant.any_remote_changes?
-      
-      tenant.save!
-      
-      pending "Not sure how to test that an update happened"
-    end
+  test "should recognize a finder method with a composite key" do
+    method_details = RemoteWithCompositeKey.recognize_remote_finder_method(:find_by_group_id_and_slug)
+    assert_not_equal false, method_details
+    assert_equal [:group_id, :slug], method_details[:remote_key]
   end
   
-  test "should fail to update a record locally when failing to update one remotely" do
-    tenant = Factory(:tenant)
-    new_name = "Totally Wonky"
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => tenant.name
-      })
-      s.update(tenant.remote_id, :status => 422, :body => {
-        :errors => {:church_name => ["is already taken"]}
-      })
-      
-      tenant.nosync = false
-      tenant.name = new_name
-      assert_raises(ActiveRecord::RecordInvalid) do
-        tenant.save!
-      end
-      assert_equal ["is already taken"], tenant.errors[:name]
-    end
-  end
   
   
+  # ========================================================================= #
+  # Validating Models                                                         #
+  # ========================================================================= #
   
-  test "should create a record remotely when creating one locally" do
-    tenant = Tenant.new({
-      :slug => "brand_new",
-      :name => "Brand New"
-    })
-    
-    RemoteTenant.run_simulation do |s|
-      s.create({
-        :id => 143,
-        :slug => tenant.slug,
-        :church_name => tenant.name
-      })
-      
-      tenant.save!
-      
-      assert_equal true, tenant.remote_resource.persisted?
-    end
+  test "should raise an exception if a remote model does not respond to all class methods" do
+    class Example1 < ActiveRecord::Base; set_table_name "tenants"; end
+    class RemoteModel1; def self.find_by(*args); end; end
+    assert_raise(Remotable::InvalidRemoteModel) { Example1.remote_model RemoteModel1 }
   end
   
-  test "should fail to create a record locally when failing to create one remotely" do
-    tenant = Tenant.new({
-      :slug => "brand_new",
-      :name => "Brand New"
-    })
-    
-    RemoteTenant.run_simulation do |s|
-      s.create({
-        :errors => {
-          :what => ["ever"],
-          :church_name => ["is already taken"]}
-      }, :status => 422)
-      
-      assert_raises(ActiveRecord::RecordInvalid) do
-        tenant.save!
-      end
-      
-      assert_equal ["is already taken"], tenant.errors[:name]
-    end
+  test "should raise an exception if a remote resource does not respond to all instance methods" do
+    class Example2 < ActiveRecord::Base; set_table_name "tenants"; end
+    class RemoteModel2; def self.new_resource; Object.new; end; end
+    assert_raise(Remotable::InvalidRemoteModel) { Example2.remote_model RemoteModel2 }
   end
   
-  
-  
-  test "should destroy a record remotely when destroying one locally" do
-    tenant = Factory(:tenant)
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => tenant.name
-      })
-      s.destroy(tenant.remote_id)
-      
-      tenant.nosync = false
-      tenant.destroy
-      
-      pending # how do I check for this?
+  test "should not raise an exception if remote models are not being validated" do
+    Remotable.without_validation do
+      class Example4 < ActiveRecord::Base; set_table_name "tenants"; end
+      class RemoteModel4; def self.find_by(*args); end; end
+      assert_nothing_raised { Example4.remote_model RemoteModel4 }
     end
   end
   
-  test "should fail to destroy a record locally when failing to destroy one remotely" do
-    tenant = Factory(:tenant)
-    
-    RemoteTenant.run_simulation do |s|
-      s.show(tenant.remote_id, {
-        :id => tenant.remote_id,
-        :slug => tenant.slug,
-        :church_name => tenant.name
-      })
-      
-      s.destroy(tenant.remote_id, :status => 500)
-      
-      tenant.nosync = false
-      assert_raises(ActiveResource::ServerError) do
-        tenant.destroy
-      end
-    end
+  test "should not raise an exception if a remote model responds to all required methods" do
+    class Example3 < ActiveRecord::Base; set_table_name "tenants"; end
+    assert_nothing_raised { Example3.remote_model BespokeModel.new }
   end
   
   
-  
 end