couch_potato-rails2 0.5.6

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, 'as_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.as_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,136 @@
+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
+  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 Bowl
+            include CouchPotato::Persistence
+            property :price
+          end
+        end
+        it "should not dup BigDecimal" do
+
+          lambda {
+            Bowl.new :price => BigDecimal.new("5.23") 
+          }.should_not raise_error(TypeError)
+        end
+        
+        it "should return the old value" do
+          bowl = Bowl.new :price => BigDecimal.new("5.23") 
+          bowl.price = BigDecimal.new("2.23")
+          bowl.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.new.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 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/initialize_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class Document
+  include CouchPotato::Persistence
+  
+  property :title
+  property :content
+end
+
+describe "new" do
+  context "without arguments" do
+    subject { Document.new }
+
+    it { should be_a(Document) }
+    its(:title) { should be_nil }
+    its(:content) { should be_nil }
+  end
+
+  context "with an argument hash" do
+    subject { Document.new(:title => 'My Title') }
+
+    it { should be_a(Document) }
+    its(:title) { should == 'My Title'}
+    its(:content) { should be_nil }
+  end
+
+  context "yielding to a block" do
+    subject {
+      Document.new(:title => 'My Title') do |doc|
+        doc.content = 'My Content'
+      end
+    }
+
+    it { should be_a(Document) }
+    its(:title) { should == 'My Title'}
+    its(:content) { should == 'My Content'}
+  end
+end

data/spec/unit/json_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+class Drink
+  include CouchPotato::Persistence
+  
+  property :alcohol
+end
+
+describe CouchPotato::Persistence::Json do
+  context '#to_hash' do
+    it "should inject JSON.create_id into the hash representation of a persistent object" do
+      sake = Drink.new(:alcohol => "18%")
+      sake.to_hash[JSON.create_id].should eql("Drink")
+    end
+    
+    it "should not include _attachments if there are none" do
+      sake = Drink.new(:alcohol => "18%")
+      sake.to_hash.keys.should_not include('_attachments')
+    end
+    
+  end
+  
+  context '.json_create' do
+    it 'should assign the _document' do
+      sake = Drink.json_create({"alcohol" => "18%"})
+      sake._document.should == {"alcohol" => "18%"}
+    end
+  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.ruby_class && doc.ruby_class == \'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.ruby_class && doc.ruby_class == \'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(RSpec::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(RSpec::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