rocking_chair 0.0.2

data/test/fixtures/extended_couch_rest_fixtures.rb

@@ -0,0 +1,23 @@
+SERVER = CouchRest.new
+SERVER.default_database = 'couchrest-extendeddoc-example'
+
+class Comment < CouchRest::ExtendedDocument
+  use_database SERVER.default_database
+  property :body
+  property :post_id
+  timestamps!  
+  
+  view_by :post_id
+end
+
+class Post < CouchRest::ExtendedDocument
+  use_database SERVER.default_database  
+  property :title
+  property :body
+  timestamps!
+  
+  def comments
+    Comment.by_post_id :key => id
+  end
+end
+

data/test/fixtures/simply_stored_fixtures.rb

@@ -0,0 +1,36 @@
+require 'simply_stored/couch'
+
+class User
+  include SimplyStored::Couch
+
+  property :firstname
+  property :lastname
+  belongs_to :project
+  
+  enable_soft_delete
+  
+  view :by_name, :key => :name
+end
+
+class Project
+  include SimplyStored::Couch
+
+  property :title
+  has_many :users
+  belongs_to :manager
+end
+
+class Manager
+  include SimplyStored::Couch
+
+  property :firstname
+  property :lastname
+  has_one :project
+end
+
+class CustomViewUser
+  include SimplyStored::Couch
+  
+  property :tags
+  view :by_tags, :type => SimplyStored::Couch::Views::ArrayPropertyViewSpec, :key => :tags
+end

data/test/simply_stored_test.rb

@@ -0,0 +1,214 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+def recreate_db
+  CouchPotato.couchrest_database.delete! rescue nil
+  CouchPotato.couchrest_database.server.create_db CouchPotato::Config.database_name
+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
+    
+    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
+      end
+    end
+    
+    context "Views" do
+      setup do
+        @manager = Manager.new(:firstname => 'Michael')
+        assert @manager.save
+        
+        @project = Project.new(:title => 'The title', :manager => @manager)
+        assert @project.save
+        
+        @user = User.new(:firstname => 'Michael', :project => @project)
+        assert @user.save
+      end
+      
+      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 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 "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
+      
+      context "belongs_to" do
+        should "load the parent object" do
+          assert_equal @project.id, @user.project.id
+        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
+        
+        should "re-use existing views" do
+          Manager.create(:firstname => 'Jochen', :lastname => 'Peter')
+          Manager.create(:firstname => 'Another', :lastname => 'Bert')
+        end
+      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
+      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
+          
+          User.create(:firstname => 'Hulk', :project => @project)
+          assert_equal ['Peter', 'Michael Mann', 'Hulk'].sort, User.all.map(&:firstname).sort
+        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')
+        
+          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)
+
+          assert_equal 2, Project.count
+          assert_equal 1, Manager.count
+          assert_equal 3, User.count
+        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
+            
+            deleted_user = User.new(:firstname => 'Pete', :lastname => 'S')
+            assert deleted_user.save
+            
+            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
+          
+          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
+            
+            user = User.new(:firstname => 'Bart', :lastname => 'S', :project => project)
+            assert user.save
+            
+            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
+          
+        end
+      end
+      
+      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 the object when the property is not an array" do
+          CustomViewUser.create(:tags => "agile")
+          assert_equal 1, CustomViewUser.find_all_by_tags("agile").size
+        end
+      end
+      
+    end
+     
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../lib/rocking_chair"
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+require File.dirname(__FILE__) + "/fixtures/extended_couch_rest_fixtures"
+require File.dirname(__FILE__) + "/fixtures/simply_stored_fixtures"
+
+RockingChair.enable
+
+def assert_error_code(code, &blk)
+  ex = nil
+  begin
+    blk.call
+  rescue Exception => e
+    ex = e
+  ensure
+    assert_not_nil ex, "No Exception raised!"
+    assert_equal RockingChair::Error, ex.class, "The raised exception is not a RockingChair::Error: #{e.class}: #{e.message} - #{e.backtrace.join("\n")}"
+    assert_equal code, ex.code
+  end
+end
+
+def dump_RockingChair
+  puts "No datases set yet!" if RockingChair::Server.databases.empty?
+  RockingChair::Server.databases.each do |db_name, db|
+    puts "Content of Database #{db_name}: \n\n#{db.inspect}"
+  end
+end
+
+def with_debug(&blk)
+  HttpAbstraction.instance_variable_set("@_rocking_chair_debug", true)
+  blk.call
+  HttpAbstraction.instance_variable_set("@_rocking_chair_debug", false)
+end

data/test/view_test.rb

@@ -0,0 +1,372 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class ViewTest < Test::Unit::TestCase
+  context "A database view" do
+    setup do
+      @db = RockingChair::Database.new
+    end
+    
+    should "need a database, a design doc, and a view name" do
+      assert_error_code 404 do
+        RockingChair::View.new(@db, 'user', 'by_firstname', {})
+      end
+      
+      @db['_design/user'] = { 'language' => 'javascript', 'views' => {
+        'by_firstname' => {
+          'reduce' => "function(key, values){ return values.length }",
+          "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+        }
+      }}.to_json
+      
+      @db.stubs(:rev).returns('the-rev')
+      
+      assert_nothing_raised do
+        RockingChair::View.new(@db, 'user', 'by_firstname', {})
+      end
+    end
+    
+    should "be constructed out a database" do
+      @db['_design/user'] = { 'language' => 'javascript', 'views' => {
+        'by_firstname' => {
+          'reduce' => "function(key, values){ return values.length }",
+          "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+        }
+      }}.to_json
+      
+      assert_nothing_raised do
+        JSON.parse(@db.view('user', 'by_firstname', {}))
+      end
+    end
+    
+    context "when querying the views" do
+      setup do
+        @db['_design/user'] = { 'language' => 'javascript', 'views' => {
+          'all_documents' => {
+            'reduce' => nil, 
+            'map' => "function(item){emit(item)}"
+          },
+          'by_firstname' => {
+            'reduce' => "function(key, values){ return values.length }",
+            "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+          },
+          'by_firstname_and_lastname' => {
+            'reduce' => "function(key, values){ return values.length }",
+            "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+          },
+          'association_user_belongs_to_project' => {
+            'reduce' => "function(key, values){ return values.length }",
+            "map" => "function(doc) {\n if(doc.ruby_class && doc.ruby_class == 'Instance') {\n emit(doc['created_at'], null);\n }\n }"
+          }
+        }}.to_json
+        
+        @db.stubs(:rev).returns('the-rev')
+      end
+      
+      should "respond to defined views" do
+        assert_nothing_raised do
+          @db.view('user', 'by_firstname', 'key' => 'abc')
+        end
+      end
+      
+      should "raise a 404 on undefined views" do
+        assert_error_code 404 do
+          @db.view('user', 'by_other_name', 'key' => 'abc')
+        end
+      end
+      
+      context "when querying by_attr_and_attr views" do
+        
+        should "return all keys if no key is given" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 3,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => nil,
+              "value" => nil,
+              },{
+              "id" => "user_3",
+              "key" => nil,
+              "value" => nil, 
+              },{
+              "id" => "user_2",
+              "key" => nil,
+              "value" => nil
+              }
+            ]}, JSON.parse(@db.view('user', 'by_firstname')))
+        end
+        
+        should "return all docs if no key is given and we asked to include the docs" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 3,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              },{
+              "id" => "user_3",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Horst",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_3' }
+              }, {
+              "id" => "user_2",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Carl",
+                "lastname" => "Alf",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_2' }
+              }
+            ]}.to_json, @db.view('user', 'by_firstname', 'include_docs' => 'true'))
+        end
+        
+        should "return matching elements" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 2,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => "Alf",
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }, {
+              "id" => "user_3",
+              "key" => "Alf",
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Horst",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_3' }
+              }
+            ]}.to_json, @db.view('user', 'by_firstname', 'key' => "Alf".to_json, 'include_docs' => 'true'))
+        end
+        
+        should "only return items with the correct klass matcher" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'Project'}.to_json
+          @db['user_2'] = {"firstname" => 'Alf', 'lastname' => 'Michaels'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 1,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_3",
+              "key" => "Alf",
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Horst",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_3' }
+              }
+            ]}.to_json, @db.view('user', 'by_firstname', 'key' => "Alf".to_json, 'include_docs' => 'true'))
+        end
+        
+        should "support multiple attributes" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 1,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => ["Alf", "Bert"],
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }
+            ]}.to_json, @db.view('user', 'by_firstname_and_lastname', 'key' => ["Alf", "Bert"].to_json, 'include_docs' => 'true'))
+        end
+
+        should "support startkey and endkey parameters" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal(JSON.parse({
+            "total_rows" => 2,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "endkey" => "Alf",
+              "value" => nil,
+              "startkey" => "Alf",
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }, {
+              "id" => "user_3",
+              "endkey" => "Alf",
+              "value" => nil,
+              "startkey" => "Alf",
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Horst",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_3' }
+              }
+            ]}.to_json), JSON.parse(@db.view('user', 'by_firstname', 'startkey' => "Alf".to_json, 'endkey' => "Alf".to_json, 'include_docs' => 'true')))
+        end
+        
+        should "support startkey/endkey combined with startkey_docid/endkey_docid parameters" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['user_3'] = {"firstname" => 'Alf', 'lastname' => 'Horst', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal(JSON.parse({
+            "total_rows" => 2,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_3",
+              "startkey" => "Alf",
+              "endkey" => "Alf",
+              "startkey_docid" => "user_3",
+              "endkey_docid" => "user_3",
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Horst",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_3' }
+              }
+            ]}.to_json), JSON.parse(@db.view('user', 'by_firstname', 'startkey' => "Alf".to_json, 'endkey' => "Alf".to_json, 'startkey_docid' => "user_3".to_json, "endkey_docid" => 'user_3'.to_json, 'include_docs' => 'true', 'limit' => '1')))
+        end
+      end
+      
+      context "belongs_to" do
+        should "load parent" do
+          @db['project_1'] = {"title" => 'alpha', 'ruby_class' => 'Project'}.to_json
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'project_id' => 'project_1', 'ruby_class' => 'User'}.to_json
+                  
+          assert_equal({
+            "total_rows" => 1,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => "project_1",
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                "project_id" => "project_1",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }
+            ]}.to_json, @db.view('user', 'association_user_belongs_to_project', 'key' => "project_1".to_json, 'include_docs' => 'true'))
+        end
+      end
+      
+      context "all_documents" do
+        should "load all documents of the matching class" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          @db['project_1'] = {"title" => 'Alpha', 'ruby_class' => 'Project'}.to_json
+          
+          assert_equal({
+            "total_rows" => 2,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }, {
+              "id" => "user_2",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Carl",
+                "lastname" => "Alf",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_2' }
+              }
+            ]}.to_json, @db.view('user', 'all_documents', 'include_docs' => 'true'))
+        end
+        
+        should "limit the results if asked to" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "total_rows" => 2,
+            "offset" => 0,
+            "rows" => [{
+              "id" => "user_1",
+              "key" => nil,
+              "value" => nil,
+              "doc" => {
+                "firstname" => "Alf",
+                "lastname" => "Bert",
+                'ruby_class' => 'User',
+                '_rev' => 'the-rev',
+                '_id' => 'user_1' }
+              }
+            ]}.to_json, @db.view('user', 'all_documents', 'include_docs' => 'true', 'limit' => '1'))
+        end
+        
+        should "count the objects with reduce" do
+          @db['user_1'] = {"firstname" => 'Alf', 'lastname' => 'Bert', 'ruby_class' => 'User'}.to_json
+          @db['user_2'] = {"firstname" => 'Carl', 'lastname' => 'Alf', 'ruby_class' => 'User'}.to_json
+          
+          assert_equal({
+            "rows" => [{ "key" => nil, "value" => 2}]
+          }.to_json, @db.view('user', 'all_documents', 'include_docs' => 'false', 'reduce' => 'true'))
+        end
+      end
+      
+    end
+    
+  end
+end