couch_tomato 0.1.0

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+require 'couchrest'
+require File.dirname(__FILE__) + '/../lib/couch_tomato.rb'
+
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+unless Test::Unit::TestCase.include?(RR::Adapters::TestUnit)
+  class Test::Unit::TestCase
+    include RR::Adapters::TestUnit
+  end
+end
+
+
+def unload_const (klass)
+  if Object.send :const_defined?, klass
+    Object.send :remove_const, klass
+  end
+end
+
+def create_const(super_klass=nil)
+  super_klass ? Class.new(super_klass) : Class.new
+end
+
+# TestDb = create_const(CouchTomato::Database)
+
+# class Test::Unit::TestCase
+#   include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
+# end
+
+# 3.times {puts}
+
+# class TestDb > CouchTomato::Database
+#   name 'couch_tomato_test'
+# end
+
+# CouchTomato::Config.database_name = 'couch_tomato_test'
+# CouchTomato::Config.database_server = 'http://127.0.0.1:5984/'
+
+
+# class Comment
+#   include CouchTomato::Persistence
+# 
+#   validates_presence_of :title
+# 
+#   property :title
+#   belongs_to :commenter
+# end
+# 
+# def recreate_db
+#   CouchTomato.couchrest_database.delete! rescue nil
+#   CouchTomato.couchrest_database.server.create_db CouchTomato::Config.database_name
+# end
+# recreate_db
+# 
+# Spec::Matchers.define :string_matching do |regex|
+#   match do |string|
+#     string =~ regex
+#   end
+# end

data/test/unit/database_test.rb

@@ -0,0 +1,285 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../lib/couch_tomato.rb'
+
+module Foo
+  class Bar
+  end
+end
+
+class DatabaseTes < Test::Unit::TestCase
+  context "A Database class" do
+    setup do
+      unload_const('TestDb')
+      ::TestDb = create_const(CouchTomato::Database)
+    end
+        
+    should "have a database name" do
+      TestDb.class_eval do
+        name 'hello-world'
+      end
+      assert_equal TestDb.database_name, 'hello-world'
+    end # have db name
+    
+    should "assign the localhost as server if none is given" do
+      @db =  Object.new
+      stub(TestDb).database_name{'hello-world'}
+      stub(TestDb).database{@db}
+      stub(@db).info{1}
+      
+      TestDb.class_eval do
+        server 
+      end
+      assert_equal TestDb.database_server, 'http://127.0.0.1:5984/'
+    end #instatiate couchrest
+    
+    should "raise an exception if the database doesn't exist" do
+      assert_raise RestClient::RequestFailed do
+        TestDb.class_eval do
+          name 'DoesNotExist'
+          server # 'http://127.0.0.1:5984/does-not-exist'
+        end
+        TestDb.database
+      end
+    end
+    
+    context "with a correctly configured database and server" do
+      setup do
+        stub(TestDb).database_name{'hello-world'}
+        stub(TestDb).database_server{'http://127.0.0.1:5984/'}
+        stub(TestDb.database).info{1}
+      end
+    
+      should "raise an exception if no nemonic is given for the view" do
+        assert_raise ArgumentError do
+          TestDb.class_eval do
+            view
+          end
+        end 
+      end # raise an exception
+      
+      should "use nemonic name for view name if none is given" do
+        TestDb.class_eval do
+          view :hello
+        end 
+        assert_equal TestDb.views[:hello][:view_name], 'hello'
+      end #should have data from view
+
+      should "use database name for design doc name if none is given" do
+        TestDb.class_eval do
+          view :hello
+        end 
+        assert_equal TestDb.views[:hello][:design_doc].to_s, 'hello-world'
+      end #should have data from view
+      
+      context "if given a document to save" do
+        setup do
+          @document = Object.new
+          stub(@document).dirty?{1}   
+        end
+
+        should "call create_doc if the document is new" do
+          stub(@document).new?{1}     
+          stub(TestDb).create_document {true}   
+          dont_allow(TestDb).update_document(@document)
+          assert_equal TestDb.save_document(@document), true    
+        end
+                 
+        should "call update_doc if the document is not new" do               
+          stub(@document).new?{nil}
+          stub(TestDb).update_document {true}   
+          dont_allow(TestDb).create_document(@document)
+          assert_equal TestDb.save_document(@document), true    
+        end
+        
+        context ", " do
+          setup do
+            stub(@document).valid?{1}
+            stub(@document).to_hash{1}
+
+            stub(TestDb.database).save_doc{{'rev' => '1', 'id' => '123', }}
+            stub(@document)._rev=('1')
+            
+            mock(@document).run_callbacks(:before_validation_on_save)
+            mock(@document).run_callbacks(:before_save)
+            mock(@document).run_callbacks(:after_save)
+          end
+
+          should ", if the document is new, call the required callbacks before saving it" do
+            stub(@document).new?{1}                        
+
+            stub(@document).database=(TestDb)
+            stub(@document)._id=('123') 
+          
+            mock(@document).run_callbacks(:before_validation_on_create)
+            mock(@document).run_callbacks(:before_create)
+            mock(@document).run_callbacks(:after_create)
+          
+            assert_equal TestDb.save_document(@document), true
+          end
+          
+          should ", if the document is not new, call the required callbacks before saving it" do
+            stub(@document).new?{nil}               
+ 
+            mock(@document).run_callbacks(:before_validation_on_update)
+            mock(@document).run_callbacks(:before_update)
+            mock(@document).run_callbacks(:after_update)
+          
+            assert_equal TestDb.save_document(@document), true
+          end          
+        end # context ,
+      end #context if given a doc to save
+      
+      context "if loading a document" do
+        setup do
+          
+        end
+
+        should "raise an exception if no id is given" do
+          assert_raise ArgumentError do
+            TestDb.load_doc
+          end 
+        end
+        
+        should "raise an exception if a nil id is given" do
+          assert_raise RuntimeError do
+            TestDb.load_doc nil
+          end 
+        end
+        
+        should "return nil if no document matching the given id is found" do
+          stub(TestDb.database).get('123456789'){raise RestClient::ResourceNotFound}
+          document = TestDb.load_doc '123456789'
+          assert_equal document, nil
+        end
+
+        should "return a hash if :model => :raw is given as an option" do
+          stub(TestDb.database).get('123456789'){{:key => "value", :key2 => "value2", }}
+          document = TestDb.load_doc '123456789', :model => :raw
+          assert_equal document, {:key => "value", :key2 => "value2", }
+        end
+        
+        should "return a hash if the document does not specify a class" do
+          stub(TestDb.database).get('123456789'){{:key => "value", :key2 => "value2", }}
+          document = TestDb.load_doc '123456789'
+          assert_equal document, {:key => "value", :key2 => "value2", }
+        end
+        
+        should "return the right class of object if one is specified in the document" do
+          stub(TestDb.database).get('123456789'){{'ruby_class' => 'Object', :key2 => "value2", }}
+          document = TestDb.load_doc '123456789'
+          # document = TestDb.load_doc '123456789', :model => Object
+          
+          assert_equal document.class, Object
+        end
+        
+        should "find classes namespeced within other classes" do
+          stub(TestDb.database).get('123456789'){{'ruby_class' => 'Foo::Bar', :key2 => "value2", }}
+          document = TestDb.load_doc '123456789'
+          
+          assert_equal document.class, Foo::Bar
+        end
+      end #context loading document
+      
+      context "if querying a view" do
+        setup do
+          
+        end
+
+        should "raise an exception if the view is not found in the DB class" do
+          #  self.query_view(name, options.merge(self.views[name][:couch_options]))
+          assert_raise RuntimeError do
+            TestDb.query_view!(:query_name)
+          end
+        end
+        
+        should "raise an exception if the view is not found in the database" do
+          stub(TestDb).query_view(:query_name,{}){raise RestClient::ResourceNotFound}
+          stub(TestDb).views{{:query_name => "query_name"}}
+          
+          assert_raise RestClient::ResourceNotFound do
+            TestDb.query_view!(:query_name)
+          end
+          
+        end
+        
+        context "the results" do
+          setup do
+            @fields = {:"key" => "value", :"key2" => "value2"}
+            @fields2 = {:"key3" => "value3", :"key4" => "value4"}
+            
+            @row1 = {"id" => "123456789", "value" => @fields, "key" => "7654321"}
+            @row2 = {"id" => "987654321", "value" => @fields2, "key" => "1234567"}
+          end
+
+           should "return an array of hashes if the documents do not cotain Class info" do
+            stub(TestDb).query_view(:query_name,{}){{"rows" => [@row1, @row2], "offset" => 0, "total_rows" => 2 }}
+            stub(TestDb).views{{:query_name => {:anything => "query_name"}}}
+          
+            assert_equal TestDb.query_view!(:query_name), [@fields, @fields2]
+          end
+          
+          should "find classes namespeced within other classes"
+          
+          should "return an empty array if results is empty" do
+            stub(TestDb).views{{:query_name => {:anything => "query_name"}}}
+            
+            empty_results = {"rows" => [], "offset" => 0, "total_rows" => 2 }
+            assert_equal TestDb.process_results(:query_name, empty_results), []
+          end
+          
+          should "return an array of hashes if the documents cotain Class info but the user specified :model=> :raw" do
+            @fields.merge!({"ruby_class" => "Object"})
+            @fields2.merge!({"ruby_class" => "Object"})
+          
+            stub(TestDb).query_view(:query_name,{:model => :raw}){{"rows" => [@row1, @row2], "offset" => 0, "total_rows" => 2 }}
+            stub(TestDb).views{{:query_name => {:anything => "query_name"}}}
+          
+            assert_equal TestDb.query_view!(:query_name, :model => :raw ), [@fields, @fields2]
+          
+          end
+        
+          should "return an array of Objects if the view definition specified :model=> Object" do
+            @fields.merge!({"ruby_class" => "Object"})
+            @fields2.merge!({"ruby_class" => "Object"})
+
+            stub(TestDb).query_view(:query_name,{}){{"rows" => [@row1, @row2], "offset" => 0, "total_rows" => 2 }}
+            stub(TestDb).views{{:query_name => {:model => Object}}}
+            stub(Object).json_create(@fields, {"id"=>"123456789", "key"=>"7654321"}){Object.new}
+            stub(Object).json_create(@fields2, {"id"=>"987654321", "key"=>"1234567"}){Object.new}
+            
+          
+            assert_equal TestDb.query_view!(:query_name, {})[0].class, Object
+            assert_equal TestDb.query_view!(:query_name, {})[1].class, Object
+          end
+          
+          should "return an array of Objects if the view definition did not specify :model=> Object but the docs contain 'ruby_class' info" do
+            @fields.merge!({"ruby_class" => "Object"})
+            @fields2.merge!({"ruby_class" => "Object"})
+          
+            stub(TestDb).query_view(:query_name,{}){{"rows" => [@row1, @row2], "offset" => 0, "total_rows" => 2 }}
+            stub(TestDb).views{{:query_name => {:anything => "query_name"}}}
+            stub(Object).json_create(@fields, {"id"=>"123456789", "key"=>"7654321"}){Object.new}
+            stub(Object).json_create(@fields2, {"id"=>"987654321", "key"=>"1234567"}){Object.new}
+          
+            assert_equal TestDb.query_view!(:query_name, {})[0].class, Object
+            assert_equal TestDb.query_view!(:query_name, {})[1].class, Object
+          
+          end          
+          
+          should "return an mixed array of Objects and hashes if the view definition did not specify :model=> Object but some docs contain 'ruby_class' info" do
+            @fields.merge!({"ruby_class" => "Object"})
+
+            stub(TestDb).query_view(:query_name,{}){{"rows" => [@row1, @row2], "offset" => 0, "total_rows" => 2 }}
+            stub(TestDb).views{{:query_name => {:anything => "query_name"}}}
+            stub(Object).json_create(@fields, {"id"=>"123456789", "key"=>"7654321"}){Object.new}
+            stub(Hash).json_create(@fields2, {"id"=>"987654321", "key"=>"1234567"}){Object.new}
+          
+            assert_equal TestDb.query_view!(:query_name, {})[0].class, Object
+            assert_equal TestDb.query_view!(:query_name, {})[1].class, Hash
+          
+          end
+        end # context the results          
+      end # context querying a view
+    end # context with db and serv
+  end #context a Db  
+end # class