couch_potato 0.7.1 → 1.0.0

data/lib/couch_potato/view/model_view_spec.rb

@@ -8,6 +8,8 @@ module CouchPotato
     #
     # in addition you can pass in conditions as a javascript string
     #   view :my_view_only_completed, :key => :name, :conditions => 'doc.completed = true'
+    # and also a results filter (the results will be run through the given proc):
+    #   view :my_view, :key => :name, :results_filter => lambda{|results| results.size}
     class ModelViewSpec < BaseViewSpec
       class ErlangGenerator
         def initialize(options, klass)
@@ -137,11 +139,14 @@ module CouchPotato
       end
 
       def process_results(results)
-        if count?
-          results['rows'].first.try(:[], 'value') || 0
-        else
-          results['rows'].map { |row| row['doc'] || row['id'] }
-        end
+        processed = if count?
+                      results['rows'].first.try(:[], 'value') || 0
+                    else
+                      results['rows'].map {|row|
+                        row['doc'] || (row['id'] unless view_parameters[:include_docs])
+                      }.compact
+                    end
+        super processed
       end
 
       private

data/lib/couch_potato/view/raw_view_spec.rb

@@ -12,14 +12,10 @@ module CouchPotato
       def map_function
         options[:map]
       end
-      
-      def process_results(results)
-        options[:results_filter] ? options[:results_filter].call(results) : results
-      end
-      
+
       def reduce_function
         options[:reduce]
       end
     end
   end
-end
+end

data/lib/couch_potato.rb

@@ -5,6 +5,7 @@ require 'json/add/core'
 require 'ostruct'
 
 JSON.create_id = 'ruby_class'
+CouchRest.decode_json_objects = true
 
 module CouchPotato
   Config = Struct.new(:database_name, :split_design_documents_per_view, :default_language).new

data/spec/default_property_spec.rb

@@ -6,6 +6,7 @@ class Test
   property :test, :default => 'Test value'
   property :complex, :default => [1, 2, 3]
   property :false_value, :default => false
+  property :proc, :default => Proc.new { 1 + 2 }
 end
 
 describe 'default properties' do
@@ -41,4 +42,9 @@ describe 'default properties' do
     t = Test.new
     t.false_value.should == false
   end
+
+  it "uses the return value of a Proc given as the default" do
+    t = Test.new
+    t.proc.should == 3
+  end
 end

data/spec/property_spec.rb

@@ -57,6 +57,14 @@ describe 'properties' do
     c.title.should == 3
   end
 
+  it "should persist a big decimal" do
+    require 'bigdecimal'
+    c = BigDecimalContainer.new :number => BigDecimal.new( '42.42' )
+    CouchPotato.database.save_document! c
+    c = CouchPotato.database.load_document c.id
+    c.number.should == BigDecimal.new( '42.42' )
+  end
+
   it "should persist a hash" do
     c = Comment.new :title => {'key' => 'value'}
     CouchPotato.database.save_document! c
@@ -68,7 +76,9 @@ describe 'properties' do
     c = Comment.new :title => value
     CouchPotato.database.save_document! c
     c = CouchPotato.database.load_document c.id
-    c.title.should == value
+    c.title.to_json.should == value.to_json
+    # no id provided in embedded object, need to check yourself for content equality
+    c.title.should_not == value
   end
 
   it "should persist a child class" do
@@ -109,7 +119,7 @@ describe 'properties' do
     p.ship_address = a
     CouchPotato.database.save_document! p
     p = CouchPotato.database.load_document p.id
-    p.ship_address.should === a
+    p.ship_address.to_json.should === a.to_json
   end
 
   it "should persist null for a null " do
@@ -223,7 +233,7 @@ describe 'properties' do
       w = Watch.new :custom_address => [address]
       CouchPotato.database.save_document! w
       w = CouchPotato.database.load_document w.id
-      w.custom_address.should eql([address])
+      w.custom_address.to_json.should eql([address].to_json)
     end
 
     it "should handle nil values" do

data/spec/reload_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CouchPotato::Persistence, '#reload' do
+  let(:db) { CouchPotato.database }
+
+  it 'returns a new instance from the database' do
+    comment = Comment.new title: 'hello'
+    db.save! comment
+
+    reloaded = comment.reload
+    expect(reloaded.object_id).to_not eql(comment.object_id)
+    expect(reloaded).to eql(comment)
+  end
+end

data/spec/spec_helper.rb

@@ -31,6 +31,12 @@ class Comment
   property :title
 end
 
+class BigDecimalContainer
+  include CouchPotato::Persistence
+
+  property :number, :type => BigDecimal
+end
+
 def recreate_db
   CouchPotato.couchrest_database.recreate!
 end

data/spec/unit/base_view_spec_spec.rb

@@ -11,13 +11,13 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       CouchPotato::Config.default_language = @default_language
     end
 
-    it "should raise an error when passing invalid view parameters" do
+    it "raises an error when passing invalid view parameters" do
       lambda {
         CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {:start_key => '1'}
       }.should raise_error(ArgumentError, "invalid view parameter: start_key")
     end
 
-    it "should not raise an error when passing valid view parameters" do
+    it "does not raise an error when passing valid view parameters" do
       lambda {
         CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {
           :key => 'keyvalue',
@@ -38,66 +38,66 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       }.should_not raise_error
     end
 
-    it "should remove stale when it's nil" do
+    it "removes stale when it's nil" do
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {:stale => nil}
       spec.view_parameters.should == {}
     end
 
-    it "should convert a range passed as key into startkey and endkey" do
+    it "converts a range passed as key into startkey and endkey" do
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {:key => '1'..'2'}
       spec.view_parameters.should == {:startkey => '1', :endkey => '2'}
     end
 
-    it "should convert a plain value to a hash with a key" do
+    it "converts a plain value to a hash with a key" do
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, '2'
       spec.view_parameters.should == {:key => '2'}
     end
 
-    it "should generate the design document path by snake_casing the class name but keeping double colons" do
+    it "generates the design document path by snake_casing the class name but keeping double colons" do
       spec = CouchPotato::View::BaseViewSpec.new 'Foo::BarBaz', '', {}, ''
       spec.design_document.should == 'foo::bar_baz'
     end
 
-    it "should generate the design document independent of the view name by default" do
+    it "generates the design document independent of the view name by default" do
       CouchPotato::Config.split_design_documents_per_view = false
       spec = CouchPotato::View::BaseViewSpec.new 'User', 'by_login_and_email', {}, ''
       spec.design_document.should == 'user'
     end
 
-    it "should generate the design document per view if configured to" do
+    it "generates the design document per view if configured to" do
       CouchPotato::Config.split_design_documents_per_view = true
       spec = CouchPotato::View::BaseViewSpec.new 'User', 'by_login_and_email', {}, ''
       spec.design_document.should == 'user_view_by_login_and_email'
     end
 
-    it "should generate the design document independent of the list name by default" do
+    it "generates the design document independent of the list name by default" do
       CouchPotato::Config.split_design_documents_per_view = false
       spec = CouchPotato::View::BaseViewSpec.new stub(:lists => nil, :to_s => 'User'), '', {:list => 'test_list'}, {}
       spec.design_document.should == 'user'
     end
 
-    it "should generate the design document per view if configured to" do
+    it "generates the design document per view if configured to" do
       CouchPotato::Config.split_design_documents_per_view = true
       spec = CouchPotato::View::BaseViewSpec.new stub(:lists => nil, :to_s => 'User'), '', {:list => :test_list}, {}
       spec.design_document.should == 'user_list_test_list'
     end
 
-    it "should extract the list name from the options" do
+    it "extracts the list name from the options" do
       spec = CouchPotato::View::BaseViewSpec.new stub(:lists => nil), 'all', {:list => :test_list}, {}
       spec.list_name.should == :test_list
     end
 
-    it "should extract the list from the view parameters" do
+    it "extracts the list from the view parameters" do
       spec = CouchPotato::View::BaseViewSpec.new stub(:lists => nil), 'all', {}, {:list => :test_list}
       spec.list_name.should == :test_list
     end
 
-    it "should prefer the list name from the view parameters over the one from the options" do
+    it "prefers the list name from the view parameters over the one from the options" do
       spec = CouchPotato::View::BaseViewSpec.new stub(:lists => nil), 'all', {:list => 'my_list'}, {:list => :test_list}
       spec.list_name.should == :test_list
     end
 
-    it "should return the list function" do
+    it "returns the list function" do
       klass = stub 'class'
       klass.stub(:lists).with('test_list').and_return('<list_code>')
       spec = CouchPotato::View::BaseViewSpec.new klass, 'all', {:list => 'test_list'}, {}
@@ -114,6 +114,13 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {:language => :erlang}, {}
       spec.language.should == :erlang
     end
+
+    it 'post-processes the results' do
+      filter = lambda{ |results| results.map{|r| r.to_i} }
+      spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {:results_filter => filter}, {}
+
+      expect(spec.process_results(['1'])).to eql([1])
+    end
   end
 end
 

data/spec/unit/custom_view_spec_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe CouchPotato::View::CustomViewSpec, '#process_results' do
+  it 'returns the documents' do
+    spec = CouchPotato::View::CustomViewSpec.new(Child, 'all', {}, {})
+    processed_results = spec.process_results('rows' => [{'doc' => {JSON.create_id => 'Child'}}])
+
+    expect(processed_results.map{|row| row.class}).to eql([Child])
+  end
+
+  it 'returns values where there are no documents' do
+    spec = CouchPotato::View::CustomViewSpec.new(Child, 'all', {}, {:include_docs => false})
+    processed_results = spec.process_results('rows' => [{'value' => {JSON.create_id => 'Child'}}])
+
+    expect(processed_results.map{|row| row.class}).to eql([Child])
+  end
+
+  it 'filters out rows without documents when include_docs=true (i.e. doc has been deleted)' do
+    spec = CouchPotato::View::CustomViewSpec.new(Child, 'all', {}, {:include_docs => true})
+    processed_results = spec.process_results('rows' => [{'value' => {JSON.create_id => 'Child'}}])
+
+    expect(processed_results).to be_empty
+  end
+end

data/spec/unit/forbidden_attributes_protection_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+begin
+  require 'rack/test'
+  require 'active_model/forbidden_attributes_protection'
+  require 'action_controller/metal/strong_parameters'
+
+  describe 'forbidden attributes protection' do
+    context 'when initializing a new object' do
+      it 'raises an error when passing non-permitted attributes' do
+        expect {
+          Child.new ActionController::Parameters.new(:text => 'xx')
+        }.to raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+
+      it 'raises no error when passing permitted attributes' do
+        expect {
+          Child.new ActionController::Parameters.new(:text => 'xx').permit!
+        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+
+      it "raises no error when passing attributes that don't respond to permitted?" do
+        expect {
+          Child.new :text => 'xx'
+        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+    end
+
+    context 'when mass-assigning attributes to an object' do
+      let(:subject) {Child.new}
+
+      it 'raises an error when passing non-permitted attributes' do
+        expect {
+          subject.attributes = ActionController::Parameters.new(:text => 'xx')
+        }.to raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+
+      it 'raises no error when passing permitted attributes' do
+        expect {
+          subject.attributes = ActionController::Parameters.new(:text => 'xx').permit!
+        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+
+      it "raises no error when passing attributes that don't respond to permitted?" do
+        expect {
+          subject.attributes = {:text => 'xx'}
+        }.to_not raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+    end
+  end
+rescue LoadError
+  puts "Skipping forbidden attributes protection specs."
+end

data/spec/unit/model_view_spec_spec.rb

@@ -1,6 +1,29 @@
 require 'spec_helper'
 
-describe CouchPotato::View::ModelViewSpec, 'map_function' do
+describe CouchPotato::View::ModelViewSpec, '#process_results' do
+  it 'returns the documents' do
+    spec = CouchPotato::View::ModelViewSpec.new(Object, 'all', {}, {})
+    processed_results = spec.process_results('rows' => [{'doc' => 'doc-1'}])
+
+    expect(processed_results).to eql(['doc-1'])
+  end
+
+  it 'returns ids where there are no documents' do
+    spec = CouchPotato::View::ModelViewSpec.new(Object, 'all', {}, {:include_docs => false})
+    processed_results = spec.process_results('rows' => [{'id' => 'doc-1'}])
+
+    expect(processed_results).to eql(['doc-1'])
+  end
+
+  it 'filters out rows without documents when include_docs=true (i.e. doc has been deleted)' do
+    spec = CouchPotato::View::ModelViewSpec.new(Object, 'all', {}, {:include_docs => true})
+    processed_results = spec.process_results('rows' => [{'id' => 'doc-1'}])
+
+    expect(processed_results).to be_empty
+  end
+end
+
+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))')

data/spec/unit/persistence_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+class Dude
+  include CouchPotato::Persistence
+  property :name
+end
+
+class NoneDude
+  include CouchPotato::Persistence
+  property :name
+end
+
+describe "persistence" do
+  context '#eql?' do
+    it "should use the class and id for equality" do
+      dude22 = Dude.new(:id => "22", :name => "foo")
+      dude11 = Dude.new(:id => "11", :name => "bar")
+
+      none_dude22 = NoneDude.new(:id => "22", :name => "foo")
+
+      dude22.should eql(dude22)
+      dude22.should_not eql(none_dude22)
+      dude22.should_not eql(dude11)
+    end
+
+    it "should handle new objects without id to be never equal" do
+      dude = Dude.new(:name => "foo")
+      dude22 = Dude.new(:id => "22", :name => "foo")
+
+      dude.should_not eql(Dude.new(:name => "foo"))
+      dude22.should_not eql(Dude.new(:name => "foo"))
+    end
+
+    it "should handle same object references to be equal" do
+      dude = Dude.new(:name => "foo")
+
+      dude.should eql(dude)
+    end
+  end
+end

data/spec/unit/rspec_matchers_spec.rb

@@ -30,6 +30,11 @@ describe CouchPotato::RSpec::MapToMatcher do
       @view_spec.should_not map({:name => 'horst', :tags => ['person', 'male']}).to(['horst', 2], ['male', 'person'])
     end
   end
+
+  it "should work with date emit values" do
+    spec = stub(:map_function => "function(doc) { emit(null, new Date(1368802800000)); }")
+    spec.should map({}).to([nil, "2013-05-17T15:00:00.000Z"])
+  end
   
   describe "failing specs" do
     before(:each) do
@@ -52,11 +57,11 @@ end
 
 describe CouchPotato::RSpec::ReduceToMatcher do
   before(:each) do
-    @view_spec = stub(:reduce_function => "function(docs, keys, rereduce) {
+    @view_spec = stub(:reduce_function => "function(keys, values, rereduce) {
       if(rereduce) {
-        return(sum(keys) * 2);
+        return(sum(values) * 2);
       } else {
-        return(sum(keys));
+        return(sum(values));
       };
     }")
   end
@@ -68,6 +73,11 @@ describe CouchPotato::RSpec::ReduceToMatcher do
   it "should not pass if the given function returns different javascript" do
     @view_spec.should_not reduce([], [1, 2, 3]).to(7)
   end
+
+  it "should work with date return values" do
+    spec = stub(:reduce_function => "function() { return new Date(1368802800000); }")
+    spec.should reduce([], []).to("2013-05-17T15:00:00.000Z")
+  end
   
   describe "rereduce" do
     it "should pass if the given function return the expected javascript" do
@@ -95,6 +105,112 @@ describe CouchPotato::RSpec::ReduceToMatcher do
   end
 end
 
+describe CouchPotato::RSpec::MapReduceToMatcher do
+  before(:each) do
+    @view_spec = stub(
+      :map_function => "function(doc) {
+          for (var i in doc.numbers)
+            emit([doc.age, doc.name], doc.numbers[i]);
+        }",
+      :reduce_function => "function (keys, values, rereduce) {
+          return Math.max.apply(this, values);
+        }")
+    @docs = [
+      {:name => "a", :age => 25, :numbers => [1, 2]},
+      {:name => "b", :age => 25, :numbers => [3, 4]},
+      {:name => "c", :age => 26, :numbers => [5, 6]},
+      {:name => "d", :age => 27, :numbers => [7, 8]}]
+  end
+
+  it "should handle date return values" do
+    spec = stub(:map_function => "function() { emit(null, null); }",
+      :reduce_function => "function() { return new Date(1368802800000); }")
+    spec.should map_reduce({}).to({"key" => nil, "value" => "2013-05-17T15:00:00.000Z"})
+  end
+
+  context "without grouping" do
+    it "should not group by key by default" do
+      @view_spec.should map_reduce(@docs).to({"key" => nil, "value" => 8})
+    end
+
+    it "should group by key with :group => false" do
+      @view_spec.should map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
+    end
+  end
+
+  context "with grouping" do
+    [true, "exact"].each do |group_value|
+      it "should group by the full key with option :group => #{group_value}" do
+        @view_spec.should map_reduce(@docs).with_options(:group => group_value).to(
+          {"key" => [25, "a"], "value" => 2},
+          {"key" => [25, "b"], "value" => 4},
+          {"key" => [26, "c"], "value" => 6},
+          {"key" => [27, "d"], "value" => 8})
+      end
+    end
+
+    it "should group by parts of the keys based on the :group_level option" do
+      @view_spec.should map_reduce(@docs).with_options(:group_level => 1).to(
+        {"key" => [25], "value" => 4},
+        {"key" => [26], "value" => 6},
+        {"key" => [27], "value" => 8})
+    end
+  end
+
+  describe "rereducing" do
+    before :each do
+      @view_spec = stub(:map_function => "function(doc) {
+          emit(doc.name, doc.number);
+        }",
+        :reduce_function => "function (keys, values, rereduce) {
+          if (rereduce) {
+            var result = {rereduce_values: []};
+            for (var v in values) {
+              result.rereduce_values.push(values[v].reduce_values);
+            }
+            return result;
+          }
+          return {reduce_values: values};
+        }")
+    end
+
+    it "should reduce and rereduce for a single emit" do
+      @view_spec.should map_reduce({:name => "a", :number => 1}).to({"key" => nil, "value" => {"rereduce_values" => [[1]]}})
+    end
+
+    it "should split and reduce each half of emitted values separately and rereduce the results" do
+      docs = [
+        {:name => "a", :number => 1},
+        {:name => "a", :number => 2},
+        {:name => "a", :number => 3},
+        {:name => "a", :number => 4}]
+      @view_spec.should map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1, 2], [3, 4]]}})
+    end
+
+    it "should correctly split and rereduce with an odd number of emits" do
+      docs = [
+        {:name => "a", :number => 1},
+        {:name => "a", :number => 2},
+        {:name => "a", :number => 3}]
+      @view_spec.should map_reduce(docs).to({"key" => nil, "value" => {"rereduce_values" => [[1], [2, 3]]}})
+    end
+  end
+
+  describe "failing specs" do
+    it "should have a nice error message for failing should" do
+      lambda {
+        @view_spec.should map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 9})
+      }.should raise_error('Expected to map/reduce to [{"key"=>nil, "value"=>9}] but got [{"key"=>nil, "value"=>8}].')
+    end
+
+    it "should have a nice error message for failing should not" do
+      lambda {
+        @view_spec.should_not map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
+      }.should raise_error('Expected not to map/reduce to [{"key"=>nil, "value"=>8}] 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'}]));}")
@@ -107,7 +223,12 @@ describe CouchPotato::RSpec::ListAsMatcher do
   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
-  
+
+  it "should work with date values" do
+    spec = stub(:list_function => "function() { send(JSON.stringify([{date: new Date(1368802800000)}])); }")
+    spec.should list({"rows" => [{}]}).as([{"date" => "2013-05-17T15:00:00.000Z"}])
+  end
+
   describe "failing specs" do
     it "should have a nice error message for failing should" do
       lambda {
@@ -121,4 +242,4 @@ describe CouchPotato::RSpec::ListAsMatcher do
       }.should raise_error('Expected to not list as [{"text"=>"hello world"}] but did.')
     end
   end
-end
+end

data/spec/views_spec.rb

@@ -105,11 +105,6 @@ describe 'views' do
     @db.view(Build.count(:reduce => true)).should == 0
   end
 
-  it "should return the total_rows" do
-    @db.save_document! Build.new(:state => 'success', :time => '2008-01-01')
-    @db.view(Build.count(:reduce => false)).total_rows.should == 1
-  end
-
   describe "with multiple keys" do
     it "should return the documents with matching keys" do
       build = Build.new(:state => 'success', :time => '2008-01-01')
@@ -125,19 +120,19 @@ describe 'views' do
   end
 
   describe "properties defined" do
-    it "should assign the configured properties" do
+    it "assigns the configured properties" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')
-      @db.view(Build.minimal_timeline).first.state.should == 'success'
+      @db.view(Build.minimal_timeline).first.state.should eql('success')
     end
 
-    it "should not assign the properties not configured" do
+    it "does not assign the properties not configured" do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')
       @db.view(Build.minimal_timeline).first.time.should be_nil
     end
 
-    it "should assign the id even if it is not configured" do
+    it "assigns the id even if it is not configured" do
       id = CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')['id']
-      @db.view(Build.minimal_timeline).first._id.should == id
+      @db.view(Build.minimal_timeline).first._id.should eql(id)
     end
   end
 
@@ -278,4 +273,15 @@ describe 'views' do
       @db.view(Coworker.all(:list => :append_doe)).first.name.should == 'joe doe'
     end
   end
+
+  describe 'with stale views' do
+    it 'does not return deleted documents' do
+      build = Build.new
+      @db.save_document! build
+      @db.view(Build.timeline)
+      @db.destroy build
+
+      expect(@db.view(Build.timeline(:stale => 'ok'))).to be_empty
+    end
+  end
 end