davber_couch_potato 0.3.0

data/spec/unit/database_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+class DbTestUser
+end
+
+# namespaced model
+module Parent
+  class Child
+    include CouchPotato::Persistence
+  end
+end
+
+describe CouchPotato::Database, 'new' do
+  it "should raise an exception if the database doesn't exist" do
+    lambda {
+      CouchPotato::Database.new CouchRest.database('couch_potato_invalid')
+    }.should raise_error('Database \'couch_potato_invalid\' does not exist.')
+  end
+end
+
+describe CouchPotato::Database, 'full_url_to_database' do
+  before(:all) do
+    @database_url = CouchPotato::Config.database_name
+  end
+
+  after(:all) do
+    CouchPotato::Config.database_name = @database_url
+  end
+  
+  it "should return the full URL when it starts with https" do
+    CouchPotato::Config.database_name = "https://example.com/database"
+    CouchPotato.full_url_to_database.should == 'https://example.com/database'
+  end
+  
+  it "should return the full URL when it starts with http" do
+    CouchPotato::Config.database_name = "http://example.com/database"
+    CouchPotato.full_url_to_database.should == 'http://example.com/database'
+  end
+  
+  it "should use localhost when no protocol was specified" do
+    CouchPotato::Config.database_name = "database"
+    CouchPotato.full_url_to_database.should == 'http://127.0.0.1:5984/database'
+  end
+end
+
+describe CouchPotato::Database, 'load' do
+  it "should raise an exception if nil given" do
+    db = CouchPotato::Database.new(stub('couchrest db', :info => nil))
+    lambda {
+      db.load nil
+    }.should raise_error("Can't load a document without an id (got nil)")
+  end
+
+  it "should set itself on the model" do
+    user = mock 'user'
+    DbTestUser.stub!(:new).and_return(user)
+    db = CouchPotato::Database.new(stub('couchrest db', :info => nil, :get => DbTestUser.json_create({JSON.create_id => 'DbTestUser'})))
+    user.should_receive(:database=).with(db)
+    db.load '1'
+  end
+
+  it "should load namespaced models" do
+    db = CouchPotato::Database.new(stub('couchrest db', :info => nil, :get => Parent::Child.json_create({JSON.create_id => 'Parent::Child'})))
+    db.load('1').class.should == Parent::Child
+  end
+  
+end
+
+describe CouchPotato::Database, 'save_document' do
+  before(:each) do
+    @db = CouchPotato::Database.new(stub('couchrest db').as_null_object)
+  end
+  
+  it "should set itself on the model for a new object before doing anything else" do
+    @db.stub(:valid_document?).and_return false
+    user = stub('user', :new? => true).as_null_object
+    user.should_receive(:database=).with(@db)
+    @db.save_document user
+  end
+
+  class Category
+    include CouchPotato::Persistence
+    property :name
+    validates_presence_of :name
+  end
+  
+  it "should return false when creating a new document and the validations failed" do
+    CouchPotato.database.save_document(Category.new).should == false
+  end
+  
+  it "should return false when saving an existing document and the validations failed" do
+    category = Category.new(:name => "pizza")
+    CouchPotato.database.save_document(category).should == true
+    category.name = nil
+    CouchPotato.database.save_document(category).should == false
+  end
+  
+  describe "when creating with validate options" do
+    it "should not run the validations when saved with false" do
+      category = Category.new
+      @db.save_document(category, false)
+      category.new?.should == false
+    end
+
+    it "should run the validations when saved with true" do
+      category = Category.new
+      @db.save_document(category, true)
+      category.new?.should == true
+    end
+
+    it "should run the validations when saved with default" do
+      category = Category.new
+      @db.save_document(category)
+      category.new?.should == true
+    end
+  end
+
+  describe "when updating with validate options" do
+    it "should not run the validations when saved with false" do
+      category = Category.new(:name => 'food')
+      @db.save_document(category)
+      category.new?.should == false
+      category.name = nil
+      @db.save_document(category, false)
+      category.dirty?.should == false
+    end
+
+    it "should run the validations when saved with true" do
+      category = Category.new(:name => "food")
+      @db.save_document(category)
+      category.new?.should == false
+      category.name = nil
+      @db.save_document(category, true)
+      category.dirty?.should == true
+      category.valid?.should == false
+    end
+
+    it "should run the validations when saved with default" do
+      category = Category.new(:name => "food")
+      @db.save_document(category)
+      category.new?.should == false
+      category.name = nil
+      @db.save_document(category)
+      category.dirty?.should == true
+    end
+  end
+  
+  describe "when saving documents with errors set in callbacks" do
+    class Vulcan
+      include CouchPotato::Persistence
+      before_validation_on_create :set_errors
+      before_validation_on_update :set_errors
+      
+      property :name
+      validates_presence_of :name
+      
+      def set_errors
+        errors.add(:validation, "failed")
+      end
+    end
+    
+    it "should keep errors added in before_validation_on_* callbacks when creating a new object" do
+      spock = Vulcan.new(:name => 'spock')
+      @db.save_document(spock)
+      spock.errors.on(:validation).should == 'failed'
+    end
+    
+    it "should keep errors added in before_validation_on_* callbacks when creating a new object" do
+      spock = Vulcan.new(:name => 'spock')
+      @db.save_document(spock, false)
+      spock.new?.should == false
+      spock.name = "spock's father"
+      @db.save_document(spock)
+      spock.errors.on(:validation).should == 'failed'
+    end
+    
+    it "should keep errors generated from normal validations together with errors set in normal validations" do
+      spock = Vulcan.new
+      @db.save_document(spock)
+      spock.errors.on(:validation).should == 'failed'
+      spock.errors.on(:name).should =~ /can't be (empty|blank)/
+    end
+    
+    it "should clear errors on subsequent, valid saves when creating" do
+      spock = Vulcan.new
+      @db.save_document(spock)
+      
+      spock.name = 'Spock'
+      @db.save_document(spock)
+      spock.errors.on(:name).should == nil
+    end
+    
+    it "should clear errors on subsequent, valid saves when updating" do
+      spock = Vulcan.new(:name => 'spock')
+      @db.save_document(spock, false)
+      
+      spock.name = nil
+      @db.save_document(spock)
+      spock.errors.on(:name).should =~ /can't be (empty|blank)/
+      
+      spock.name = 'Spock'
+      @db.save_document(spock)
+      spock.errors.on(:name).should == nil
+    end
+    
+  end
+end
+
+describe CouchPotato::Database, 'view' do
+  before(:each) do
+    @couchrest_db = stub('couchrest db').as_null_object
+    @db = CouchPotato::Database.new(@couchrest_db)
+    @result = stub('result')
+    @spec = stub('view spec', :process_results => [@result]).as_null_object
+    CouchPotato::View::ViewQuery.stub(:new => stub('view query', :query_view! => {'rows' => [@result]}))
+  end
+  
+  it "should initialze a view query with map/reduce/list funtions" do
+    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+      :map_function => '<map_code>', :reduce_function => '<reduce_code>',
+      :list_name => 'my_list', :list_function => '<list_code>')
+    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      @couchrest_db,
+      'design_doc',
+      {'my_view' => {
+        :map => '<map_code>',
+        :reduce => '<reduce_code>'
+      }},
+      {'my_list' => '<list_code>'})
+    @db.view(@spec)
+  end
+  
+  it "should initialze a view query with only map/reduce functions" do
+    @spec.stub(:design_document => 'design_doc', :view_name => 'my_view',
+      :map_function => '<map_code>', :reduce_function => '<reduce_code>',
+      :list_name => nil, :list_function => nil)
+    CouchPotato::View::ViewQuery.should_receive(:new).with(
+      @couchrest_db,
+      'design_doc',
+      {'my_view' => {
+        :map => '<map_code>',
+        :reduce => '<reduce_code>'
+      }}, nil)
+    @db.view(@spec)
+  end
+  
+  it "should set itself on returned results that have an accessor" do
+    @result.stub(:respond_to?).with(:database=).and_return(true)
+    @result.should_receive(:database=).with(@db)
+    @db.view(@spec)
+  end
+  
+  it "should not set itself on returned results that don't have an accessor" do
+    @result.stub(:respond_to?).with(:database=).and_return(false)
+    @result.should_not_receive(:database=).with(@db)
+    @db.view(@spec)
+  end
+  
+  it "should not try to set itself on result sets that are not collections" do
+    lambda {
+      @spec.stub(:process_results => 1)
+    }.should_not raise_error
+    
+    @db.view(@spec)
+  end
+end

data/spec/unit/date_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Date, 'to_json' do
+  it "should format the date in a way that i can use it for sorting in couchdb" do
+    date = Date.parse('2009-01-01')
+    date.to_json.should == "\"2009/01/01\""
+  end
+end
+
+describe Date, 'to_s(:json)' do
+  it "should format it in the same way as to_json does so i can use this to do queries over date attributes" do
+    date = Date.parse('2009-01-01')
+    date.to_s(:json).should == "2009/01/01"
+  end
+end
+
+describe Date, 'to_s' do
+  it "should leave the original to_s untouched" do
+    date = Date.parse('2009-01-01')
+    date.to_s.should == "2009-01-01"
+  end
+end

data/spec/unit/dirty_attributes_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+class Plate
+  include CouchPotato::Persistence
+  
+  property :food
+end
+
+describe 'dirty attribute tracking' do
+  before(:each) do
+    @couchrest_db = stub('database', :save_doc => {'id' => '1', 'rev' => '2'}, :info => nil)
+    @db = CouchPotato::Database.new(@couchrest_db)
+  end
+  
+  describe "save" do
+    it "should not save when nothing dirty" do
+      plate = Plate.new :food => 'sushi'
+      @db.save_document!(plate)
+      @couchrest_db.should_not_receive(:save_doc)
+      @db.save_document(plate)
+    end
+    
+    it "should return true when not dirty" do
+      plate = Plate.new :food => 'sushi'
+      @db.save_document!(plate)
+      @db.save_document(plate).should be_true
+    end
+    
+    it "should save when there are dirty attributes" do
+      plate = Plate.new :food => 'sushi'
+      @db.save_document!(plate)
+      plate.food = 'burger'
+      @couchrest_db.should_receive(:save_doc)
+      @db.save_document(plate)
+    end
+
+    it "should correctly track dirty hashes (deep clone)" do
+      plate = Plate.new :food => {:veggies => ['carrots', 'peas']}
+      @db.save_document(plate)
+      plate.food[:veggies] << 'beans'
+      @couchrest_db.should_receive(:save_doc)
+      @db.save_document(plate)
+    end
+
+    it "should correctly track dirty hashes (deep clone) after a save" do
+      plate = Plate.new :food => {:veggies => ['carrots', 'peas']}
+      @db.save_document(plate)
+      plate.food[:veggies] << 'beans'
+      @db.save_document(plate)
+      plate.food[:veggies] << 'cauliflower'
+      @couchrest_db.should_receive(:save_doc)
+      @db.save_document(plate)
+    end
+  end
+  
+  describe "newly created object" do
+    
+    before(:each) do
+      @plate = Plate.new :food => 'sushi'
+    end
+    
+    describe "access old values" do
+      it "should return the old value" do
+        @plate.food = 'burger'
+        @plate.food_was.should == 'sushi'
+      end
+      
+      describe "with type BigDecimal" do
+        before(:each) do
+          class ::Plate
+            property :price
+          end
+        end
+        it "should not dup BigDecimal" do
+
+          lambda {
+            Plate.new :price => BigDecimal.new("5.23") 
+          }.should_not raise_error(TypeError)
+        end
+        
+        it "should return the old value" do
+          plate = Plate.new :price => BigDecimal.new("5.23") 
+          plate.price = BigDecimal.new("2.23")
+          plate.price_was.should == 5.23
+        end
+        
+      end
+    end
+
+    describe "check for dirty" do
+      it "should return true if attribute changed" do
+        @plate.food = 'burger'
+        @plate.should be_food_changed
+      end
+
+      it "should return false if attribute not changed" do
+        @plate.should_not be_food_changed
+      end
+      
+      it "should return false if attribute forced not changed" do
+        @plate.food = 'burger'
+        @plate.food_not_changed
+        @plate.should_not be_food_changed
+      end
+      
+      it "should return true if forced dirty" do
+        @plate.is_dirty
+        @plate.should be_dirty
+      end
+    end
+  end
+  
+  describe "object loaded from database" do
+    before(:each) do
+      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil)
+      @plate = CouchPotato::Database.new(couchrest_db).load_document '1'
+    end
+    
+    describe "access old values" do
+      it "should return the old value" do
+        @plate.food = 'burger'
+        @plate.food_was.should == 'sushi'
+      end
+    end
+
+    describe "check for dirty" do
+      it "should return true if attribute changed" do
+        @plate.food = 'burger'
+        @plate.should be_food_changed
+      end
+      
+      it "should return true if array attribute changed" do
+        couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => ['sushi'], JSON.create_id => 'Plate'}), :info => nil)
+        plate = CouchPotato::Database.new(couchrest_db).load_document '1'
+        plate.food << 'burger'
+        plate.should be_food_changed
+      end
+
+      it "should return false if attribute not changed" do
+        @plate.should_not be_food_changed
+      end
+    end
+  end
+  
+  
+  describe "after save" do
+    it "should reset all attributes to not dirty" do
+      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {})
+      db = CouchPotato::Database.new(couchrest_db)
+      @plate = db.load_document '1'
+      @plate.food = 'burger'
+      db.save! @plate
+      @plate.should_not be_food_changed
+    end
+    
+    it "should reset a forced dirty state" do
+      couchrest_db = stub('database', :get => Plate.json_create({'_id' => '1', '_rev' => '2', 'food' => 'sushi', JSON.create_id => 'Plate'}), :info => nil, :save_doc => {'rev' =>  '3'})
+      db = CouchPotato::Database.new(couchrest_db)
+      @plate = db.load_document '1'
+      @plate.is_dirty
+      db.save! @plate
+      @plate.should_not be_dirty
+    end
+  end
+  
+end

data/spec/unit/json_create_id_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+class Drink
+  include CouchPotato::Persistence
+  
+  property :alcohol
+end
+
+describe "json module" do
+  it "should inject JSON.create_id into hash representation of a persistence object" do
+    sake = Drink.new(:alcohol => "18%")
+    sake.to_hash[JSON.create_id].should eql("Drink")
+  end
+end

data/spec/unit/lists_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe CouchPotato::View::Lists, '.list' do
+  it "should make the list function available via .lists" do
+    clazz = Class.new
+    clazz.send :include, CouchPotato::View::Lists
+    clazz.list 'my_list', '<list_code>'
+    
+    clazz.lists('my_list').should == '<list_code>'
+  end
+  
+  it "should make the list available to subclasses" do
+    clazz = Class.new
+    clazz.send :include, CouchPotato::View::Lists
+    clazz.list 'my_list', '<list_code>'
+    sub_clazz = Class.new clazz
+    
+    sub_clazz.lists('my_list').should == '<list_code>'
+  end
+end

data/spec/unit/model_view_spec_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe CouchPotato::View::ModelViewSpec, 'map_function' do
+  it "should include conditions" do
+    spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {:conditions => 'doc.closed = true'}, {}
+    spec.map_function.should include("if(doc.#{CouchPotato.type_field} && doc.#{CouchPotato.type_field} == 'Object' && (doc.closed = true))")
+  end
+  
+  it "should not include conditions when they are nil" do
+    spec = CouchPotato::View::ModelViewSpec.new Object, 'all', {}, {}
+    spec.map_function.should include("if(doc.#{CouchPotato.type_field} && doc.#{CouchPotato.type_field} == 'Object')")
+  end
+end

data/spec/unit/properties_view_spec_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'couch_potato/rspec'
+
+class Contract
+  include CouchPotato::Persistence
+  
+  property :date
+  property :terms
+  
+  view :by_date, :type => :properties, :key => :_id, :properties => [:date]
+end
+
+describe CouchPotato::View::PropertiesViewSpec do
+  it "should map the given properties" do
+    Contract.by_date.should map(
+      Contract.new(:date => '2010-01-01', :_id => '1')
+    ).to(['1', {"date" => "2010-01-01"}])
+  end
+  
+  it "should reduce to the number of documents" do
+    Contract.by_date.should reduce(
+      ['1', {"date" => "2010-01-01"}], ['2', {"date" => "2010-01-02"}]
+    ).to(2)
+  end
+  
+  it "should rereduce the number of documents" do
+    Contract.by_date.should rereduce(
+      nil, [12, 13]
+    ).to(25)
+  end
+end

data/spec/unit/rspec_matchers_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'couch_potato/rspec'
+
+describe CouchPotato::RSpec::MapToMatcher do
+  
+  describe "basic map function" do
+    before(:each) do
+      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length);}")
+    end
+
+    it "should pass if the given function emits the expected javascript" do
+      @view_spec.should map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2])
+    end
+
+    it "should not pass if the given function emits different javascript" do
+      @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 3])
+    end
+  end
+  
+  describe "functions emitting multiple times" do
+    before(:each) do
+      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, doc.tags.length); emit(doc.tags[0], doc.tags[1])};")
+    end
+    
+    it "should pass if the given function emits the expected javascript" do
+      @view_spec.should map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['person', 'male'])
+    end
+  
+    it "should return false if the given function emits different javascript" do
+      @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['male', 'person'])
+    end
+  end
+  
+  describe "failing specs" do
+    before(:each) do
+      @view_spec = stub(:map_function => "function(doc) {emit(doc.name, null)}")
+    end
+    
+    it "should have a nice error message for failing should" do
+      lambda {
+        @view_spec.should map({:name => 'bill'}).to(['linus', nil])
+      }.should raise_error('Expected to map to [["linus", nil]] but got [["bill", nil]].')
+    end
+    
+    it "should have a nice error message for failing should not" do
+      lambda {
+        @view_spec.should_not map({:name => 'bill'}).to(['bill', nil])
+      }.should raise_error('Expected not to map to [["bill", nil]] but did.')
+    end
+  end
+end
+
+describe CouchPotato::RSpec::ReduceToMatcher do
+  before(:each) do
+    @view_spec = stub(:reduce_function => "function(docs, keys, rereduce) {
+      if(rereduce) {
+        return(sum(keys) * 2);
+      } else {
+        return(sum(keys));
+      };
+    }")
+  end
+  
+  it "should pass if the given function return the expected javascript" do
+    @view_spec.should reduce([], [1, 2, 3]).to(6)
+  end
+  
+  it "should not pass if the given function returns different javascript" do
+    @view_spec.should_not reduce([], [1, 2, 3]).to(7)
+  end
+  
+  describe "rereduce" do
+    it "should pass if the given function return the expected javascript" do
+      @view_spec.should rereduce([], [1, 2, 3]).to(12)
+    end
+    
+    it "should not pass if the given function returns different javascript" do
+      @view_spec.should_not rereduce([], [1, 2, 3]).to(13)
+    end
+  end
+  
+  describe 'failing specs' do
+    
+    it "should have a nice error message for failing should" do
+      lambda {
+        @view_spec.should reduce([], [1, 2, 3]).to(7)
+      }.should raise_error('Expected to reduce to 7 but got 6.')
+    end
+    
+    it "should have a nice error message for failing should not" do
+      lambda {
+        @view_spec.should_not reduce([], [1, 2, 3]).to(6)
+      }.should raise_error('Expected not to reduce to 6 but did.')
+    end
+  end
+end
+
+describe CouchPotato::RSpec::ListAsMatcher do
+  before(:each) do
+    @view_spec = stub(:list_function => "function() {var row = getRow(); send(JSON.stringify([{text: row.text + ' world'}]));}")
+  end
+  
+  it "should pass if the function return the expected json" do
+    @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
+  end
+  
+  it "should not pass if the function does not return the expected json" do
+    @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
+  end
+  
+  describe "failing specs" do
+    it "should have a nice error message for failing should" do
+      lambda {
+        @view_spec.should list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
+      }.should raise_error('Expected to list as [{"text"=>"hello there"}] but got [{"text"=>"hello world"}].')
+    end
+    
+    it "should have a nice error message for failing should not" do
+      lambda {
+        @view_spec.should_not list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
+      }.should raise_error('Expected to not list as [{"text"=>"hello world"}] but did.')
+    end
+  end
+end

data/spec/unit/rspec_stub_db_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'couch_potato/rspec'
+
+class WithStubbedView
+  include CouchPotato::Persistence
+  
+  view :stubbed_view, :key => :x
+end
+
+describe "stubbing the db" do
+  it "should replace CouchPotato.database with a stub" do
+    stub_db
+    CouchPotato.database.should be_a(Spec::Mocks::Mock)
+  end
+  
+  it "should return the stub" do
+    db = stub_db
+    CouchPotato.database.should == db
+  end
+end
+
+describe "stubbing a view" do
+  before(:each) do
+    @db = stub_db
+    @db.stub_view(WithStubbedView, :stubbed_view).with('123').and_return([:result])
+  end
+  
+  it "should stub the view to return a stub" do
+    WithStubbedView.stubbed_view('123').should be_a(Spec::Mocks::Mock)
+  end
+  
+  it "should stub the database to return fake results when called with the stub" do
+    @db.view(WithStubbedView.stubbed_view('123')).should == [:result]
+  end
+end