couchrest_model 1.0.0 → 1.1.0.beta

data/spec/couchrest/designs_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+class DesignModel < CouchRest::Model::Base
+  
+end
+
+describe "Design" do
+
+  it "should accessable from model" do
+    DesignModel.respond_to?(:design).should be_true
+  end
+
+  describe "class methods" do
+
+    describe ".design" do
+      before :each do 
+        @mapper = mock('DesignMapper')
+        @mapper.stub!(:create_view_method)
+      end
+
+      it "should instantiate a new DesignMapper" do
+        CouchRest::Model::Designs::DesignMapper.should_receive(:new).with(DesignModel).and_return(@mapper)
+        @mapper.should_receive(:create_view_method).with(:all)
+        @mapper.should_receive(:instance_eval)
+        DesignModel.design() { }
+      end
+
+      it "should allow methods to be called in mapper" do
+        @mapper.should_receive(:foo)
+        CouchRest::Model::Designs::DesignMapper.stub!(:new).and_return(@mapper)
+        DesignModel.design { foo }
+      end
+
+      it "should request a design refresh" do
+        DesignModel.should_receive(:req_design_doc_refresh)
+        DesignModel.design() { }
+      end
+
+      it "should work even if a block is not provided" do
+        lambda { DesignModel.design }.should_not raise_error
+      end
+
+    end
+
+    describe "default_per_page" do
+      it "should return 25 default" do
+        DesignModel.default_per_page.should eql(25)
+      end
+    end
+
+    describe ".paginates_per" do
+      it "should set the default per page value" do
+        DesignModel.paginates_per(21)
+        DesignModel.default_per_page.should eql(21)
+      end
+    end
+  end
+
+  describe "DesignMapper" do
+    
+    before :all do
+      @klass = CouchRest::Model::Designs::DesignMapper
+    end
+
+    it "should initialize and set model" do
+      object = @klass.new(DesignModel)
+      object.send(:model).should eql(DesignModel)
+    end
+
+    describe "#view" do
+
+      before :each do
+        @object = @klass.new(DesignModel)
+      end
+
+      it "should call create method on view" do
+        CouchRest::Model::Designs::View.should_receive(:create).with(DesignModel, 'test', {})
+        @object.view('test')
+      end
+
+      it "should create a method on parent model" do
+        CouchRest::Model::Designs::View.stub!(:create)
+        @object.view('test_view')
+        DesignModel.should respond_to(:test_view)
+      end
+
+      it "should create a method for view instance" do
+        CouchRest::Model::Designs::View.stub!(:create)
+        @object.should_receive(:create_view_method).with('test')
+        @object.view('test')
+      end
+
+    end
+
+    describe "#create_view_method" do
+      before :each do
+        @object = @klass.new(DesignModel)
+      end
+
+      it "should create a method that returns view instance" do
+        CouchRest::Model::Designs::View.should_receive(:new).with(DesignModel, {}, 'test_view').and_return(nil)
+        @object.create_view_method('test_view')
+        DesignModel.test_view
+      end
+
+    end
+
+  end
+
+end

data/spec/couchrest/persistence_spec.rb

@@ -15,17 +15,17 @@ describe "Model Persistence" do
   describe "creating a new document from database" do
 
     it "should instantialize" do
-      doc = Article.create_from_database({'_id' => 'testitem1', '_rev' => 123, 'couchrest-type' => 'Article', 'name' => 'my test'})
+      doc = Article.build_from_database({'_id' => 'testitem1', '_rev' => 123, 'couchrest-type' => 'Article', 'name' => 'my test'})
       doc.class.should eql(Article)
     end
 
     it "should instantialize of same class if no couchrest-type included from DB" do
-      doc = Article.create_from_database({'_id' => 'testitem1', '_rev' => 123, 'name' => 'my test'})
+      doc = Article.build_from_database({'_id' => 'testitem1', '_rev' => 123, 'name' => 'my test'})
       doc.class.should eql(Article)
     end
 
     it "should instantialize document of different type" do
-      doc = Article.create_from_database({'_id' => 'testitem2', '_rev' => 123, Article.model_type_key => 'WithTemplateAndUniqueID', 'name' => 'my test'})
+      doc = Article.build_from_database({'_id' => 'testitem2', '_rev' => 123, Article.model_type_key => 'WithTemplateAndUniqueID', 'name' => 'my test'})
       doc.class.should eql(WithTemplateAndUniqueID)
     end
 
@@ -329,14 +329,14 @@ describe "Model Persistence" do
     
     describe "validation" do
       it "should run before_validation before validating" do
-        @doc.run_before_validate.should be_nil
+        @doc.run_before_validation.should be_nil
         @doc.should be_valid
-        @doc.run_before_validate.should be_true
+        @doc.run_before_validation.should be_true
       end
       it "should run after_validation after validating" do
-        @doc.run_after_validate.should be_nil
+        @doc.run_after_validation.should be_nil
         @doc.should be_valid
-        @doc.run_after_validate.should be_true
+        @doc.run_after_validation.should be_true
       end
     end
 
@@ -412,4 +412,33 @@ describe "Model Persistence" do
   end
 
 
+  describe "#reload" do
+    it "reloads defined attributes" do
+      i = Article.create!(:title => "Reload when changed")
+      i.title.should == "Reload when changed"
+
+      i.title = "..."
+      i.title.should == "..."
+
+      i.reload
+      i.title.should == "Reload when changed"
+    end
+
+    it "reloads defined attributes set to nil" do
+      i = Article.create!(:title => "Reload when nil")
+      i.title.should == "Reload when nil"
+
+      i.title = nil
+      i.title.should be_nil
+
+      i.reload
+      i.title.should == "Reload when nil"
+    end
+
+    it "returns self" do
+      i = Article.create!(:title => "Reload return self")
+      i.reload.should be(i)
+    end
+  end
+
 end

data/spec/couchrest/property_spec.rb

@@ -340,6 +340,11 @@ describe "Model properties" do
         @course.estimate.should eql(1232434123.323)
       end
 
+      it "should handle numbers with whitespace" do
+        @course.estimate = " 24.35 "
+        @course.estimate.should eql(24.35)
+      end
+
       [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
         it "does not typecast non-numeric value #{value.inspect}" do
           @course.estimate = value
@@ -426,6 +431,11 @@ describe "Model properties" do
         @course['hours'].should eql(-24)
       end
 
+      it "should handle numbers with whitespace" do
+        @course.hours = " 24 "
+        @course['hours'].should eql(24)
+      end
+
       [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
         it "does not typecast non-numeric value #{value.inspect}" do
           @course.hours = value
@@ -511,6 +521,11 @@ describe "Model properties" do
         @course['profit'].should eql(BigDecimal('-24.35'))
       end
 
+      it "should handle numbers with whitespace" do
+        @course.profit = " 24.35 "
+        @course['profit'].should eql(BigDecimal('24.35'))
+      end
+
       [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
         it "does not typecast non-numeric value #{value.inspect}" do
           @course.profit = value

data/spec/couchrest/proxyable_spec.rb

@@ -0,0 +1,329 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+require File.join(FIXTURE_PATH, 'more', 'cat')
+
+class DummyProxyable < CouchRest::Model::Base
+  def proxy_database
+    'db' # Do not use this!
+  end
+end
+
+class ProxyKitten < CouchRest::Model::Base
+end
+
+describe "Proxyable" do
+
+  it "should provide #model_proxy method" do
+    DummyProxyable.new.should respond_to(:model_proxy)
+  end
+
+  describe "class methods" do
+
+    describe ".proxy_for" do
+
+      it "should be provided" do
+        DummyProxyable.should respond_to(:proxy_for)
+      end
+
+      it "should create a new method" do
+        DummyProxyable.stub!(:method_defined?).and_return(true)
+        DummyProxyable.proxy_for(:cats)
+        DummyProxyable.new.should respond_to(:cats)
+      end
+
+      describe "generated method" do
+        it "should call ModelProxy" do
+          DummyProxyable.proxy_for(:cats)
+          @obj = DummyProxyable.new
+          CouchRest::Model::Proxyable::ModelProxy.should_receive(:new).with(Cat, @obj, 'dummy_proxyable', 'db').and_return(true)
+          @obj.should_receive('proxy_database').and_return('db')
+          @obj.should_receive(:respond_to?).with('proxy_database').and_return(true)
+          @obj.cats
+        end
+
+        it "should call class on root namespace" do
+          class ::Document < CouchRest::Model::Base
+            def self.foo; puts 'bar'; end
+          end
+          DummyProxyable.proxy_for(:documents)
+          @obj = DummyProxyable.new
+          CouchRest::Model::Proxyable::ModelProxy.should_receive(:new).with(::Document, @obj, 'dummy_proxyable', 'db').and_return(true)
+          @obj.should_receive('proxy_database').and_return('db')
+          @obj.should_receive(:respond_to?).with('proxy_database').and_return(true)
+          @obj.documents
+        end
+
+        it "should raise an error if the database method is missing" do
+          DummyProxyable.proxy_for(:cats)
+          @obj = DummyProxyable.new
+          @obj.should_receive(:respond_to?).with('proxy_database').and_return(false)
+          lambda { @obj.cats }.should raise_error(StandardError, "Missing #proxy_database method for proxy")
+        end
+
+        it "should raise an error if custom database method missing" do
+          DummyProxyable.proxy_for(:proxy_kittens, :database_method => "foobardom")
+          @obj = DummyProxyable.new
+          lambda { @obj.proxy_kittens }.should raise_error(StandardError, "Missing #foobardom method for proxy")
+        end
+
+
+      end
+
+    end
+
+    describe ".proxied_by" do
+      it "should be provided" do
+        DummyProxyable.should respond_to(:proxied_by)
+      end
+
+      it "should add an attribute accessor" do
+        DummyProxyable.proxied_by(:foobar)
+        DummyProxyable.new.should respond_to(:foobar)
+      end
+
+      it "should raise an error if model name pre-defined" do
+        lambda { DummyProxyable.proxied_by(:object_id) }.should raise_error
+      end
+    end
+
+  end
+
+  describe "ModelProxy" do
+    
+    before :all do
+      @klass = CouchRest::Model::Proxyable::ModelProxy
+    end
+
+    it "should initialize and set variables" do
+      @obj = @klass.new(Cat, 'owner', 'owner_name', 'database')
+      @obj.model.should eql(Cat)
+      @obj.owner.should eql('owner')
+      @obj.owner_name.should eql('owner_name')
+      @obj.database.should eql('database')
+    end
+
+    describe "instance" do
+
+      before :each do
+        @obj = @klass.new(Cat, 'owner', 'owner_name', 'database')
+      end
+
+      it "should proxy new call" do
+        Cat.should_receive(:new).and_return({})
+        @obj.should_receive(:proxy_update).and_return(true)
+        @obj.new
+      end
+
+      it "should proxy build_from_database" do
+        Cat.should_receive(:build_from_database).and_return({})
+        @obj.should_receive(:proxy_update).with({}).and_return(true)
+        @obj.build_from_database
+      end
+
+      describe "#method_missing" do
+        it "should return design view object" do
+          m = "by_some_property"
+          inst = mock('DesignView')
+          inst.stub!(:proxy).and_return(inst)
+          @obj.should_receive(:has_view?).with(m).and_return(true)
+          Cat.should_receive(:respond_to?).with(m).and_return(true)
+          Cat.should_receive(:send).with(m).and_return(inst)
+          @obj.method_missing(m).should eql(inst)
+        end
+
+        it "should call view if necessary" do
+          m = "by_some_property"
+          @obj.should_receive(:has_view?).with(m).and_return(true)
+          Cat.should_receive(:respond_to?).with(m).and_return(false)
+          @obj.should_receive(:view).with(m, {}).and_return('view')
+          @obj.method_missing(m).should eql('view')
+        end
+
+        it "should provide wrapper for #first_from_view" do
+          m = "find_by_some_property"
+          view = "by_some_property"
+          @obj.should_receive(:has_view?).with(m).and_return(false)
+          @obj.should_receive(:has_view?).with(view).and_return(true)
+          @obj.should_receive(:first_from_view).with(view).and_return('view')
+          @obj.method_missing(m).should eql('view')    
+        end
+
+      end
+
+      it "should proxy #all" do
+        Cat.should_receive(:all).with({:database => 'database'})
+        @obj.should_receive(:proxy_update_all)
+        @obj.all
+      end
+  
+      it "should proxy #count" do
+        Cat.should_receive(:all).with({:database => 'database', :raw => true, :limit => 0}).and_return({'total_rows' => 3})
+        @obj.count.should eql(3)
+      end
+
+      it "should proxy #first" do
+        Cat.should_receive(:first).with({:database => 'database'})
+        @obj.should_receive(:proxy_update)
+        @obj.first
+      end
+
+      it "should proxy #last" do
+        Cat.should_receive(:last).with({:database => 'database'})
+        @obj.should_receive(:proxy_update)
+        @obj.last
+      end
+
+      it "should proxy #get" do
+        Cat.should_receive(:get).with(32, 'database')
+        @obj.should_receive(:proxy_update)
+        @obj.get(32)
+      end
+      it "should proxy #find" do
+        Cat.should_receive(:get).with(32, 'database')
+        @obj.should_receive(:proxy_update)
+        @obj.find(32)
+      end
+
+      it "should proxy #has_view?" do
+        Cat.should_receive(:has_view?).with('view').and_return(false)
+        @obj.has_view?('view')
+      end
+
+      it "should proxy #view_by" do
+        Cat.should_receive(:view_by).with('name').and_return(false)
+        @obj.view_by('name')
+      end
+
+      it "should proxy #view" do
+        Cat.should_receive(:view).with('view', {:database => 'database'})
+        @obj.should_receive(:proxy_update_all)
+        @obj.view('view')
+      end
+
+      it "should proxy #first_from_view" do
+        Cat.should_receive(:first_from_view).with('view', {:database => 'database'})
+        @obj.should_receive(:proxy_update)
+        @obj.first_from_view('view')
+      end
+
+      it "should proxy design_doc" do
+        Cat.should_receive(:design_doc)
+        @obj.design_doc
+      end
+
+      describe "#refresh_design_doc" do
+        it "should be proxied without database arg" do
+          Cat.should_receive(:refresh_design_doc).with('database')
+          @obj.refresh_design_doc
+        end
+        it "should be proxied with database arg" do
+          Cat.should_receive(:refresh_design_doc).with('db')
+          @obj.refresh_design_doc('db')
+        end
+      end
+
+      describe "#save_design_doc" do
+        it "should be proxied without args" do
+          Cat.should_receive(:save_design_doc).with('database')
+          @obj.save_design_doc
+        end
+
+        it "should be proxied with database arg" do
+          Cat.should_receive(:save_design_doc).with('db')
+          @obj.save_design_doc('db')
+        end
+      end
+
+      
+
+      ### Updating methods
+
+      describe "#proxy_update" do
+        it "should set returned doc fields" do
+          doc = mock(:Document)
+          doc.should_receive(:respond_to?).with(:database=).and_return(true)
+          doc.should_receive(:database=).with('database')
+          doc.should_receive(:respond_to?).with(:model_proxy=).and_return(true)
+          doc.should_receive(:model_proxy=).with(@obj)
+          doc.should_receive(:respond_to?).with('owner_name=').and_return(true)
+          doc.should_receive(:send).with('owner_name=', 'owner')
+          @obj.send(:proxy_update, doc).should eql(doc)
+        end
+
+        it "should not fail if some fields missing" do
+          doc = mock(:Document)
+          doc.should_receive(:respond_to?).with(:database=).and_return(true)
+          doc.should_receive(:database=).with('database')
+          doc.should_receive(:respond_to?).with(:model_proxy=).and_return(false)
+          doc.should_not_receive(:model_proxy=)
+          doc.should_receive(:respond_to?).with('owner_name=').and_return(false)
+          doc.should_not_receive(:owner_name=)
+          @obj.send(:proxy_update, doc).should eql(doc)
+        end
+
+        it "should pass nil straight through without errors" do
+          lambda { @obj.send(:proxy_update, nil).should eql(nil) }.should_not raise_error
+        end
+      end
+
+      it "#proxy_update_all should update array of docs" do
+        docs = [{}, {}]
+        @obj.should_receive(:proxy_update).twice.with({})
+        @obj.send(:proxy_update_all, docs)
+      end
+
+    end
+
+  end
+
+  describe "scenarios" do
+
+    before :all do
+      class ProxyableCompany < CouchRest::Model::Base
+        use_database DB
+        property :slug
+        proxy_for :proxyable_invoices
+        def proxy_database
+          @db ||= TEST_SERVER.database!(TESTDB + "-#{slug}")
+        end
+      end
+
+      class ProxyableInvoice < CouchRest::Model::Base
+        property :client
+        property :total
+        proxied_by :proxyable_company
+        validates_uniqueness_of :client
+        design do
+          view :by_total
+        end
+      end
+
+
+      @company = ProxyableCompany.create(:slug => 'samco')
+    end
+
+    it "should create the new database" do
+      @company.proxyable_invoices.all.should be_empty
+      TEST_SERVER.databases.find{|db| db =~ /#{TESTDB}-samco/}.should_not be_nil
+    end
+
+    it "should allow creation of new entries" do
+      inv = @company.proxyable_invoices.new(:client => "Lorena", :total => 35)
+      inv.save.should be_true
+      @company.proxyable_invoices.count.should eql(1)
+      @company.proxyable_invoices.first.client.should eql("Lorena")
+    end
+
+    it "should validate uniqueness" do
+      inv = @company.proxyable_invoices.new(:client => "Lorena", :total => 40)
+      inv.save.should be_false
+    end
+
+    it "should allow design views" do
+      item = @company.proxyable_invoices.by_total.key(35).first
+      item.client.should eql('Lorena')
+    end
+
+  end
+
+end

data/spec/couchrest/{validations.rb → validations_spec.rb}

@@ -25,7 +25,7 @@ describe "Validations" do
     it "should not validate a non-unique document" do
       @obj = WithUniqueValidation.create(:title => 'title 1')
       @obj.should_not be_valid
-      @obj.errors[:title].should eql(['is already taken'])
+      @obj.errors[:title].should == ["has already been taken"]
     end
 
     it "should save already created document" do
@@ -57,7 +57,6 @@ describe "Validations" do
         @obj.class.should_receive('view').and_return({'rows' => [ ]})
         @obj.valid?
       end
-
     end
  
     context "with a proxy parameter" do
@@ -76,7 +75,6 @@ describe "Validations" do
         proxy.should_receive('view').and_return({'rows' => [ ]})
         @obj.valid?
       end
-
     end