couch_tomato 0.1.0

data/test/unit/js_view_test.rb

@@ -0,0 +1,362 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../lib/couch_tomato.rb'
+
+class JsViewTes < Test::Unit::TestCase
+  context "A Javascript View class" do
+    setup do
+      unload_const('TestView')
+      ::TestView = create_const(CouchTomato::JsViewSource)
+      def gen_str(size=10)
+        (0...size).map{ ('a'..'z').to_a[rand(26)] }.join
+      end
+      
+      def gen_num(size=10)
+        (0...size).map{ (0..9).to_a[rand(10)] }.join
+      end
+      
+      def gen_alphanum(size=10)
+        (0...size).map{ ((0..9).to_a + ('a'..'z').to_a)[rand(36)] }.join
+      end
+      
+      def gen_path(size=4)
+        "/" + Array.new(size).collect{ gen_str }.join("/")
+      end
+    end
+        
+    should "infer a single database name from the file system" do
+      path = gen_path
+      database = gen_str
+      stub(TestView).path { path }
+      stub(Dir).[](TestView.path + "/**") { ["#{path}/#{database}"] }
+      assert_equal TestView.fs_database_names, [database]
+    end
+    
+    should "get a single design doc from couch server" do
+      name = gen_str
+      mock(db = Object.new).get(anything, anything) {{
+        "rows" => [{
+          "doc" => {
+            "_id"=>"_design/#{name}"
+          }
+        }]}
+      }
+      
+      expected = { name.to_sym => { "_id"=>"_design/#{name}" } }
+      assert_equal TestView.db_design_docs(db), expected
+    end
+    
+    context "with views in the local filesystem" do
+      setup do
+        @path = gen_path
+        
+        class VirtualFile
+          def initialize(content)
+            @content = content
+          end
+          
+          def read
+            @content
+          end
+          
+          def close
+            @content = nil
+          end
+        end
+      end
+      
+      should "raise an exception when an invalid javascript file path is provided for a local view" do
+        assert_raise Errno::ENOENT do
+          TestView.fs_view({}, "#{@path}/#{gen_str}-map.js")
+        end
+      end
+      
+      should "raise an exception when an empty hash is provided as a container for the local javascript" do
+        mock(TestView).open(anything) { VirtualFile.new("") }
+        assert_raise RuntimeError do
+          TestView.fs_view({}, "#{@path}/#{gen_str}-map.js")
+        end
+      end
+      
+      should "raise an exception if a passed javascript does not contain a map or reduce tag" do
+        mock(TestView).open(anything) { VirtualFile.new("") }
+        assert_raise RuntimeError do
+          TestView.fs_view({}, "#{@path}/#{gen_str}.js")
+        end
+      end
+      
+      should "create a proper hash containing the information from a single javascript (view) file" do
+        content = gen_str
+        view_name = gen_str
+        view_type = "map"
+        file_path = "#{@path}/#{view_name}-#{view_type}.js"
+        sha = gen_alphanum(40)
+        
+        mock(TestView).open(anything) { VirtualFile.new(content) }
+        mock(Digest::SHA1).hexdigest(anything) { sha }
+        
+        expected = { "views" => {
+          view_name => {
+            view_type => content,
+            "sha1-#{view_type}" => sha
+          }
+        }}
+        assert_equal TestView.fs_view({'views' => {}}, file_path), expected
+      end
+      
+      should "properly accrue the views for a given design document/database(without any design docs)" do
+        design_name = gen_str
+        views = {
+          gen_str => {:map => { :content => gen_str, :sha1 => gen_alphanum(40) },
+                      :reduce => { :content => gen_str, :sha1 => gen_alphanum(40) }},
+          gen_str => {:map => { :content => gen_str, :sha1 => gen_alphanum(40) },
+                      :reduce => { :content => gen_str, :sha1 => gen_alphanum(40) }}
+        }
+        
+        accrued_hash = {'views' => {}}
+        views.each do |view_name, view_types|
+          view_types.each do |type, view_data|
+            stub(TestView).open { VirtualFile.new(view_data[:content]) }
+            path = "#{@path}/#{design_name}/#{view_name}-#{type.to_s}.js"
+            stub(Digest::SHA1).hexdigest { view_data[:sha1] }
+            TestView.fs_view(accrued_hash, path)
+          end
+        end
+        
+        expected = {'views' => {}}
+        views.each do |view_name, view_types|
+          expected['views'][view_name] ||= {}
+          view_types.each do |type, view_data|
+            expected['views'][view_name][type.to_s] = view_data[:content]
+            expected['views'][view_name]["sha1-#{type.to_s}"] = view_data[:sha1]
+          end
+        end
+        assert_equal accrued_hash, expected
+      end
+    end
+    
+    context "with design documents in the local filesystem that need to be aggregated" do
+      setup do
+        @path = gen_path
+        @db_name = gen_str
+        stub(TestView).path { @path + "/" + @db_name }
+        
+        def assign_path(views, design_doc=nil)
+          views.map do |view|
+            [@path, @db_name, design_doc, view].compact.join("/")
+          end
+        end
+      end
+    
+      should "get a hash of a design doc under a specific database with no design folders in the filesystem; no reduce functions" do
+        view = gen_str
+        view_components = ["#{view}-map.js"]
+
+        stub(Dir).[](TestView.path + "/**") { assign_path(view_components) }
+        fs_view_return = {
+          "views"=> {
+            "#{view}"=> {}
+          }
+        }
+        
+        stub(TestView).fs_view { fs_view_return }
+        expected = { @db_name.to_sym => fs_view_return }
+        assert_equal TestView.fs_design_docs(@db_name), expected
+      end
+      
+      should "get a hash of a design doc under a specific database with no design folders in the filesystem; one reduce function" do
+        view = gen_str
+        view_components = ["#{view}-map.js", "#{view}-reduce.js"]
+      
+        stub(Dir).[](TestView.path + "/**") { assign_path(view_components) }
+        fs_view_return = {
+          "views"=> {
+            "#{view}"=> { "reduce"=>gen_str, "map"=>gen_str }
+          }
+        }
+          
+        stub(TestView).fs_view { fs_view_return }
+        expected = { @db_name.to_sym => fs_view_return }
+        assert_equal TestView.fs_design_docs(@db_name), expected
+      end
+      
+      should "raise an exception when a reduce view is given without a corresponding map view under a specific database with no design folders" do
+        view = gen_str
+        view_components = ["#{view}-reduce.js"]
+      
+        stub(Dir).[](TestView.path + "/**") { assign_path(view_components) }
+        fs_view_return = {
+          "views"=> {
+            "#{view}"=> { "reduce"=>gen_str }
+          }
+        }
+          
+        stub(TestView).fs_view { fs_view_return }
+        assert_raise RuntimeError do
+          TestView.fs_design_docs(@db_name)
+        end
+      end
+
+      should "get a hash of design docs under a specific database with multiple design folders" do
+        design_names = [gen_str, gen_str]
+        views = design_names.inject({}) do |doc_views, doc_name|
+          view = gen_str
+          doc_views.merge!(doc_name => ["#{view}-map.js", "#{view}-reduce.js"])
+        end
+
+        mock(Dir).[](TestView.path + "/**") { assign_path(design_names) }
+        mock(Dir).[]("#{TestView.path}/#{design_names[0]}/*.js") { 
+          assign_path(views[design_names[0]], design_names[0]) }
+        mock(Dir).[]("#{TestView.path}/#{design_names[1]}/*.js") { 
+          assign_path(views[design_names[1]], design_names[1]) }
+          
+        expected = {
+          design_names[0].to_sym => {
+            "views"=> {
+              views[design_names[0]].first.split("-").first => 
+                { "reduce"=>gen_str, "map"=>gen_str }
+            }
+          },
+          design_names[1].to_sym => {
+            "views"=> {
+              views[design_names[1]].first.split("-").first => 
+                { "reduce"=>gen_str, "map"=>gen_str }
+            }
+          }
+        }
+        
+        stub(TestView).fs_view(anything, /#{design_names[0]}/) { expected[design_names[0].to_sym] }
+        stub(TestView).fs_view(anything, /#{design_names[1]}/) { expected[design_names[1].to_sym] }
+        
+        assert_equal TestView.fs_design_docs(@db_name), expected
+      end
+    end
+    
+    context "with documents in either the filesystem, the database, or both" do
+      setup do
+        @path = gen_path
+        @db_name = gen_str
+        
+        def gen_view_file(type)
+          {
+            type => gen_str,
+            "sha1-#{type}" => gen_alphanum(40)
+          }
+        end
+        
+        def gen_view(name, elements)
+          view = {name => {}}
+          elements.each do |element|
+            view[name].merge!(gen_view_file(element.to_s))
+          end
+          view
+        end
+        
+        def gen_design_doc(id, views)
+          design_doc = {
+            "_id" => "_design/#{id}",
+            "views" => {}
+          }
+          
+          views.each do |view, types|
+            design_doc["views"].merge!(gen_view(view, types))
+          end
+          design_doc
+        end
+        
+        def gen_db_hash(seed=rand(5))
+          design_docs = {}
+          types = [:map, :reduce]
+          (0..seed).each do
+            views = {}
+            (0..rand(seed)).each do
+              views.merge!(gen_str => types[0, rand(types.length) + 1])
+            end
+            design_name = gen_str
+            design_docs.merge!(design_name.to_sym => gen_design_doc(design_name, views))
+          end
+          design_docs
+        end
+      end
+      
+      should "delete a document from the database when the same document is found on the filesystem with no views" do
+        databases = [ gen_str ]
+        mock(TestView).fs_database_names { databases }
+        db = Object.new
+        stub(TestView).database! { db }
+        fs_db = gen_db_hash(1)
+        remote_db = fs_db.clone
+        remote_db.values.each { |doc| doc.merge!("_rev" => gen_num) }
+        fs_db[fs_db.keys.first]["views"] = {}
+        
+        mock(TestView).fs_design_docs(anything) { fs_db }
+        mock(TestView).db_design_docs(anything) { remote_db }
+
+        mock(db).delete_doc(anything) {}
+        stub(db).save_doc {}
+        
+        TestView.push(true)
+      end
+      
+      should "create an empty remote db if an empty db folder is found in the file system" do
+        db = Object.new
+        mock(TestView).fs_database_names { [gen_str] }
+        mock(TestView).database!(anything) { db }
+        
+        fs_single_doc_name = gen_str
+        fs_db = {
+          fs_single_doc_name.to_sym => {
+            "_id" => "_design/#{fs_single_doc_name}", 
+            "views" => {}}
+        }
+        remote_db = gen_db_hash(2)
+        remote_db.values.each { |doc| doc.merge!("_rev" => gen_num) }
+        mock(TestView).fs_design_docs(anything) { fs_db }
+        mock(TestView).db_design_docs(anything) { remote_db }
+        dont_allow(db).delete_doc(anything) {}
+        dont_allow(db).save_doc(anything) {}
+        
+        TestView.push(true)
+      end
+      
+      should "not update documents on the server if both file system and server documents are identical" do
+        db = Object.new
+        mock(TestView).fs_database_names { [gen_str] }
+        mock(TestView).database!(anything) { db }
+        
+        fs_db = gen_db_hash(1)
+        remote_db = fs_db.clone
+        remote_db.values.each { |doc| doc.merge!("_rev" => gen_num) }
+        
+        mock(TestView).fs_design_docs(anything) { fs_db }
+        mock(TestView).db_design_docs(anything) { remote_db }
+        dont_allow(db).delete_doc(anything) {}
+        dont_allow(db).save_doc(anything) {}
+        
+        TestView.push(true)
+      end
+      
+      should "properly added all new documents seen on the file system to the remote system." do
+        db = Object.new
+        mock(TestView).fs_database_names { [gen_str] }
+        mock(TestView).database!(anything) { db }
+        
+        fs_db = gen_db_hash(2)
+        remote_db = gen_db_hash(2)
+        remote_db.values.each { |doc| doc.merge!("_rev" => gen_num) }
+        
+        mock(TestView).fs_design_docs(anything) { fs_db }
+        mock(TestView).db_design_docs(anything) { remote_db }
+        dont_allow(db).delete_doc(anything) {}
+        mock(db).save_doc(anything).times(fs_db.length) {}
+        
+        TestView.push(true)
+      end
+    end
+    
+    should "properly read fs view, create a remote database\
+        if necessary, and copy all the local views to the remote site (database)" do
+      stub(TestView).path { "#{File.dirname(__FILE__)}/../../test/integration" }
+      #TODO: Complete this integration test.
+    end
+  end
+end

data/test/unit/property_test.rb

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../lib/couch_tomato.rb'
+
+class PropertyTes < Test::Unit::TestCase
+  context "A Model that will persist data using CouchTomato" do
+    setup do
+      unload_const('Comment')
+      ::Comment = create_const
+      Comment.class_eval do
+        include CouchTomato::Persistence
+      end
+    end
+
+    should "raise an exception if native JSON data types are assigned to the properties" do
+      [Float, String, Integer, Array, Hash, Fixnum].each do |klass|
+        assert_raise RuntimeError do
+          Comment.class_eval do
+            property :title, :type => klass
+          end
+        end
+      end
+    end
+
+    should "raise an exception if an empty array is used as a property's type" do
+      assert_raise RuntimeError do
+        Comment.class_eval do
+          property :title, :type => []
+        end
+      end
+    end
+
+    should "return the names of its properties using property_names" do
+      Comment.class_eval do
+        property :title
+        property :commenter
+        property :email
+      end
+      assert_equal Comment.property_names, [:created_at, :updated_at, :title, :commenter, :email]
+    end
+
+    should "respond to property name attribute accessor methods" do
+      Comment.class_eval do
+        property :title
+      end
+
+      @comment = Comment.new
+
+      assert  @comment.respond_to?(:title)
+      assert  @comment.respond_to?(:title=)
+    end
+
+    should "mark as invalid a property which requires to have a value and has none" do
+      Comment.class_eval do
+        property :title
+        validates_presence_of :title
+      end
+
+      @comment = Comment.new
+
+      assert_equal @comment.valid?, false
+
+      @comment.title = "Title"
+
+      assert_equal @comment.valid?, true
+    end
+
+    should "call the validate callbacks when required" do
+      Comment.class_eval do
+        property :title
+        validates_presence_of :title
+      end
+
+      @comment = Comment.new :title => "My Title"
+
+      # stub(@comment).valid?{true}
+      mock(@comment).run_callbacks(:before_validation)
+
+      @comment.valid?
+    end
+
+    should "return true if a property is set" do
+      Comment.class_eval do
+        property :title
+      end
+
+      @comment = Comment.new
+
+      assert_equal @comment.title?, false
+
+      @comment.title = "Title"
+
+      assert_equal @comment.title?, true
+    end
+
+    context "and has callback methods defined" do
+      setup do
+        Comment.class_eval do
+            property :title
+
+            before_create :do_before
+            after_create  :do_after
+
+            attr_reader :count_var
+
+            def do_before
+              @count_var = 0
+              @count_var +=3
+            end
+
+            def do_after
+              @count_var +=2
+            end
+
+        end
+
+        unload_const('TestDb')
+        ::TestDb = create_const(CouchTomato::Database)
+        TestDb.couchrest_db = Object.new
+
+        @document = Comment.new :title => "My Title"
+
+        stub(@document).valid?{true}
+
+        stub(TestDb.database).save_doc{{'rev' => '1', 'id' => '123'}}
+      end
+
+
+      should "support single callbacks" do
+        stub(@document).new?{true}
+        stub(@document).dirty?{true}
+
+        TestDb.save_doc @document
+
+        assert_equal @document.count_var, 5
+      end
+
+      should "support multiple callbacks" do
+        stub(@document).new?{false}
+        stub(@document).dirty?{true}
+
+        Comment.class_eval do
+            before_update :do_before, :do_after
+            after_update  :do_after
+        end
+
+        TestDb.save_doc @document
+
+        assert_equal @document.count_var, 7
+      end
+    end # context has callbacks defined
+
+    context "and wants to delete (destroy) a particular document" do
+      setup do
+        unload_const('TestDb')
+        ::TestDb = create_const(CouchTomato::Database)
+        TestDb.couchrest_db = Object.new
+
+        @document = Comment.new
+        @document._deleted = false
+        @document._id = '123'
+        @document._rev = '456'
+        stub(@document).to_hash{1}
+        stub(TestDb.couchrest_db).delete_doc(@document.to_hash) {1}
+        mock(@document).run_callbacks(:before_destroy)
+        mock(@document).run_callbacks(:after_destroy)
+      end
+
+      should "call the destroy related callbacks" do
+        TestDb.destroy_doc(@document)
+      end
+
+      should "mark the document as deleted" do
+        TestDb.destroy_doc(@document)
+
+        assert_equal true, @document._deleted
+      end
+
+      should "make the document id nil" do
+        TestDb.destroy_doc(@document)
+
+        assert_equal nil, @document.id
+      end
+
+      should "make the document revision nil" do
+        TestDb.destroy_doc(@document)
+
+        assert_equal nil, @document._rev
+      end
+    end
+
+  end #context a model that will persist data
+
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: couch_tomato
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Plastic Trophy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-18 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: validatable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: couchrest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.24"
+    version: 
+description: Ruby persistence layer for CouchDB, inspired by and forked from Couch Potato
+email: dev@plastictrophy.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- MIT-LICENSE.txt
+- README.md
+- init.rb
+- lib/core_ext/date.rb
+- lib/core_ext/duplicable.rb
+- lib/core_ext/extract_options.rb
+- lib/core_ext/inheritable_attributes.rb
+- lib/core_ext/object.rb
+- lib/core_ext/string.rb
+- lib/core_ext/symbol.rb
+- lib/core_ext/time.rb
+- lib/couch_tomato.rb
+- lib/couch_tomato/database.rb
+- lib/couch_tomato/js_view_source.rb
+- lib/couch_tomato/migration.rb
+- lib/couch_tomato/migrator.rb
+- lib/couch_tomato/persistence.rb
+- lib/couch_tomato/persistence/base.rb
+- lib/couch_tomato/persistence/belongs_to_property.rb
+- lib/couch_tomato/persistence/callbacks.rb
+- lib/couch_tomato/persistence/dirty_attributes.rb
+- lib/couch_tomato/persistence/json.rb
+- lib/couch_tomato/persistence/magic_timestamps.rb
+- lib/couch_tomato/persistence/properties.rb
+- lib/couch_tomato/persistence/simple_property.rb
+- lib/couch_tomato/persistence/validation.rb
+- lib/couch_tomato/replicator.rb
+- lib/tasks/couch_tomato.rake
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/plastictrophy/couch_tomato
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby persistence layer for CouchDB, inspired by and forked from Couch Potato
+test_files: 
+- spec/callbacks_spec.rb
+- spec/comment.rb
+- spec/create_spec.rb
+- spec/custom_view_spec.rb
+- spec/destroy_spec.rb
+- spec/fixtures/address.rb
+- spec/fixtures/person.rb
+- spec/property_spec.rb
+- spec/spec_helper.rb
+- spec/unit/attributes_spec.rb
+- spec/unit/callbacks_spec.rb
+- spec/unit/create_spec.rb
+- spec/unit/customs_views_spec.rb
+- spec/unit/database_spec.rb
+- spec/unit/dirty_attributes_spec.rb
+- spec/unit/string_spec.rb
+- spec/unit/view_query_spec.rb
+- spec/update_spec.rb
+- test/test_helper.rb
+- test/unit/database_test.rb
+- test/unit/js_view_test.rb
+- test/unit/property_test.rb