couch_potato 1.4.0 → 1.6.3

data/spec/rails_spec.rb

@@ -30,12 +30,12 @@ describe CouchPotato::Database, 'rails specific behavior' do
   context 'load a document' do
     it "should load models whose constants are currently uninitialized (like with rails in development mode)" do
       CouchPotato.couchrest_database.save_doc(JSON.create_id => 'Autoloader::Uninitialized', '_id' => '1')
-      CouchPotato.database.load('1').class.name.should == 'Autoloader::Uninitialized'
+      expect(CouchPotato.database.load('1').class.name).to eq('Autoloader::Uninitialized')
     end
     
     it "should load nested models" do
       CouchPotato.couchrest_database.save_doc(JSON.create_id => 'Autoloader::Nested::Nested2', '_id' => '1')
-      CouchPotato.database.load('1').class.name.should == 'Autoloader::Nested::Nested2'
+      expect(CouchPotato.database.load('1').class.name).to eq('Autoloader::Nested::Nested2')
     end
   end  
   
@@ -43,7 +43,7 @@ describe CouchPotato::Database, 'rails specific behavior' do
     it "should load models from a view whose constants are currently uninitialized" do
       doc = {JSON.create_id => 'WithUnloadedEmbedded', '_id' => '1', 'embedded' => {JSON.create_id => 'WithUnloadedEmbedded::Uninitialized'}}
       CouchPotato.couchrest_database.save_doc(doc)
-      CouchPotato.database.view(WithUnloadedEmbedded.all).first.embedded.class.name.should == 'WithUnloadedEmbedded::Uninitialized'
+      expect(CouchPotato.database.view(WithUnloadedEmbedded.all).first.embedded.class.name).to eq('WithUnloadedEmbedded::Uninitialized')
     end
   end
 end

data/spec/railtie_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'yaml'
-require 'spec/mocks'
 
 module Rails
   def self.env
@@ -13,11 +12,11 @@ module Rails
   end
 
   def self.root
-    RSpec::Mocks::Mock.new :join => ''
+    RSpec::Mocks::Double.new join: ''
   end
 
   def self.logger
-    RSpec::Mocks::Mock.new :warn => nil
+    RSpec::Mocks::Double.new warn: nil
   end
 end
 
@@ -35,16 +34,16 @@ describe "railtie" do
   end
 
   before(:each) do
-    File.stub(exist?: true)
+    allow(File).to receive_messages(exist?: true)
   end
 
   context 'when the yml file does not exist' do
     before(:each) do
-      File.stub(exist?: false)
+      allow(File).to receive_messages(exist?: false)
     end
 
     it 'does not configure the database' do
-      CouchPotato::Config.should_not_receive(:database_name=)
+      expect(CouchPotato::Config).not_to receive(:database_name=)
 
       CouchPotato.rails_init
     end
@@ -52,9 +51,9 @@ describe "railtie" do
 
   context 'yaml file contains only database names' do
     it "should set the database name from the yaml file" do
-      File.stub(:read => "test: test_db")
+      allow(File).to receive_messages(:read => "test: test_db")
 
-      CouchPotato::Config.should_receive(:database_name=).with('test_db')
+      expect(CouchPotato::Config).to receive(:database_name=).with('test_db')
 
       CouchPotato.rails_init
     end
@@ -62,26 +61,26 @@ describe "railtie" do
 
   context 'yaml file contains more configuration' do
     before(:each) do
-      File.stub(:read => "test: \n  database: test_db\n  default_language: :erlang")
+      allow(File).to receive_messages(:read => "test: \n  database: test_db\n  default_language: :erlang")
     end
 
     it "set the database name from the yaml file" do
-      CouchPotato::Config.should_receive(:database_name=).with('test_db')
+      expect(CouchPotato::Config).to receive(:database_name=).with('test_db')
 
       CouchPotato.rails_init
     end
 
     it 'sets the default language from the yaml file' do
-      CouchPotato::Config.should_receive(:default_language=).with(:erlang)
+      expect(CouchPotato::Config).to receive(:default_language=).with(:erlang)
 
       CouchPotato.rails_init
     end
   end
 
   it "should process the yml file with erb" do
-    File.stub(:read => "test: \n  database: <%= 'db' %>")
+    allow(File).to receive_messages(:read => "test: \n  database: <%= 'db' %>")
 
-    CouchPotato::Config.should_receive(:database_name=).with('db')
+    expect(CouchPotato::Config).to receive(:database_name=).with('db')
 
     CouchPotato.rails_init
   end

data/spec/spec_helper.rb

@@ -34,7 +34,7 @@ end
 class BigDecimalContainer
   include CouchPotato::Persistence
 
-  property :number, :type => BigDecimal
+  property :number, type: BigDecimal
 end
 
 def recreate_db
@@ -53,11 +53,11 @@ RSpec::Matchers.define :eql_ignoring_indentation do |expected|
     strip_indentation(string) == strip_indentation(expected)
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected\n#{strip_indentation(actual).inspect} to == \n#{strip_indentation(expected).inspect} but wasn't."
   end
 
-  failure_message_for_should_not do |actual|
+  failure_message_when_negated do |actual|
     "expected\n#{strip_indentation(actual).inspect} to not == \n#{strip_indentation(expected).inspect} but wasn."
   end
 

data/spec/unit/active_model_compliance_spec.rb

@@ -12,6 +12,10 @@ begin
       end
     end
 
+    def assert_equal(one, other)
+      expect(one).to equal(other)
+    end
+
     class ActiveComment
       include CouchPotato::Persistence
       property :name
@@ -26,31 +30,31 @@ begin
 
     describe '#to_partial_path' do
       it 'returns a path based on the class name' do
-        @model.to_partial_path.should == 'active_comments/active_comment'
+        expect(@model.to_partial_path).to eq('active_comments/active_comment')
       end
     end
 
     describe "#persisted?" do
       it "should return false if it is a new document " do
-        @model.should_not be_persisted
+        expect(@model).not_to be_persisted
       end
 
       it "should be true if it was saved" do
         @comment = ActiveComment.new(:name => 'Thilo', :email => 'test@local.host')
         CouchPotato.database.save_document! @comment
-        @comment.should be_persisted
+        expect(@comment).to be_persisted
       end
     end
 
     describe "#to_key" do
       it "should return nil if the document was not persisted" do
-        @model.to_key.should be_nil
+        expect(@model.to_key).to be_nil
       end
 
       it "should return the id of the document if it was persisted" do
         @comment = ActiveComment.new(:name => 'Thilo', :email => 'test@local.host')
         CouchPotato.database.save_document! @comment
-        @comment.to_key.should == [@comment.id]
+        expect(@comment.to_key).to eq([@comment.id])
       end
     end
 
@@ -58,31 +62,31 @@ begin
     describe "#errors" do
       it "should return a single error as array" do
         @model.valid?
-        @model.errors[:name].should be_kind_of(Array)
+        expect(@model.errors[:name]).to be_kind_of(Array)
       end
 
       it "should return multiple errors as array" do
         @model.valid?
-        @model.errors[:email].size.should == 2
+        expect(@model.errors[:email].size).to eq(2)
       end
 
       it "should return no error as an empty array" do
-        @model.errors[:name].should == []
+        expect(@model.errors[:name]).to eq([])
       end
 
       it "should be able to be Marshal.dump'ed" do
-        lambda { Marshal.dump(@model.errors) }.should_not raise_error
+        expect { Marshal.dump(@model.errors) }.not_to raise_error
       end
     end
 
     describe "#destroyed" do
       it "should return destroyed if the object is deleted" do
         @model._deleted = true
-        @model.should be_destroyed
+        expect(@model).to be_destroyed
       end
 
       it "should not return destroyed if it's not deleted" do
-        @model.should_not be_destroyed
+        expect(@model).not_to be_destroyed
       end
     end
 
@@ -91,14 +95,10 @@ begin
     end
 
     def assert_kind_of(klass, object)
-      object.should be_a(klass)
+      expect(object).to be_a(klass)
     end
   end
 
 rescue LoadError
   STDERR.puts "WARNING: active_model gem not installed. Not running ActiveModel specs."
 end
-
-
-
-

data/spec/unit/attributes_spec.rb

@@ -21,40 +21,42 @@ describe "attributes" do
     it "should assign the attributes" do
       plant = Plant.new
       plant.attributes = {:leaf_count => 1}
-      plant.leaf_count.should == 1
+      expect(plant.leaf_count).to eq(1)
     end
 
     it "should assign the attributes via []=" do
       plant = Plant.new
       plant[:leaf_count] = 1
-      plant.leaf_count.should == 1
+      expect(plant.leaf_count).to eq(1)
     end
   end
 
   context "attributes" do
     it "should return the attributes" do
       plant = Plant.new(:leaf_count => 1)
-      plant.attributes.should == {'leaf_count' => 1, 'created_at' => nil, 'updated_at' => nil,
-                                  'typed_leaf_count' => nil, 'typed_leaf_size' => nil, 'branch' => nil}
+      expect(plant.attributes).to eq({'leaf_count' => 1, 'created_at' => nil, 'updated_at' => nil,
+                                  'typed_leaf_count' => nil, 'typed_leaf_size' => nil, 'branch' => nil})
     end
 
     it "should return the attributes via [symbol]" do
       plant = Plant.new(:leaf_count => 1)
-      plant.attributes[:leaf_count].should eql(plant[:leaf_count])
-      plant.attributes[:leaf_count].should eql(1)
+      expect(plant.attributes[:leaf_count]).to eql(plant[:leaf_count])
+      expect(plant.attributes[:leaf_count]).to eql(1)
     end
 
     it "should return the attributes via [string]" do
-      plant = Plant.new(:leaf_count => 1)
-      plant.attributes["leaf_count"].should eql(plant[:leaf_count])
-      plant.attributes["leaf_count"].should eql(1)
+      plant = Plant.new(leaf_count: 1)
+
+      expect(plant.attributes["leaf_count"]).to eql(plant[:leaf_count])
+      expect(plant.attributes["leaf_count"]).to eql(1)
     end
   end
 
   context "has_key?" do
-    it "should respond to has_key?" do
-      plant = Plant.new(:leaf_count => 1)
-      plant.has_key?(:leaf_count).should be_true
+    it 'should respond to has_key?' do
+      plant = Plant.new(leaf_count: 1)
+
+      expect(plant.has_key?(:leaf_count)).to be_truthy
     end
   end
 
@@ -62,21 +64,21 @@ describe "attributes" do
   context "accessing ghost attributes" do
     it "should allow me to access attributes that are in the couchdb document but not defined as a property" do
       plant = Plant.json_create({JSON.create_id => "Plant", "color" => "red", "leaf_count" => 1})
-      plant.color.should == 'red'
+      expect(plant.color).to eq('red')
     end
 
     it "should raise a no method error when trying to read attributes that are not in the document" do
       plant = Plant.json_create({JSON.create_id => "Plant", "leaf_count" => 1})
-      lambda do
+      expect do
         plant.length
-      end.should raise_error(NoMethodError)
+      end.to raise_error(NoMethodError)
     end
 
     it "should raise a no method error if the document hasn't been loaded from the database" do
       plant = Plant.new
-      lambda do
+      expect do
         plant.length
-      end.should raise_error(NoMethodError, /undefined method `length'/)
+      end.to raise_error(NoMethodError, /undefined method `length'/)
     end
   end
 
@@ -87,91 +89,91 @@ describe "attributes" do
 
     context 'nested objects' do
       it 'assigns the attributes of nested objects' do
-        Plant.new(:branch => {:leafs => 3}).branch.leafs.should == 3
+        expect(Plant.new(:branch => {:leafs => 3}).branch.leafs).to eq(3)
       end
     end
 
     describe "fixnum" do
       it 'rounds a float to a fixnum' do
         @plant.typed_leaf_count = 4.5
-        @plant.typed_leaf_count.should == 5
+        expect(@plant.typed_leaf_count).to eq(5)
       end
 
       it "converts a string into a fixnum" do
         @plant.typed_leaf_count = '4'
-        @plant.typed_leaf_count.should == 4
+        expect(@plant.typed_leaf_count).to eq(4)
       end
 
       it "converts a string into a negative fixnum" do
         @plant.typed_leaf_count = '-4'
-        @plant.typed_leaf_count.should == -4
+        expect(@plant.typed_leaf_count).to eq(-4)
       end
 
       it "leaves a fixnum as is" do
         @plant.typed_leaf_count = 4
-        @plant.typed_leaf_count.should == 4
+        expect(@plant.typed_leaf_count).to eq(4)
       end
 
       it "leaves nil as is" do
         @plant.typed_leaf_count = nil
-        @plant.typed_leaf_count.should be_nil
+        expect(@plant.typed_leaf_count).to be_nil
       end
 
       it "sets the attributes to zero if a string given" do
         @plant.typed_leaf_count = 'x'
-        @plant.typed_leaf_count.should == 0
+        expect(@plant.typed_leaf_count).to eq(0)
       end
 
       it "parses numbers out of a string" do
         @plant.typed_leaf_count = 'x123'
-        @plant.typed_leaf_count.should == 123
+        expect(@plant.typed_leaf_count).to eq(123)
       end
 
       it "set the attributes to nil if given a blank string" do
         @plant.typed_leaf_count = ''
-        @plant.typed_leaf_count.should be_nil
+        expect(@plant.typed_leaf_count).to be_nil
       end
     end
 
     context "float" do
       it "should convert a number in a string with a decimal place" do
         @plant.typed_leaf_size = '0.5001'
-        @plant.typed_leaf_size.should == 0.5001
+        expect(@plant.typed_leaf_size).to eq(0.5001)
       end
 
       it "should convert a number in a string without a decimal place" do
         @plant.typed_leaf_size = '5'
-        @plant.typed_leaf_size.should == 5.0
+        expect(@plant.typed_leaf_size).to eq(5.0)
       end
 
       it "should convert a negative number in a string" do
         @plant.typed_leaf_size = '-5.0'
-        @plant.typed_leaf_size.should == -5.0
+        expect(@plant.typed_leaf_size).to eq(-5.0)
       end
 
       it "should leave a float as it is" do
         @plant.typed_leaf_size = 0.5
-        @plant.typed_leaf_size.should == 0.5
+        expect(@plant.typed_leaf_size).to eq(0.5)
       end
 
       it "should leave nil as is" do
         @plant.typed_leaf_size = nil
-        @plant.typed_leaf_size.should be_nil
+        expect(@plant.typed_leaf_size).to be_nil
       end
 
       it "should set the attributes to zero if a string given" do
         @plant.typed_leaf_size = 'x'
-        @plant.typed_leaf_size.should == 0
+        expect(@plant.typed_leaf_size).to eq(0)
       end
 
       it "should parse numbers out of a string" do
         @plant.typed_leaf_size = 'x00.123'
-        @plant.typed_leaf_size.should == 0.123
+        expect(@plant.typed_leaf_size).to eq(0.123)
       end
 
       it "should set the attributes to nil if given a blank string" do
         @plant.typed_leaf_size = ''
-        @plant.typed_leaf_size.should be_nil
+        expect(@plant.typed_leaf_size).to be_nil
       end
     end
   end

data/spec/unit/base_view_spec_spec.rb

@@ -11,14 +11,14 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       CouchPotato::Config.default_language = @default_language
     end
 
-    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")
+    it 'raises an error when passing invalid view parameters' do
+      expect {
+        CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {start_key: '1'}
+      }.to raise_error(ArgumentError, "invalid view parameter: start_key")
     end
 
-    it "does not raise an error when passing valid view parameters" do
-      lambda {
+    it 'does not raise an error when passing valid view parameters' do
+      expect {
         CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {
           :key => 'keyvalue',
           :startkey => 'keyvalue',
@@ -33,95 +33,142 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
           :group_level => 1,
           :reduce => false,
           :include_docs => true,
-          :inclusive_end => true
+          :inclusive_end => true,
+          :list_params => {}
         }
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "removes stale when it's nil" do
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {:stale => nil}
-      spec.view_parameters.should == {}
+      expect(spec.view_parameters).to eq({})
     end
 
     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'}
+      expect(spec.view_parameters).to eq({:startkey => '1', :endkey => '2'})
     end
 
     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'}
+      expect(spec.view_parameters).to eq({:key => '2'})
+    end
+
+    it 'merges the list params' do
+      spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, key: '2', list_params: {:x => 'y'}
+      expect(spec.view_parameters).to eq({:key => '2', :x => 'y'})
     end
 
     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'
+      expect(spec.design_document).to eq('foo::bar_baz')
     end
 
     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'
+      expect(spec.design_document).to eq('user')
     end
 
     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'
+      expect(spec.design_document).to eq('user_view_by_login_and_email')
+    end
+
+    it 'adds the view name digest to the design doc name' do
+      CouchPotato::Config.split_design_documents_per_view = true
+      spec = CouchPotato::View::RawViewSpec.new 'User', 'by_login_and_email',
+        {digest_view_name: true, map: 'function(doc) {}'}, ''
+
+      expect(spec.design_document).to eq('user_view_by_login_and_email-375c815fcb4f977f330a2edfadc7f74d')
     end
 
+    it 'builds the name digest by hashing the map and reduce function if there is one' do
+      CouchPotato::Config.split_design_documents_per_view = true
+      spec = CouchPotato::View::RawViewSpec.new 'User', 'by_login_and_email',
+        {digest_view_name: true, map: 'function(doc) {}', reduce: 'function(key, values) {}'}, ''
+
+      expect(spec.design_document).to eq('user_view_by_login_and_email-c9f83cec3dab954a8ca56330006f187e')
+    end
+
+
     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'
+      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil, :to_s => 'User'), '', {list: 'test_list'}, {}
+      expect(spec.design_document).to eq('user')
     end
 
     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'
+      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil, :to_s => 'User'), '', {list: :test_list}, {}
+      expect(spec.design_document).to eq('user_list_test_list')
     end
 
     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
+      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {list: :test_list}, {}
+      expect(spec.list_name).to eq(:test_list)
     end
 
     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
+      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {}, {list: :test_list}
+      expect(spec.list_name).to eq(:test_list)
     end
 
     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
+      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {list: 'my_list'}, list: :test_list
+      expect(spec.list_name).to eq(:test_list)
+    end
+
+    it 'returns the view name' do
+      spec = CouchPotato::View::BaseViewSpec.new Object, 'by_id', {}, {}
+      expect(spec.view_name).to eq('by_id')
+    end
+
+    it 'adds a digest to the view name based on the map function content when passing digest_view_name' do
+      # need to use RawViewSpec here so we can pass a map function
+      spec = CouchPotato::View::RawViewSpec.new Object, 'by_id',
+        {digest_view_name: true, map: 'function() {}'}, {}
+
+      expect(spec.view_name).to eq('by_id-4644e3a3ef266d4e6b513dc79bad5ab7')
+    end
+
+    it 'adds a digest to the view name if configure to' do
+      begin
+        CouchPotato::Config.digest_view_names = true
+        # need to use RawViewSpec here so we can pass a map function
+        spec = CouchPotato::View::RawViewSpec.new Object, 'by_id',
+          {map: 'function() {}'}, {}
+
+        expect(spec.view_name).to eq('by_id-4644e3a3ef266d4e6b513dc79bad5ab7')
+      ensure
+        CouchPotato::Config.digest_view_names = false
+      end
     end
 
     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'}, {}
-      spec.list_function.should == '<list_code>'
+      klass = double 'class'
+      allow(klass).to receive(:lists).with('test_list').and_return('<list_code>')
+      spec = CouchPotato::View::BaseViewSpec.new klass, 'all', {list: 'test_list'}, {}
+      expect(spec.list_function).to eq('<list_code>')
     end
 
     it 'reads the language from the couch potato config by default' do
       CouchPotato::Config.default_language = :ruby
       spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {}, {}
-      spec.language.should == :ruby
+      expect(spec.language).to eq(:ruby)
     end
 
     it 'sets the language to the given language' do
-      spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {:language => :erlang}, {}
-      spec.language.should == :erlang
+      spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {language: :erlang}, {}
+      expect(spec.language).to eq(: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}, {}
+      filter = -> (results) { results.map(&:to_i) }
+      spec = CouchPotato::View::BaseViewSpec.new Object, 'all', {results_filter: filter}, {}
 
       expect(spec.process_results(['1'])).to eql([1])
     end
   end
 end
-
-