morpheus 0.3.6 → 0.3.7

data/spec/morpheus/mixins/attributes_spec.rb

@@ -1,99 +1,93 @@
 require 'spec_helper'
 
-describe Morpheus::Attributes, "#property" do
-  
-  it "defines setter and getter methods for the given property" do
-    @book = Book.new
-    @book.should respond_to(:title)
-    @book.title = "Test Title"
-    @book.title.should eql("Test Title")
-  end
-  
-  it "creates an attribute entry for this property" do
-    Book.new.attributes.should include(:title)
+describe Morpheus::Attributes do
+
+  describe '.property' do
+    it 'defines setter and getter methods for the given property' do
+      @book = Book.new
+      @book.should respond_to(:title)
+      @book.title = 'Test Title'
+      @book.title.should eql('Test Title')
+    end
+
+    it 'creates an attribute entry for this property' do
+      Book.new.attributes.should include(:title)
+    end
   end
-  
-end
 
-describe Morpheus::Attributes, "#default_attributes" do
-  
-  it "returns the default attributes has which will be applied as the attributes when a new object is instantiated" do
-    Book.default_attributes.should eql(HashWithIndifferentAccess.new({ :id => nil, :title => nil, :author_id => nil }))
+  describe '.default_attributes' do
+    it 'returns the default attributes has which will be applied as the attributes when a new object is instantiated' do
+      Book.default_attributes.should eql(HashWithIndifferentAccess.new({ :id => nil, :title => nil, :author_id => nil }))
+    end
   end
-  
-end
 
-describe Morpheus::Attributes, "#typecast_attributes" do
-  pending
-end
+  describe '.typecast_attributes' do
+    pending
+  end
 
-describe Morpheus::Attributes, "#attribute_defined?" do
-  pending
-end
+  describe '.attribute_defined?' do
+    pending
+  end
 
-describe Morpheus::Attributes, ".attributes" do
-  
-  it "returns the attributes hash" do
-    Book.new.attributes.should eql(HashWithIndifferentAccess.new({ :id => nil, :title => nil, :author_id => nil }))
+  describe '#attributes' do
+    it 'returns the attributes hash' do
+      Book.new.attributes.should eql(HashWithIndifferentAccess.new({ :id => nil, :title => nil, :author_id => nil }))
+    end
   end
-  
-end
 
-describe Morpheus::Attributes, ".read_attribute_for_validation" do
-  pending
-end
+  describe '#read_attribute_for_validation' do
+    pending
+  end
 
-describe Morpheus::Attributes, ".typecast" do
-  pending
-end
+  describe '#typecast' do
+    pending
+  end
 
-describe Morpheus::Attributes, ".attributes_without_id" do
-  pending
-end
+  describe '#attributes_without_basic_attributes' do
+    pending
+  end
 
-describe Morpheus::Attributes, ".update_attribute" do
-  
-  it "updates the attribute with the given value" do
-    @book = Book.new(:title => "Horton Hears a Who")
-    @book.title.should eql("Horton Hears a Who")
-    @book.update_attribute(:title, "Red Fish, Blue Fish, One Fish, Two Fish")
-    @book.title.should eql("Red Fish, Blue Fish, One Fish, Two Fish")
+  describe "#update_attribute" do
+    it 'updates the attribute with the given value' do
+      @book = Book.new(:title => 'Horton Hears a Who')
+      @book.title.should eql('Horton Hears a Who')
+      @book.update_attribute(:title, 'One Fish, Two Fish, Red Fish, Blue Fish')
+      @book.title.should eql('One Fish, Two Fish, Red Fish, Blue Fish')
+    end
   end
-  
-end
 
-describe Morpheus::Attributes, ".merge_attributes" do
-  
-  it "updates each attribute with the given value" do
-    @book = Book.new(:title => "Green Eggs and Ham")
-    @book.id.should be_nil
-    @book.title.should eql("Green Eggs and Ham")
-    @book.send(:merge_attributes, { :title => "Red Fish, Blue Fish, One Fish, Two Fish", :id => 5 })
-    @book.id.should eql(5)
-    @book.title.should eql("Red Fish, Blue Fish, One Fish, Two Fish")
+  describe '#update_reflection' do
+    pending
   end
-  
-end
 
-describe Morpheus::Attributes, "dirty tracking" do
-  
-  it "includes the ActiveModel::Validations module" do
-    Morpheus::Base.included_modules.should include(ActiveModel::Dirty)
+  describe '#merge_attributes' do
+    it 'updates each attribute with the given value' do
+      @book = Book.new(:title => 'Green Eggs and Ham')
+      @book.id.should be_nil
+      @book.title.should eql('Green Eggs and Ham')
+      @book.send(:merge_attributes, { :title => 'One Fish, Two Fish, Red Fish, Blue Fish', :id => 5 })
+      @book.id.should eql(5)
+      @book.title.should eql('One Fish, Two Fish, Red Fish, Blue Fish')
+    end
   end
-  
-  it "tracks dirty state for property values" do
-    @book = Book.new
-    @book.should_not be_title_changed
-    @book.title = "Dirty title"
-    @book.should be_title_changed
+
+  describe 'dirty tracking' do
+    it 'includes the ActiveModel::Dirty module' do
+      Morpheus::Base.included_modules.should include(ActiveModel::Dirty)
+    end
+
+    it 'tracks dirty state for property values' do
+      @book = Book.new
+      @book.should_not be_title_changed
+      @book.title = 'Dirty title'
+      @book.should be_title_changed
+    end
   end
-  
-end
 
-describe Morpheus::Attributes, "validations" do
-  
-  it "includes the ActiveModel::Validations module" do
-    Morpheus::Base.included_modules.should include(ActiveModel::Validations)
+  describe 'validations' do
+    it 'includes the ActiveModel::Validations module' do
+      Morpheus::Base.included_modules.should include(ActiveModel::Validations)
+    end
   end
-  
+
 end

data/spec/morpheus/mixins/conversion_spec.rb

@@ -1,76 +1,66 @@
 require 'spec_helper'
 
-describe Morpheus::Conversion, ".to_model" do
-  
-  before(:each) do
-    @dog = Dog.new
-  end
-
-  it "returns this object" do
-    @dog.to_model.should eql(@dog)
-  end
-
-end
+describe Morpheus::Conversion do
 
-describe Morpheus::Conversion, ".to_param" do
-  
-  context "when the id attribute is set" do
-    
+  describe '#to_model' do
     before(:each) do
-      Morpheus::Base.stub(:get).and_return(Morpheus::Base.new(:id => 1))
-      @base = Morpheus::Base.find(1)
+      @dog = Dog.new
     end
-    
-    it "returns the id as a string" do
-      @base.to_param.should eql("1")
-    end
-    
-  end
-  
-  context "when the id attribute is set" do
-    
-    before(:each) do
-      @base = Morpheus::Base.new
-    end
-    
-    it "returns the id as a string" do
-      @base.to_param.should be_nil
+
+    it 'returns this object' do
+      @dog.to_model.should eql(@dog)
     end
-    
   end
-  
-end
 
-describe Morpheus::Conversion, ".to_key" do
-  
-  context "when the object is a new record" do
-  
-    before(:each) do
-      @dog = Dog.new(:name => "Daisy", :breed => "English Bulldog", :age => 2)
+  describe '#to_param' do
+    context 'when the id attribute is set' do
+      before(:each) do
+        Morpheus::Base.stub(:get).and_return(Morpheus::Base.new(:id => 1))
+        @base = Morpheus::Base.find(1)
+      end
+
+      it 'returns the id as a string' do
+        @base.to_param.should eql('1')
+      end
     end
-  
-    it "returns nil" do
-      @dog.to_key.should be_nil
+
+    context 'when the id attribute is set' do
+      before(:each) do
+        @base = Morpheus::Base.new
+      end
+
+      it 'returns the id as a string' do
+        @base.to_param.should be_nil
+      end
     end
-    
   end
-  
-  context "when the object is persisted" do
 
-    before(:each) do
-      Dog.stub(:get).and_return(Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog", :age => 2))
-      @dog = Dog.find(1)
+  describe '#to_key' do
+    context 'when the object is a new record' do
+      before(:each) do
+        @dog = Dog.new(:name => 'Daisy', :breed => 'English Bulldog', :age => 2)
+      end
+
+      it 'returns nil' do
+        @dog.to_key.should be_nil
+      end
     end
 
-    it "returns the attribute keys of the object" do
-      @keys = @dog.to_key
-      @keys.should have(4).keys
-      @keys.should include('id')
-      @keys.should include('name')
-      @keys.should include('breed')
-      @keys.should include('age')
+    context 'when the object is persisted' do
+      before(:each) do
+        Dog.stub(:get).and_return(Dog.new(:id => 1, :name => 'Daisy', :breed => 'English Bulldog', :age => 2))
+        @dog = Dog.find(1)
+      end
+
+      it 'returns the attribute keys of the object' do
+        @keys = @dog.to_key
+        @keys.should have(4).keys
+        @keys.should include('id')
+        @keys.should include('name')
+        @keys.should include('breed')
+        @keys.should include('age')
+      end
     end
-    
   end
-  
+
 end

data/spec/morpheus/mixins/filtering_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Morpheus::Filtering do
+
+  describe '.filter' do
+    pending
+  end
+
+  describe '.find_filter' do
+    pending
+  end
+
+end

data/spec/morpheus/mixins/finders_spec.rb

@@ -1,255 +1,218 @@
 require 'spec_helper'
 
-describe Morpheus::Finders, "#find" do
-  
-  context "when the argument is a single integer" do
-    
-    context "when this record exists on the external service" do
-      
-      before(:each) do
-        @dog = Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog")
-        Dog.stub(:get).and_return(@dog)
-      end
-      
-      it "makes a request to /dogs/1 at the external service" do
-        Dog.should_receive(:get).with("/dogs/1", nil, { :id => 1 }).and_return(@dog)
-        Dog.find(1)
-      end
-      
-      it "returns the instance representing this found record" do
-        @dog = Dog.find(1)
-        @dog.should be_a(Dog)
-        @dog.id.should eql(1)
-        @dog.name.should eql("Daisy")
-        @dog.breed.should eql("English Bulldog")
-      end
-      
-    end
-    
-    context "when this record does not exist on the external service" do
-      
-      before(:each) do
-        Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs/1").and_return(build_morpheus_response(404, nil))
+describe Morpheus::Finders do
+
+  describe '#find' do
+    context 'when the argument is a single integer' do
+      context 'when this record exists on the external service' do
+        before(:each) do
+          @dog = Dog.new(:id => 1, :name => 'Daisy', :breed => 'English Bulldog')
+          Dog.stub(:get).and_return(@dog)
+        end
+
+        it 'makes a request to /dogs/1 at the external service' do
+          Dog.should_receive(:get).with('/dogs/1', nil, { :id => 1 }).and_return(@dog)
+          Dog.find(1)
+        end
+
+        it 'returns the instance representing this found record' do
+          @dog = Dog.find(1)
+          @dog.should be_a(Dog)
+          @dog.id.should eql(1)
+          @dog.name.should eql('Daisy')
+          @dog.breed.should eql('English Bulldog')
+        end
       end
-      
-      it "raises a ResourceNotFound error" do
-        lambda { Dog.find(1) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find Dog with ID=1")
+
+      context 'when this record does not exist on the external service' do
+        before(:each) do
+          Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs/1").and_return(build_morpheus_response(404, nil))
+        end
+
+        it 'raises a ResourceNotFound error' do
+          lambda { Dog.find(1) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find Dog with ID=1")
+        end
       end
-      
     end
-    
-  end
-  
-  context "when the argument is a single array" do
-    
-    context "when all records exists on the external service" do
-      
-      before(:each) do
-        @dogs = [
-          Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog"),
-          Dog.new(:id => 2, :name => "Wilbur", :breed => "Hounddog"),
-          Dog.new(:id => 3, :name => "Fido", :breed => "Dalmatian")
-        ]
-        Dog.stub(:get).and_return(@dogs)
-      end
-      
-      it "makes a request to /dogs?ids=1,2,3 at the external service" do
-        Dog.should_receive(:get).with("/dogs", { :ids => [1,2,3] }, { :ids => [1,2,3] }).and_return(@dogs)
-        Dog.find([1,2,3])
+
+    context 'when the argument is a single array' do
+      context 'when all records exists on the external service' do
+        before(:each) do
+          @dogs = [
+            Dog.new(:id => 1, :name => 'Daisy',  :breed => 'English Bulldog'),
+            Dog.new(:id => 2, :name => 'Wilbur', :breed => 'Hounddog'),
+            Dog.new(:id => 3, :name => 'Fido',   :breed => 'Dalmatian')
+          ]
+          Dog.stub(:get).and_return(@dogs)
+        end
+
+        it 'makes a request to /dogs?ids=1,2,3 at the external service' do
+          Dog.should_receive(:get).with('/dogs', { :ids => [1,2,3] }, { :ids => [1,2,3] }).and_return(@dogs)
+          Dog.find([1,2,3])
+        end
+
+        it 'returns an array of instances representing these found records' do
+          @dogs = Dog.find([1,2,3])
+          @dogs.should be_an(Array)
+          @dogs.should have(3).dogs
+          @dogs.each do |dog|
+            dog.should be_a(Dog)
+          end
+        end
       end
-      
-      it "returns an array of instances representing these found records" do
-        @dogs = Dog.find([1,2,3])
-        @dogs.should be_an(Array)
-        @dogs.should have(3).dogs
-        @dogs.each do |dog|
-          dog.should be_a(Dog)
+
+      context 'when there is a requested record that does not exist on the external service' do
+        before(:each) do
+          Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3").and_return(build_morpheus_response(404, nil))
+        end
+
+        it 'raises a ResourceNotFound error' do
+          lambda { Dog.find([1,2,3]) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find all Dogs with IDs (1, 2, 3)")
         end
       end
-      
     end
-    
-    context "when there is a requested record that does not exist on the external service" do
-      
-      before(:each) do
-        Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs?ids=1&ids=2&ids=3").and_return(build_morpheus_response(404, nil))
+
+    context 'when there are multiple arguments, each being an integer' do
+      context 'when all records exists on the external service' do
+        before(:each) do
+          @dogs = [
+            Dog.new(:id => 1, :name => 'Daisy',  :breed => 'English Bulldog'),
+            Dog.new(:id => 2, :name => 'Wilbur', :breed => 'Hounddog'),
+            Dog.new(:id => 3, :name => 'Fido',   :breed => 'Dalmatian')
+          ]
+          Dog.stub(:get).and_return(@dogs)
+        end
+
+        it 'makes a request to /dogs?ids=1,2,3 at the external service' do
+          Dog.should_receive(:get).with('/dogs', { :ids => [1,2,3] }, { :ids => [1,2,3] }).and_return(@dogs)
+          Dog.find(1,2,3)
+        end
+
+        it 'returns an array of instances representing these found records' do
+          @dogs = Dog.find(1,2,3)
+          @dogs.should be_an(Array)
+          @dogs.should have(3).dogs
+          @dogs.each do |dog|
+            dog.should be_a(Dog)
+          end
+        end
       end
-      
-      it "raises a ResourceNotFound error" do
-        lambda { Dog.find([1,2,3]) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find all Dogs with IDs (1, 2, 3)")
+
+      context 'when there is a requested record that does not exist on the external service' do
+        before(:each) do
+          Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3").and_return(build_morpheus_response(404, nil))
+        end
+
+        it 'raises a ResourceNotFound error' do
+          lambda { Dog.find(1,2,3) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find all Dogs with IDs (1, 2, 3)")
+        end
       end
-      
     end
-    
   end
-  
-  context "when there are multiple arguments, each being an integer" do
-    
-    context "when all records exists on the external service" do
-      
-      before(:each) do
-        @dogs = [
-          Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog"),
-          Dog.new(:id => 2, :name => "Wilbur", :breed => "Hounddog"),
-          Dog.new(:id => 3, :name => "Fido", :breed => "Dalmatian")
-        ]
-        Dog.stub(:get).and_return(@dogs)
-      end
-      
-      it "makes a request to /dogs?ids=1,2,3 at the external service" do
-        Dog.should_receive(:get).with("/dogs", { :ids => [1,2,3] }, { :ids => [1,2,3] }).and_return(@dogs)
-        Dog.find(1,2,3)
-      end
-      
-      it "returns an array of instances representing these found records" do
-        @dogs = Dog.find(1,2,3)
-        @dogs.should be_an(Array)
-        @dogs.should have(3).dogs
-        @dogs.each do |dog|
-          dog.should be_a(Dog)
-        end
-      end
-      
+
+  describe '#all' do
+    before(:each) do
+      @dogs =  [
+        Dog.new(:id => 1, :name => 'Daisy',  :breed => 'English Bulldog'),
+        Dog.new(:id => 2, :name => 'Wilbur', :breed => 'Hounddog'),
+        Dog.new(:id => 3, :name => 'Fido',   :breed => 'Dalmatian')
+      ]
+      Dog.stub(:get).and_return(@dogs)
     end
-    
-    context "when there is a requested record that does not exist on the external service" do
-      
-      before(:each) do
-        Morpheus::Configuration.hydra.stub(:get, "#{Morpheus::Configuration.host}/dogs?ids=1&ids=2&ids=3").and_return(build_morpheus_response(404, nil))
-      end
-      
-      it "raises a ResourceNotFound error" do
-        lambda { Dog.find(1,2,3) }.should raise_error(Morpheus::ResourceNotFound, "Couldn't find all Dogs with IDs (1, 2, 3)")
+
+    it 'returns all found records' do
+      @dogs = Dog.all
+      @dogs.should be_an(Array)
+      @dogs.should have(3).dogs
+      @dogs.each do |dog|
+        dog.should be_a(Dog)
       end
-      
     end
-    
   end
-  
-end
 
-describe Morpheus::Finders, "#all" do
+  describe '#first' do
+    before(:each) do
+      @dogs = [Dog.new(:id => 1, :name => 'Daisy', :breed => 'English Bulldog')]
+      Dog.stub(:get).and_return(@dogs)
+    end
 
-  before(:each) do
-    @dogs =  [
-      Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog"),
-      Dog.new(:id => 2, :name => "Wilbur", :breed => "Hounddog"),
-      Dog.new(:id => 3, :name => "Fido", :breed => "Dalmatian")
-    ]
-    Dog.stub(:get).and_return(@dogs)
-  end
-  
-  it "returns all found records" do
-    @dogs = Dog.all
-    @dogs.should be_an(Array)
-    @dogs.should have(3).dogs
-    @dogs.each do |dog|
-      dog.should be_a(Dog)
+    it 'returns first found record' do
+      @dog = Dog.first
+      @dog.should be_a(Dog)
     end
   end
 
-end
-
-describe Morpheus::Finders, "#first" do
-  
-  before(:each) do
-    @dogs = [Dog.new(:id => 1, :name => "Daisy", :breed => "English Bulldog")]
-    Dog.stub(:get).and_return(@dogs)
-  end
-  
-  it "returns first found record" do
-    @dog = Dog.first
-    @dog.should be_a(Dog)
-  end
-  
-end
+  describe '#where' do
+    context 'when the where attribute is an acceptable attribute' do
+      context 'for a where clause with one attribute' do
+        before(:each) do
+          @dogs =  [Dog.new(:name => 'Daisy', :breed => 'English Bulldog').attributes.merge(:id => 1)]
+        end
 
-describe Morpheus::Finders, "#where" do
-  
-  context "when the where attribute is an acceptable attribute" do
-    
-    context "for a where clause with one attribute" do
-      
-      before(:each) do
-        @dogs =  [Dog.new(:name => "Daisy", :breed => "English Bulldog").attributes.merge(:id => 1)]
-      end
-      
-      it "makes a request to find all records with the given query parameter" do
-        Dog.should_receive(:get).with("/dogs", { :name => "Daisy" }).and_return(@dogs)
-        Dog.where(:name => "Daisy").first
-      end
-      
-    end
-    
-    context "for a where clause with multiple attributes" do
-      
-      before(:each) do
-        @dogs =  [Dog.new(:name => "Daisy", :breed => "English Bulldog").attributes.merge(:id => 1)]
+        it 'makes a request to find all records with the given query parameter' do
+          Dog.should_receive(:get).with('/dogs', { :name => 'Daisy' }).and_return(@dogs)
+          Dog.where(:name => 'Daisy').first
+        end
       end
-      
-      it "makes a request to find all records with the given query parameters" do
-        Dog.should_receive(:get).with("/dogs", { :breed => "English Bulldog", :name => "Daisy" }).and_return(@dogs)
-        Dog.where(:name => "Daisy", :breed => "English Bulldog").first
+
+      context 'for a where clause with multiple attributes' do
+        before(:each) do
+          @dogs =  [Dog.new(:name => 'Daisy', :breed => 'English Bulldog').attributes.merge(:id => 1)]
+        end
+
+        it 'makes a request to find all records with the given query parameters' do
+          Dog.should_receive(:get).with('/dogs', { :breed => 'English Bulldog', :name => 'Daisy' }).and_return(@dogs)
+          Dog.where(:name => 'Daisy', :breed => 'English Bulldog').first
+        end
       end
-      
     end
-    
   end
-  
-end
 
-describe Morpheus::Finders, "#limit" do
-  
-  before(:each) do
-    @dogs = [
-      Dog.new(:name => "Daisy", :breed => "English Bulldog").attributes.merge(:id => 1),
-      Dog.new(:name => "Wilbur", :breed => "Hounddog").attributes.merge(:id => 2),
-      Dog.new(:name => "Fido", :breed => "Dalmatian").attributes.merge(:id => 3)
-    ]
-  end
+  describe '#limit' do
+    before(:each) do
+      @dogs = [
+        Dog.new(:id => 1, :name => 'Daisy',  :breed => 'English Bulldog'),
+        Dog.new(:id => 2, :name => 'Wilbur', :breed => 'Hounddog'),
+        Dog.new(:id => 3, :name => 'Fido',   :breed => 'Dalmatian')
+      ]
+    end
 
-  it "makes a request to find all of the given records, but with a given limit" do
-    Dog.should_receive(:get).with("/dogs", { :limit => 10 }).and_return(@dogs)
-    Dog.limit(10).all
+    it 'makes a request to find all of the given records, but with a given limit' do
+      Dog.should_receive(:get).with('/dogs', { :limit => 10 }).and_return(@dogs)
+      Dog.limit(10).all
+    end
   end
 
-end
-
-describe Morpheus::Finders, "#page" do
-  
-  before(:each) do
-    Dog.results_per_page = 10
-    
-    @dogs = [
-      Dog.new(:name => "Daisy", :breed => "English Bulldog").attributes.merge(:id => 1),
-      Dog.new(:name => "Wilbur", :breed => "Hounddog").attributes.merge(:id => 2),
-      Dog.new(:name => "Fido", :breed => "Dalmatian").attributes.merge(:id => 3)
-    ]
-  end
+  describe '#page' do
+    before(:each) do
+      Dog.results_per_page = 10
+      @dogs = [
+        Dog.new(:id => 1, :name => 'Daisy',  :breed => 'English Bulldog'),
+        Dog.new(:id => 2, :name => 'Wilbur', :breed => 'Hounddog'),
+        Dog.new(:id => 3, :name => 'Fido',   :breed => 'Dalmatian')
+      ]
+    end
 
-  it "makes a request to find all of the given records, but with a given limit and offset" do
-    Dog.should_receive(:get).with("/dogs", { :limit => 10, :offset => 20 }).and_return(@dogs)
-    Dog.page(3).all
+    it 'makes a request to find all of the given records, but with a given limit and offset' do
+      Dog.should_receive(:get).with('/dogs', { :limit => 10, :offset => 20 }).and_return(@dogs)
+      Dog.page(3).all
+    end
   end
-  
-end
 
-describe Morpheus::Finders, "#results_per_page" do
-  
-  it "defaults to 10" do
-    Dog.results_per_page.should eql(10)
-  end
-  
-  context "when set to something other than the default" do
-    
-    before(:each) do
-      Dog.results_per_page = 25
+  describe '#results_per_page' do
+    it 'defaults to 10' do
+      Dog.results_per_page.should eql(10)
     end
-    
-    it "returns the number of results to be returned on a page request" do
-      Dog.results_per_page.should eql(25)
+
+    context 'when set to something other than the default' do
+      before(:each) do
+        Dog.results_per_page = 25
+      end
+
+      it 'returns the number of results to be returned on a page request' do
+        Dog.results_per_page.should eql(25)
+      end
     end
-    
   end
-  
+
 end