rocking_chair 0.3.0 → 0.3.1

data/lib/rocking_chair/view.rb

@@ -18,10 +18,10 @@ module RockingChair
         @design_document = JSON.parse(database.storage["_design/#{design_document_name}"], :create_additions => false)
         @view_document = design_document['views'][view_name] || RockingChair::Error.raise_404
       end
-      
+
       @database = database
       @keys = database.storage.keys
-      @design_document_name = design_document_name
+      @design_document_name = normalize_design_document_name(design_document_name)
       @view_name = view_name
       initialize_ruby_store
       
@@ -311,5 +311,9 @@ module RockingChair
       end
     end
     
+    def normalize_design_document_name(design_doc_name)
+      design_doc_name.to_s.gsub(/_view_\w+/, '')
+    end
+
   end
 end

data/test/fixtures/simply_stored_fixtures.rb

@@ -29,7 +29,7 @@ class Manager
   has_one :project
 end
 
-class CustomViewUser
+class CustomFiewUser
   include SimplyStored::Couch
   
   property :tags

data/test/simply_stored_test.rb

@@ -6,395 +6,398 @@ def recreate_db
 end
 
 class SimplyStoredTest < Test::Unit::TestCase
-  context "Extended use cases for SimplyStored" do
-    setup do
-      RockingChair::Server.reset
-      CouchPotato::Config.database_name = 'fake_simply_stored'
-      recreate_db
-    end
+  [false, true].each do |setting|
+    CouchPotato::Config.split_design_documents_per_view = setting
     
-    context "storing and loading documents" do
-      should "save and find Projects" do
-        p = Project.new(:title => 'The title')
-        assert p.save
-        assert_not_nil p.id, p.inspect
-        project = Project.find(p.id)
-        assert_equal 'The title', project.title
+    context "Extended use cases for SimplyStored with split_design_documents_per_view #{setting ? 'enabled' : 'disabled'}" do
+      setup do
+        RockingChair::Server.reset
+        CouchPotato::Config.database_name = 'fake_simply_stored'
+        recreate_db
       end
+    
+      context "storing and loading documents" do
+        should "save and find Projects" do
+          p = Project.new(:title => 'The title')
+          assert p.save
+          assert_not_nil p.id, p.inspect
+          project = Project.find(p.id)
+          assert_equal 'The title', project.title
+        end
       
-      should "save and find Users" do
-        p = Project.new(:title => 'The title')
-        assert p.save
-        u = User.new(:firstname => 'Doc', :lastname => 'Holiday', :project => p)
-        assert u.save
-        user = User.find(u.id)
-        assert_equal 'Doc', user.firstname
-        assert_equal 'Holiday', user.lastname
-        assert_equal p.id, user.project_id
-        assert_equal p, user.project
+        should "save and find Users" do
+          p = Project.new(:title => 'The title')
+          assert p.save
+          u = User.new(:firstname => 'Doc', :lastname => 'Holiday', :project => p)
+          assert u.save
+          user = User.find(u.id)
+          assert_equal 'Doc', user.firstname
+          assert_equal 'Holiday', user.lastname
+          assert_equal p.id, user.project_id
+          assert_equal p, user.project
+        end
       end
-    end
     
-    context "Views" do
-      setup do
-        @manager = Manager.new(:firstname => 'Michael')
-        assert @manager.save
+      context "Views" do
+        setup do
+          @manager = Manager.new(:firstname => 'Michael')
+          assert @manager.save
         
-        @project = Project.new(:title => 'The title', :manager => @manager)
-        assert @project.save
+          @project = Project.new(:title => 'The title', :manager => @manager)
+          assert @project.save
         
-        @user = User.new(:firstname => 'Michael', :project => @project)
-        assert @user.save
-      end
+          @user = User.new(:firstname => 'Michael', :project => @project)
+          assert @user.save
+        end
       
-      context "by_attribute views" do
+        context "by_attribute views" do
       
-        should "load first" do
-          user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
-          user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
-          assert_equal 'J', User.find_by_firstname('Homer').lastname
-        end
+          should "load first" do
+            user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
+            user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
+            assert_equal 'J', User.find_by_firstname('Homer').lastname
+          end
       
-        should "load all" do
-          user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
-          user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
-          user_2 = User.create(:firstname => 'Homer', :lastname => 'S')
-          assert_equal ['S', 'J'].sort, User.find_all_by_firstname('Homer').map(&:lastname).sort
-        end
+          should "load all" do
+            user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
+            user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
+            user_2 = User.create(:firstname => 'Homer', :lastname => 'S')
+            assert_equal ['S', 'J'].sort, User.find_all_by_firstname('Homer').map(&:lastname).sort
+          end
       
-        should "only load objects from the correct class" do
-          user = User.create(:firstname => 'Bart', :lastname => 'S')
-          manager = Manager.create(:firstname => 'Bart', :lastname => 'J')
-          assert_equal ['S'], User.find_all_by_firstname('Bart').map(&:lastname)
-        end
+          should "only load objects from the correct class" do
+            user = User.create(:firstname => 'Bart', :lastname => 'S')
+            manager = Manager.create(:firstname => 'Bart', :lastname => 'J')
+            assert_equal ['S'], User.find_all_by_firstname('Bart').map(&:lastname)
+          end
         
-        should "support multiple attributes" do
-          user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
-          user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
-          user_2 = User.create(:firstname => 'Homer', :lastname => 'S')
-          assert_equal ['J'].sort, User.find_all_by_firstname_and_lastname('Homer', 'J').map(&:lastname).sort
+          should "support multiple attributes" do
+            user_1 = User.create(:firstname => 'Bart', :lastname => 'S')
+            user_2 = User.create(:firstname => 'Homer', :lastname => 'J')
+            user_2 = User.create(:firstname => 'Homer', :lastname => 'S')
+            assert_equal ['J'].sort, User.find_all_by_firstname_and_lastname('Homer', 'J').map(&:lastname).sort
+          end
         end
-      end
       
-      context "belongs_to" do
-        should "load the parent object" do
-          assert_equal @project.id, @user.project.id
+        context "belongs_to" do
+          should "load the parent object" do
+            assert_equal @project.id, @user.project.id
+          end
         end
-      end
       
-      context "has_one" do
-        should "load the child object" do
-          assert_equal @project.id, @manager.project.id
-          assert_equal @manager.id, @project.manager.id
-        end
+        context "has_one" do
+          should "load the child object" do
+            assert_equal @project.id, @manager.project.id
+            assert_equal @manager.id, @project.manager.id
+          end
         
-        should "re-use existing views" do
-          Manager.create(:firstname => 'Jochen', :lastname => 'Peter')
-          Manager.create(:firstname => 'Another', :lastname => 'Bert')
+          should "re-use existing views" do
+            Manager.create(:firstname => 'Jochen', :lastname => 'Peter')
+            Manager.create(:firstname => 'Another', :lastname => 'Bert')
+          end
         end
-      end
       
-      context "has_many" do
-        setup do
-          RockingChair::Server.reset
-          CouchPotato::Config.database_name = 'fake_simply_stored'
-          recreate_db
-        end
+        context "has_many" do
+          setup do
+            RockingChair::Server.reset
+            CouchPotato::Config.database_name = 'fake_simply_stored'
+            recreate_db
+          end
         
-        should "load all has_many objects" do
-          user = User.new(:firstname => 'Michael', :project => @project)
-          assert user.save
-          assert_equal [user.id], @project.users.map(&:id)
-        end
+          should "load all has_many objects" do
+            user = User.new(:firstname => 'Michael', :project => @project)
+            assert user.save
+            assert_equal [user.id], @project.users.map(&:id)
+          end
         
-        should "support counting associated" do
-          assert_equal 0, @project.user_count
-          user = User.create(:firstname => 'Michael', :project => @project)
-          assert_equal 1, @project.user_count(:force_reload => true)
-        end
+          should "support counting associated" do
+            assert_equal 0, @project.user_count
+            user = User.create(:firstname => 'Michael', :project => @project)
+            assert_equal 1, @project.user_count(:force_reload => true)
+          end
         
-        should "support limiting" do
-          3.times{ User.create!(:firstname => 'Michael', :project => @project) }
-          assert_equal 3, @project.users.size
-          assert_equal 2, @project.users(:limit => 2).size
-        end
+          should "support limiting" do
+            3.times{ User.create!(:firstname => 'Michael', :project => @project) }
+            assert_equal 3, @project.users.size
+            assert_equal 2, @project.users(:limit => 2).size
+          end
                 
-        should "support mixing order and limit" do
-          michael = User.find(User.create!(:firstname => "michael", :project => @project).id)
-          michael.created_at = Time.local(2001)
-          michael.save!
+          should "support mixing order and limit" do
+            michael = User.find(User.create!(:firstname => "michael", :project => @project).id)
+            michael.created_at = Time.local(2001)
+            michael.save!
           
-          mickey = User.find(User.create!(:firstname => "mickey", :project => @project).id)
-          mickey.created_at = Time.local(2002)
-          mickey.save!
+            mickey = User.find(User.create!(:firstname => "mickey", :project => @project).id)
+            mickey.created_at = Time.local(2002)
+            mickey.save!
           
-          mike = User.find(User.create!(:firstname => "mike", :project => @project).id)
-          mike.created_at = Time.local(2003)
-          mike.save!
+            mike = User.find(User.create!(:firstname => "mike", :project => @project).id)
+            mike.created_at = Time.local(2003)
+            mike.save!
           
-          assert_equal ["michael", "mickey", "mike"], @project.users(:order => :asc).map(&:firstname)
-          assert_equal ["michael", "mickey", "mike"].reverse, @project.users(:order => :desc).map(&:firstname)
+            assert_equal ["michael", "mickey", "mike"], @project.users(:order => :asc).map(&:firstname)
+            assert_equal ["michael", "mickey", "mike"].reverse, @project.users(:order => :desc).map(&:firstname)
+          end
         end
-      end
       
-      context "when querying the all_documents view" do
-        setup do
-          RockingChair::Server.reset
-          CouchPotato::Config.database_name = 'fake_simply_stored'
-          recreate_db
-        end
+        context "when querying the all_documents view" do
+          setup do
+            RockingChair::Server.reset
+            CouchPotato::Config.database_name = 'fake_simply_stored'
+            recreate_db
+          end
         
-        should "load all from the same class" do
-          User.create(:firstname => 'Michael Mann', :project => @project)
-          User.create(:firstname => 'Peter', :project => @project)
-          assert_equal ['Peter', 'Michael Mann'].sort, User.all.map(&:firstname).sort
+          should "load all from the same class" do
+            User.create(:firstname => 'Michael Mann', :project => @project)
+            User.create(:firstname => 'Peter', :project => @project)
+            assert_equal ['Peter', 'Michael Mann'].sort, User.all.map(&:firstname).sort
           
-          User.create(:firstname => 'Hulk', :project => @project)
-          assert_equal ['Peter', 'Michael Mann', 'Hulk'].sort, User.all.map(&:firstname).sort
-        end
+            User.create(:firstname => 'Hulk', :project => @project)
+            assert_equal ['Peter', 'Michael Mann', 'Hulk'].sort, User.all.map(&:firstname).sort
+          end
         
-        should "support order" do
-          3.times{|i| User.create!(:firstname => "user #{i}") }
-          assert_not_equal User.all(:order => :asc).map(&:id), User.all(:order => :desc).map(&:id)
-          assert_equal User.all(:order => :asc).reverse, User.all(:order => :desc)
-        end
+          should "support order" do
+            3.times{|i| User.create!(:firstname => "user #{i}") }
+            assert_not_equal User.all(:order => :asc).map(&:id), User.all(:order => :desc).map(&:id)
+            assert_equal User.all(:order => :asc).reverse, User.all(:order => :desc)
+          end
         
-        should "load first" do
-          User.create(:firstname => 'Michael Mann', :project => @project)
-          User.create(:firstname => 'Peter', :project => @project)
-          assert User.first.respond_to?(:firstname)
-        end
+          should "load first" do
+            User.create(:firstname => 'Michael Mann', :project => @project)
+            User.create(:firstname => 'Peter', :project => @project)
+            assert User.first.respond_to?(:firstname)
+          end
         
-        should "count" do
-          User.create(:firstname => 'Michael the first')
+          should "count" do
+            User.create(:firstname => 'Michael the first')
         
-          assert_equal 0, Project.count
-          assert_equal 0, Manager.count
-          assert_equal 1, User.count
+            assert_equal 0, Project.count
+            assert_equal 0, Manager.count
+            assert_equal 1, User.count
 
-          Manager.create(:firstname => 'Jochen', :lastname => 'Peter')
-          Project.create(:title => 'The title', :manager => @manager)
-          Project.create(:title => 'another title', :manager => @manager)
-          User.create(:firstname => 'Michael Mann', :project => @project)
-          User.create(:firstname => 'Peter', :project => @project)
+            Manager.create(:firstname => 'Jochen', :lastname => 'Peter')
+            Project.create(:title => 'The title', :manager => @manager)
+            Project.create(:title => 'another title', :manager => @manager)
+            User.create(:firstname => 'Michael Mann', :project => @project)
+            User.create(:firstname => 'Peter', :project => @project)
 
-          assert_equal 2, Project.count
-          assert_equal 1, Manager.count
-          assert_equal 3, User.count
-        end
+            assert_equal 2, Project.count
+            assert_equal 1, Manager.count
+            assert_equal 3, User.count
+          end
         
-        should "count_by" do
-          User.create(:firstname => 'michael')
+          should "count_by" do
+            User.create(:firstname => 'michael')
         
-          assert_equal 1, User.count
-          assert_equal 1, User.count_by_firstname('michael')
-        end
+            assert_equal 1, User.count
+            assert_equal 1, User.count_by_firstname('michael')
+          end
         
-        should "count_by with nil attributes" do
-          Project.create(:title => nil)
+          should "count_by with nil attributes" do
+            Project.create(:title => nil)
         
-          assert_equal 1, Project.count
-          assert_equal 1, Project.count_by_title(nil)
+            assert_equal 1, Project.count
+            assert_equal 1, Project.count_by_title(nil)
           
-          Project.create(:title => nil, :manager_id => 12)
+            Project.create(:title => nil, :manager_id => 12)
           
-          assert_equal 2, Project.count
-          assert_equal 2, Project.count_by_title(nil)
-          assert_equal 1, Project.count_by_manager_id(12)
-          assert_equal 1, Project.count_by_manager_id_and_title(12, nil)
+            assert_equal 2, Project.count
+            assert_equal 2, Project.count_by_title(nil)
+            assert_equal 1, Project.count_by_manager_id(12)
+            assert_equal 1, Project.count_by_manager_id_and_title(12, nil)
           
-          Project.create(:title => 'Hi There')
+            Project.create(:title => 'Hi There')
           
-          assert_equal 3, Project.count
-          assert_equal 2, Project.count_by_title(nil)
-        end
-        
-        context "with deleted" do
-          setup do
-            RockingChair::Server.reset
-            CouchPotato::Config.database_name = 'fake_simply_stored'
-            recreate_db
+            assert_equal 3, Project.count
+            assert_equal 2, Project.count_by_title(nil)
           end
+        
+          context "with deleted" do
+            setup do
+              RockingChair::Server.reset
+              CouchPotato::Config.database_name = 'fake_simply_stored'
+              recreate_db
+            end
           
-          should "ignore deleted in find all but load them in all with deleted" do
-            user = User.new(:firstname => 'Bart', :lastname => 'S')
-            assert user.save
+            should "ignore deleted in find all but load them in all with deleted" do
+              user = User.new(:firstname => 'Bart', :lastname => 'S')
+              assert user.save
             
-            deleted_user = User.new(:firstname => 'Pete', :lastname => 'S')
-            assert deleted_user.save
+              deleted_user = User.new(:firstname => 'Pete', :lastname => 'S')
+              assert deleted_user.save
             
-            deleted_user.destroy
+              deleted_user.destroy
 
-            assert_equal ['Bart'], User.all.map(&:firstname)
-            assert_equal ['Bart', 'Pete'].sort, User.find(:all, :with_deleted => true).map(&:firstname).sort
-          end
+              assert_equal ['Bart'], User.all.map(&:firstname)
+              assert_equal ['Bart', 'Pete'].sort, User.find(:all, :with_deleted => true).map(&:firstname).sort
+            end
           
-          should "ignore deleted in find first" do
-            user = User.new(:firstname => 'Bart', :lastname => 'S')
-            assert user.save
-            assert_equal 'Bart', User.find(:first).firstname
-            user.destroy
-            assert_nil User.first
-            assert_equal 'Bart', User.find(:first, :with_deleted => true).firstname
-          end
+            should "ignore deleted in find first" do
+              user = User.new(:firstname => 'Bart', :lastname => 'S')
+              assert user.save
+              assert_equal 'Bart', User.find(:first).firstname
+              user.destroy
+              assert_nil User.first
+              assert_equal 'Bart', User.find(:first, :with_deleted => true).firstname
+            end
           
-          should "ignore deleted in belongs_to/has_many" do
-            project = Project.new(:title => 'secret')
-            assert project.save
+            should "ignore deleted in belongs_to/has_many" do
+              project = Project.new(:title => 'secret')
+              assert project.save
             
-            user = User.new(:firstname => 'Bart', :lastname => 'S', :project => project)
-            assert user.save
+              user = User.new(:firstname => 'Bart', :lastname => 'S', :project => project)
+              assert user.save
             
-            assert_equal [user.id], project.users.map(&:id)
-            user.destroy
+              assert_equal [user.id], project.users.map(&:id)
+              user.destroy
             
-            assert_equal [], project.users(:force_reload => true, :with_deleted => false).map(&:id)
-            assert_equal [user.id], project.users(:force_reload => true, :with_deleted => true).map(&:id)
-          end
+              assert_equal [], project.users(:force_reload => true, :with_deleted => false).map(&:id)
+              assert_equal [user.id], project.users(:force_reload => true, :with_deleted => true).map(&:id)
+            end
           
+          end
         end
-      end
       
-      context "With array views" do
+        context "With array views" do
 
-        should "find objects with one match of the array" do
-          CustomViewUser.create(:tags => ["agile", "cool", "extreme"])
-          CustomViewUser.create(:tags => ["agile"])
-          assert_equal 2, CustomViewUser.find_all_by_tags("agile").size
-        end
+          should "find objects with one match of the array" do
+            CustomFiewUser.create(:tags => ["agile", "cool", "extreme"])
+            CustomFiewUser.create(:tags => ["agile"])
+            assert_equal 2, CustomFiewUser.find_all_by_tags("agile").size
+          end
 
-        should "find the object when the property is not an array" do
-          CustomViewUser.create(:tags => "agile")
-          assert_equal 1, CustomViewUser.find_all_by_tags("agile").size
+          should "find the object when the property is not an array" do
+            CustomFiewUser.create(:tags => "agile")
+            assert_equal 1, CustomFiewUser.find_all_by_tags("agile").size
+          end
         end
-      end
       
-    end
-    
-    context "when deleting" do
-      should "delete the doc" do
-        user = User.new(:firstname => 'Bart', :lastname => 'S')
-        assert user.save
-        assert user.delete
       end
-    end
     
-    context "when handling n:m relations using has_and_belongs_to_many" do
-      should "work relations from both sides" do
-        network_a = Network.create(:klass => "A")
-        network_b = Network.create(:klass => "B")
-        3.times {
-          server = Server.new
-          server.add_network(network_a)
-          server.add_network(network_b)
-        }
-        assert_equal 3, network_a.servers.size
-        network_a.servers.each do |server|
-          assert_equal 2, server.networks.size
-        end
-        assert_equal 3, network_b.servers.size
-        network_b.servers.each do |server|
-          assert_equal 2, server.networks.size
+      context "when deleting" do
+        should "delete the doc" do
+          user = User.new(:firstname => 'Bart', :lastname => 'S')
+          assert user.save
+          assert user.delete
         end
       end
-
-      should "work relations from both sides - regardless from where the add was called" do
-        network_a = Network.create(:klass => "A")
-        network_b = Network.create(:klass => "B")
-        3.times {
-          server = Server.new
-          network_a.add_server(server)
-          network_b.add_server(server)
-        }
-        assert_equal 3, network_a.servers.size
-        network_a.servers.each do |server|
-          assert_equal 2, server.networks.size, server.network_ids.inspect
+    
+      context "when handling n:m relations using has_and_belongs_to_many" do
+        should "work relations from both sides" do
+          network_a = Network.create(:klass => "A")
+          network_b = Network.create(:klass => "B")
+          3.times {
+            server = Server.new
+            server.add_network(network_a)
+            server.add_network(network_b)
+          }
+          assert_equal 3, network_a.servers.size
+          network_a.servers.each do |server|
+            assert_equal 2, server.networks.size
+          end
+          assert_equal 3, network_b.servers.size
+          network_b.servers.each do |server|
+            assert_equal 2, server.networks.size
+          end
         end
-        assert_equal 3, network_b.servers.size
-        network_b.servers.each do |server|
-          assert_equal 2, server.networks.size
+
+        should "work relations from both sides - regardless from where the add was called" do
+          network_a = Network.create(:klass => "A")
+          network_b = Network.create(:klass => "B")
+          3.times {
+            server = Server.new
+            network_a.add_server(server)
+            network_b.add_server(server)
+          }
+          assert_equal 3, network_a.servers.size
+          network_a.servers.each do |server|
+            assert_equal 2, server.networks.size, server.network_ids.inspect
+          end
+          assert_equal 3, network_b.servers.size
+          network_b.servers.each do |server|
+            assert_equal 2, server.networks.size
+          end
         end
-      end
 
-      should "cound correctly - regardless of the side of the relation" do
-        network_a = Network.create(:klass => "A")
-        network_b = Network.create(:klass => "B")
-        3.times {
-          server = Server.new
-          network_a.add_server(server)
-          network_b.add_server(server)
-        }
-        assert_equal 3, network_a.server_count
-        assert_equal 3, network_b.server_count
-        assert_equal 2, network_a.servers.first.network_count
-        assert_equal 2, network_b.servers.first.network_count
-      end
+        should "cound correctly - regardless of the side of the relation" do
+          network_a = Network.create(:klass => "A")
+          network_b = Network.create(:klass => "B")
+          3.times {
+            server = Server.new
+            network_a.add_server(server)
+            network_b.add_server(server)
+          }
+          assert_equal 3, network_a.server_count
+          assert_equal 3, network_b.server_count
+          assert_equal 2, network_a.servers.first.network_count
+          assert_equal 2, network_b.servers.first.network_count
+        end
 
-      should "support mixing order and limit" do
-        network_1 = Network.find(Network.create!(:klass => "A").id)
-        network_1.created_at = Time.local(2001)
-        network_1.save!
+        should "support mixing order and limit" do
+          network_1 = Network.find(Network.create!(:klass => "A").id)
+          network_1.created_at = Time.local(2001)
+          network_1.save!
 
-        network_2 = Network.find(Network.create!(:klass => "B").id)
-        network_2.created_at = Time.local(2002)
-        network_2.save!
+          network_2 = Network.find(Network.create!(:klass => "B").id)
+          network_2.created_at = Time.local(2002)
+          network_2.save!
 
-        server_1 = Server.find(Server.create!(:hostname => 'www.example.com').id)
-        server_1.created_at = Time.local(2003)
-        network_1.add_server(server_1)
-        network_2.add_server(server_1)
+          server_1 = Server.find(Server.create!(:hostname => 'www.example.com').id)
+          server_1.created_at = Time.local(2003)
+          network_1.add_server(server_1)
+          network_2.add_server(server_1)
 
-        server_2 = Server.find(Server.create!(:hostname => 'foo.com').id)
-        server_2.created_at = Time.local(2004)
-        network_1.add_server(server_2)
-        network_2.add_server(server_2)
+          server_2 = Server.find(Server.create!(:hostname => 'foo.com').id)
+          server_2.created_at = Time.local(2004)
+          network_1.add_server(server_2)
+          network_2.add_server(server_2)
 
-        assert_equal ['www.example.com', 'foo.com'], network_1.servers(:order => :asc).map(&:hostname)
-        assert_equal ['www.example.com', 'foo.com'].reverse, network_1.servers(:order => :desc).map(&:hostname)
+          assert_equal ['www.example.com', 'foo.com'], network_1.servers(:order => :asc).map(&:hostname)
+          assert_equal ['www.example.com', 'foo.com'].reverse, network_1.servers(:order => :desc).map(&:hostname)
 
-        assert_equal ['A', 'B'], server_2.networks(:order => :asc).map(&:klass)
-        assert_equal ['A', 'B'].reverse, server_2.networks(:order => :desc).map(&:klass)
+          assert_equal ['A', 'B'], server_2.networks(:order => :asc).map(&:klass)
+          assert_equal ['A', 'B'].reverse, server_2.networks(:order => :desc).map(&:klass)
 
-        assert_equal ['www.example.com'], network_1.servers(:order => :asc, :limit => 1).map(&:hostname)
-        assert_equal ['foo.com'], network_1.servers(:order => :desc, :limit => 1).map(&:hostname)
+          assert_equal ['www.example.com'], network_1.servers(:order => :asc, :limit => 1).map(&:hostname)
+          assert_equal ['foo.com'], network_1.servers(:order => :desc, :limit => 1).map(&:hostname)
 
-        assert_equal ['A'], server_2.networks(:order => :asc, :limit => 1).map(&:klass)
-        assert_equal ['B'], server_2.networks(:order => :desc, :limit => 1).map(&:klass)
-      end
+          assert_equal ['A'], server_2.networks(:order => :asc, :limit => 1).map(&:klass)
+          assert_equal ['B'], server_2.networks(:order => :desc, :limit => 1).map(&:klass)
+        end
       
-      should "when counting cache the result" do
-        @network = Network.create(:klass => "C")
-        @server = Server.create
-        assert_equal 0, @network.server_count
-        Server.create(:network_ids => [@network.id])
-        assert_equal 0, @network.server_count
-        assert_equal 0, @network.instance_variable_get("@server_count")
-        @network.instance_variable_set("@server_count", nil)
-        assert_equal 1, @network.server_count
-      end
+        should "when counting cache the result" do
+          @network = Network.create(:klass => "C")
+          @server = Server.create
+          assert_equal 0, @network.server_count
+          Server.create(:network_ids => [@network.id])
+          assert_equal 0, @network.server_count
+          assert_equal 0, @network.instance_variable_get("@server_count")
+          @network.instance_variable_set("@server_count", nil)
+          assert_equal 1, @network.server_count
+        end
 
-      should "when counting cache the result - from both directions" do
-        @network = Network.create(:klass => "C")
-        @server = Server.create
-        assert_equal 0, @server.network_count
-        @server.network_ids = [@network.id]
-        @server.save!
-        assert_equal 0, @server.network_count
-        assert_equal 0, @server.instance_variable_get("@network_count")
-        @server.instance_variable_set("@network_count", nil)
-        assert_equal 1, @server.network_count
+        should "when counting cache the result - from both directions" do
+          @network = Network.create(:klass => "C")
+          @server = Server.create
+          assert_equal 0, @server.network_count
+          @server.network_ids = [@network.id]
+          @server.save!
+          assert_equal 0, @server.network_count
+          assert_equal 0, @server.instance_variable_get("@network_count")
+          @server.instance_variable_set("@network_count", nil)
+          assert_equal 1, @server.network_count
+        end
       end
-    end
 
-    context "when deleting all design docs" do
-      should "reset all design docs" do
-        User.find_all_by_firstname('a')
-        db = "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
-        assert_nothing_raised do
-          assert_equal 1, SimplyStored::Couch.delete_all_design_documents(db)
+      context "when deleting all design docs" do
+        should "reset all design docs" do
+          User.find_all_by_firstname('a')
+          db = "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
+          assert_nothing_raised do
+            assert_equal 1, SimplyStored::Couch.delete_all_design_documents(db)
+          end
         end
       end
     end
-     
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rocking_chair
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Jonathan Weiss
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-22 00:00:00 +01:00
+date: 2011-04-04 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency