amfetamine 0.1.5

data/spec/amfetamine/caching_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Amfetamine::Cache do
+  it "should return same data after all request has been made" do
+    dummy = build(:dummy)
+    dummy2 = build(:dummy)
+    dummies = nil
+    stub_all_response(dummy, dummy2) do
+      dummies = Dummy.all
+    end
+    dummies_no_request = Dummy.all
+    dummies.should == dummies
+  end
+
+  it "should return same data after find request has been made" do
+    dummy = build(:dummy)
+    return_dummy = nil
+    stub_single_response(dummy) do
+      return_dummy = Dummy.find(dummy.id) 
+    end
+    dummy_no_request = Dummy.find(dummy.id)
+    dummy_no_request.should == return_dummy
+  end
+
+  it "should update the cache after a save has been made" do
+    dummy = build(:dummy)
+    dummy.instance_variable_set('@notsaved', false)
+    dummy.title = 'blabla'
+    stub_update_response(dummy) do
+      dummy.save
+    end
+    dummy2 = Dummy.find(dummy.id)
+    dummy2.should == dummy
+  end
+
+end
+

data/spec/amfetamine/callbacks_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+
+describe "Callbacks" do
+  before do
+    Dummy.stub_responses! do |r|
+      r.post { build(:dummy) }
+    end
+  end
+
+  context "create" do
+    it "should work with before" do
+      Dummy.any_instance.should_receive(:"action_before_create")
+      Dummy.create
+    end
+
+    it "should work with after" do
+      pending "Not working, but not needed either"
+      Dummy.any_instance.should_receive(:"action_after_create")
+      Dummy.create
+    end
+  end
+
+  context "save" do
+    it "should work" do
+      dummy = build(:dummy)
+      dummy.should_receive(:"action_before_save")
+      dummy.should_receive(:"action_after_save")
+      dummy.save
+    end
+  end
+end
+
+
+
+

data/spec/amfetamine/conditions_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe "Amfetamine REST Helpers with conditions" do
+  it "should work regular #all" do
+    Dummy.cache.flush # Just to be uber sure
+
+    query = {:title => 'Dummy'}
+    dummy = build(:dummy)
+    dummy.instance_variable_set('@notsaved',false)
+
+    result = nil
+    stub_conditional_all_response(query, dummy) do
+      result = Dummy.all(:conditions => query)
+    end
+    result2 = Dummy.all(:conditions => query) # No errors raised means it got it from the cache
+    result.should == result2
+    result.should include(dummy)
+    Dummy.prevent_external_connections! do |resource|
+      resource.delete {}
+      dummy.destroy
+    end
+
+    lambda {Dummy.all(:conditions => query) }.should raise_exception(FakeWeb::NetConnectNotAllowedError)
+  end
+
+  it "should work with nested resource #all" do
+    Dummy.cache.flush # Just to be uber sure
+    Child.cache.flush
+
+    query = {:title => 'Child'}
+    dummy = build(:dummy)
+    child = build(:child)
+    dummy.children << child
+
+    dummy.instance_variable_set('@notsaved',false)
+    child.instance_variable_set('@notsaved',false)
+
+    result = nil
+    stub_conditional_nested_all_response(dummy, query, child) do
+      result = dummy.children.all(:conditions => query)
+    end
+    result2 = dummy.children.all(:conditions => query) # No errors raised means it got it from the cache
+    result.should == result2
+    result.should include(child)
+    
+
+    stub_delete_response(child) do
+      child.destroy
+    end
+    
+    child.should_not be_cached
+
+    lambda {dummy.children.all(:conditions => query, :force => true) }.should raise_exception(FakeWeb::NetConnectNotAllowedError)
+  end
+
+  it "should work with normal resource #find" do
+    dummy = build(:dummy)
+    query = { :title => 'Dummy' }
+
+    Dummy.stub_responses! do |r|
+      r.get(:path => "/dummies/#{dummy.id}", :code => 200) { dummy }
+      r.get(:path => "/dummies/#{dummy.id}", :code => 200, :query =>  query) { dummy }
+      r.delete(:path => "/dummies/#{dummy.id}", :code => 200) {}
+    end
+
+    Dummy.cache.flush
+
+    dummy.instance_variable_set('@notsaved',false)
+
+    result = Dummy.find(dummy.id)
+    result.should == dummy
+
+    result2 = Dummy.find(dummy.id, :conditions => query)
+    result2.should == result
+
+    dummy.destroy
+
+    dummy.should_not be_cached
+  end
+
+
+  it "should work with nested resource #find" do
+    Dummy.cache.flush
+    Child.cache.flush
+
+    query = { :title => 'Dummy' }
+    dummy = build(:dummy)
+    child = build(:child)
+    dummy.children << child
+
+    dummy.instance_variable_set('@notsaved',false)
+    child.instance_variable_set('@notsaved',false)
+
+    result = nil
+    stub_conditional_nested_single_response(dummy,child, query) do
+      result = dummy.children.find(dummy.id, :conditions =>  query)
+    end
+
+    result.should == child
+
+    result2 = dummy.children.find(dummy.id, :conditions => query)
+    result2.should == result
+
+    stub_delete_response(child) do
+      child.destroy
+    end
+
+    child.should_not be_cached
+  end
+end

data/spec/amfetamine/dummy_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Dummy do
+  context "ActiveModel Lint test" do
+    subject { Dummy.new }
+    it_should_behave_like "ActiveModel"
+  end
+
+  context "Client side validation" do
+    let(:dummy) { Dummy.new }
+
+    it "should not be valid" do
+      dummy.should_not be_valid
+    end
+  end
+
+  context "Configuration" do
+    it "should be configurable" do
+      Dummy.amfetamine_configure :memcached_instance => ['localhost:11211', {:key => 1}], :rest_client => DummyRestClient, :resource_suffix => '.json'
+      cs = Dummy.instance_variable_get('@cache_server')
+      cs.should be_a(Amfetamine::Cache)
+      cs.instance_variable_get('@cache_server').instance_variable_get('@options').should include(:key => 1) # Annoying bug :/
+      Dummy.rest_client.should == DummyRestClient
+      Dummy.resource_suffix.should == '.json'
+    end
+  end
+end

data/spec/amfetamine/relationships_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Amfetamine::Relationships do
+  let(:dummy) {build :dummy}
+  let(:child) {build :child}
+  
+  context "Routing" do
+    it "should generate correct paths" do
+      dummy.children << child
+
+      Child.rest_path.should == "/children"
+      child.rest_path.should == "/children"
+      child.singular_path.should == "/children/#{child.id}"
+      dummy.children.rest_path.should == "/dummies/#{dummy.id}/children"
+
+      Child.resource_suffix = '.json'
+      child.rest_path.should == "/children.json"
+      dummy.children.rest_path.should == "/dummies/#{dummy.id}/children.json"
+      child.singular_path.should == "/children/#{child.id}.json"
+
+      Child.resource_suffix = ''
+      child.dummy.singular_path.should == "/dummies/#{dummy.id}/children/#{child.id}"
+      dummy.children.find_path(child.id).should == "/dummies/#{dummy.id}/children/#{child.id}"
+    end
+
+    it "should raise error if nested path lacks parent id" do
+      child = Child.new({:title => 'test', :dummy_id => nil})
+
+      lambda { child.belongs_to_relationships.first.rest_path }.should raise_exception(Amfetamine::InvalidPath)
+    end
+  end
+
+  context "Adding and modifying children" do
+    before(:each) do
+      dummy.children << child
+      child.instance_variable_set(:@notsaved, false)
+    end
+
+    it "should create a relationship if parent id is passed in params" do
+      child2 = Child.new(:title => 'Child2', :dummy_id => dummy.id)
+      child2.dummy.should be_a(Amfetamine::Relationship)
+    end
+
+    it "should be possible list all children" do
+      dummy.children.should include(child)
+      Dummy.cache.flush
+      dummy.children.should include(child)
+    end
+
+    it "should be possible to get all children if not in memory" do
+      Dummy.cache.flush
+      new_dummy = nil
+      stub_single_response(dummy) do
+        new_dummy = Dummy.find(dummy.id)
+      end
+        
+      children = nil
+      stub_nested_all_response(dummy,child) do
+        children = new_dummy.children.all
+      end
+      children.should include(child)
+    end
+
+    it "should be possible to get a single child if not in memory" do
+      child.attributes[:dummy_id] = dummy.id # Lets fake we saved it.
+      Dummy.cache.flush
+      new_dummy = nil
+      stub_single_response(dummy) do
+        new_dummy = Dummy.find(dummy.id)
+      end
+
+      new_child = nil
+      stub_nested_single_response(dummy,child) do
+        new_child = new_dummy.children.find(child.id)
+      end
+
+      new_child.should == child
+    end
+
+
+    it "should build new child if asked" do
+      new_child = dummy.build_child
+      new_child.should be_new
+      new_child.should be_a(Child)
+      dummy.children
+    end
+
+    it "should create a new child if asked" do
+      new_child = nil
+      stub_post_response(child) do
+        new_child = dummy.create_child
+      end
+
+      new_child.should_not be_new
+      new_child.should be_cached
+      dummy.children.should include(new_child)
+      Dummy.cache.flush
+      dummy.children.should include(new_child)
+    end
+  end
+end
+
+

data/spec/amfetamine/rest_helpers_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Amfetamine::RestHelpers do
+  context "methods" do
+
+    it "plural_path" do
+      Dummy.rest_path.should ==('/dummies')
+    end
+
+    it "singular_path" do
+      dummy = build(:dummy)
+      dummy.singular_path.should ==("/dummies/#{dummy.id}")
+    end
+
+    it "find_path" do
+      dummy = build(:dummy)
+      Dummy.find_path(dummy.id).should ==("/dummies/#{dummy.id}")
+    end
+
+    it "should work with a resource suffix" do
+      Dummy.resource_suffix = '.json'
+      Dummy.rest_path.should ==('/dummies.json')
+    end
+  end
+end

data/spec/amfetamine/rspec_matchers_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Dummy do
+  context "#make_request_to" do
+    pending "Fix this."
+  end
+end

data/spec/amfetamine/testing_helpers_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe "test_helpers" do
+  let(:test_dummy) { build(:dummy) }
+  describe "#prevent_external_connections!" do
+    it "should raise exception if connections are tried to be made" do
+      Dummy.prevent_external_connections!
+      lambda { Dummy.all }.should raise_exception(Amfetamine::ExternalConnectionsNotAllowed)
+    end
+
+    it "should return correct objects if responses are stubbed for #singular" do
+      dummy = build(:dummy)
+
+      Dummy.stub_responses! do |res|
+        res.get { dummy  }
+      end
+
+      Dummy.find(dummy.id).should == dummy
+    end
+
+    it "should return correct objects if responses are stubbed for #all" do
+      dummy = build(:dummy)
+
+      Dummy.stub_responses! do |res|
+        res.get { [dummy] }
+      end
+
+      Dummy.all.should == [dummy]
+    end
+
+    it "should return give me correct response codes" do
+      Dummy.stub_responses! do |res|
+        res.post(:code => 201) { }
+      end
+
+      dummy = Dummy.new(:title => 'valid', :description => 'valid')
+      dummy.valid?.should be_true
+      dummy.save.should be_true
+    end
+
+    it "should also work with multiple paths" do
+      dummy = build(:dummy)
+
+      Dummy.stub_responses! do |res|
+        res.get(:code => 200, :path => '/dummies/1') { dummy }
+        res.get(:code => 200, :path => '/dummies/') { [ dummy ] }
+      end
+
+      Dummy.find(1).should == dummy
+      Dummy.all.should == [dummy]
+    end
+
+
+    it "should work with a let statement" do
+      lambda {
+        Dummy.stub_responses! do |res|
+          res.get { test_dummy }
+          res.get(:path => '/dummies') { [test_dummy] }
+        end
+      }.should_not raise_exception
+    end
+
+    it "should work with opts parsed and descriminate #all" do
+      dummy1 = build(:dummy)
+      dummy2 = build(:dummy)
+
+      dummy1.title = "DUMMY1"
+      dummy2.title = "DUMMY2"
+
+      Dummy.stub_responses! do |r|
+        r.get(:path => '/dummies', :query => {:title => "DUMMY1"}) { [dummy1] }
+        r.get(:path => '/dummies', :query => {:title => "DUMMY2"}) { [dummy2] }
+      end
+
+      Dummy.all(:conditions => {:title => "DUMMY1"}).should include(dummy1)
+      Dummy.all(:conditions => {:title => "DUMMY1"}).should_not include(dummy2)
+
+      Dummy.all(:conditions => {:title => "DUMMY2"}).should include(dummy2)
+      Dummy.all(:conditions => {:title => "DUMMY2"}).should_not include(dummy1)
+    end
+
+    it "should work with opts parsed and descriminate #all" do
+      dummy1 = build(:dummy)
+      dummy2 = build(:dummy)
+
+      dummy1.title = "DUMMY1"
+      dummy2.title = "DUMMY2"
+
+      Dummy.stub_responses! do |r|
+        r.get(:path => "/dummies/#{dummy1.id}", :query => {:title => "DUMMY1"}) { dummy1 }
+        r.get(:path => "/dummies/#{dummy2.id}", :query => {:title => "DUMMY2"}) { dummy2 }
+      end
+
+      Dummy.find(dummy1.id, :conditions => {:title => "DUMMY1"}).should ==(dummy1)
+      Dummy.find(dummy1.id, :conditions => {:title => "DUMMY1"}).should_not ==(dummy2)
+
+      Dummy.find(dummy2.id, :conditions => {:title => "DUMMY2"}).should ==(dummy2)
+      Dummy.find(dummy2.id, :conditions => {:title => "DUMMY2"}).should_not ==(dummy1)
+    end
+  end
+end