couch_potato 1.18.0 → 1.19.1

data/spec/unit/base_view_spec_spec.rb

@@ -33,8 +33,7 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
           :group_level => 1,
           :reduce => false,
           :include_docs => true,
-          :inclusive_end => true,
-          :list_params => {}
+          :inclusive_end => true
         }
       }.not_to raise_error
     end
@@ -54,70 +53,72 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       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', '', {}, ''
-      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', {}, ''
-      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', {}, ''
-      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 double(lists: nil, :to_s => 'User'), '', {list: 'test_list'}, {}
-      expect(spec.design_document).to eq('user')
-    end
+    context 'when single design document is enabled' do
+      before(:each) do
+        CouchPotato::Config.single_design_document = true
+      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 double(lists: nil, :to_s => 'User'), '', {list: :test_list}, {}
-      expect(spec.design_document).to eq('user_list_test_list')
-    end
+      after(:each) do
+        CouchPotato::Config.single_design_document = false
+      end
+      
+      it 'generates one design document for all views' do
+        spec = CouchPotato::View::BaseViewSpec.new 'User', 'by_login_and_email', {}, ''
 
-    it "extracts the list name from the options" do
-      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {list: :test_list}, {}
-      expect(spec.list_name).to eq(:test_list)
+        expect(spec.design_document).to eq('couch_potato')
+      end
     end
 
-    it "extracts the list from the view parameters" do
-      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {}, {list: :test_list}
-      expect(spec.list_name).to eq(:test_list)
-    end
+    context 'when single design document is disabled' do
+      before(:each) do
+        CouchPotato::Config.single_design_document = false
+      end
+      
+      context 'and split design documents per view is enabled' do
+        before(:each) do
+          CouchPotato::Config.split_design_documents_per_view = true
+        end
+
+        after(:each) do
+          CouchPotato::Config.split_design_documents_per_view = false
+        end
+        
+        it "generates one design document per view" do
+          spec = CouchPotato::View::BaseViewSpec.new 'User', '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
+          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
+          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
+      end
 
-    it "prefers the list name from the view parameters over the one from the options" do
-      spec = CouchPotato::View::BaseViewSpec.new double(lists: nil), 'all', {list: 'my_list'}, list: :test_list
-      expect(spec.list_name).to eq(:test_list)
+      context 'and split design documents per view is disabled' do
+        before(:each) do
+          CouchPotato::Config.split_design_documents_per_view = false
+        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', '', {}, ''
+          expect(spec.design_document).to eq('foo::bar_baz')
+        end
+    
+        it "generates the design document independent of the view name" do
+          spec = CouchPotato::View::BaseViewSpec.new 'User', 'by_login_and_email', {}, ''
+          expect(spec.design_document).to eq('user')
+        end
+      end
+      
     end
 
     it 'returns the view name' do
@@ -146,13 +147,6 @@ describe CouchPotato::View::BaseViewSpec, 'initialize' do
       end
     end
 
-    it "returns the list function" do
-      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', {}, {}

data/spec/unit/couch_potato_spec.rb

@@ -8,6 +8,7 @@ describe CouchPotato, '.configure' do
     CouchPotato::Config.database_name = nil
     CouchPotato::Config.split_design_documents_per_view = false
     CouchPotato::Config.digest_view_names = false
+    CouchPotato::Config.single_design_document = false
     CouchPotato::Config.default_language = :javascript
     CouchPotato::Config.database_host = 'http://127.0.0.1:5984'
     CouchPotato::Config.additional_databases = {}
@@ -35,12 +36,14 @@ describe CouchPotato, '.configure' do
         test2: 'test2_db'
       },
       split_design_documents_per_view: true,
+      single_design_document: true,
       digest_view_names: true,
       default_language: 'erlang'
     )
 
     expect(CouchPotato::Config.database_name).to eq('testdb')
     expect(CouchPotato::Config.split_design_documents_per_view).to eq(true)
+    expect(CouchPotato::Config.single_design_document).to eq(true)
     expect(CouchPotato::Config.digest_view_names).to eq(true)
     expect(CouchPotato::Config.default_language).to eq('erlang')
     expect(CouchPotato::Config.database_host).to eq('http://10.0.0.1:2000')

data/spec/unit/database_spec.rb

@@ -415,29 +415,10 @@ describe CouchPotato::Database, 'view' do
     allow(CouchPotato::View::ViewQuery).to receive_messages(new: double('view query', query_view!: { 'rows' => [@result] }))
   end
 
-  it 'initializes a view query with map/reduce/list/lib funtions' do
-    allow(@spec).to receive_messages(design_document: 'design_doc', view_name: 'my_view',
-                                     map_function: '<map_code>', reduce_function: '<reduce_code>',
-                                     lib: { test: '<test_code>' },
-                                     list_name: 'my_list', list_function: '<list_code>', language: 'javascript')
-    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
-      @couchrest_db,
-      'design_doc',
-      { 'my_view' => {
-        map: '<map_code>',
-        reduce: '<reduce_code>'
-      } },
-      { 'my_list' => '<list_code>' },
-      { test: '<test_code>' },
-      'javascript'
-    )
-    @db.view(@spec)
-  end
 
-  it 'initializes a view query with map/reduce/list funtions' do
+  it 'initializes a view query with map/reduce functions' do
     allow(@spec).to receive_messages(design_document: 'design_doc', view_name: 'my_view',
                                      map_function: '<map_code>', reduce_function: '<reduce_code>',
-                                     lib: nil, list_name: 'my_list', list_function: '<list_code>',
                                      language: 'javascript')
     expect(CouchPotato::View::ViewQuery).to receive(:new).with(
       @couchrest_db,
@@ -446,44 +427,11 @@ describe CouchPotato::Database, 'view' do
         map: '<map_code>',
         reduce: '<reduce_code>'
       } },
-      { 'my_list' => '<list_code>' },
-      nil,
       'javascript'
     )
     @db.view(@spec)
   end
 
-  it 'initializes a view query with only map/reduce/lib functions' do
-    allow(@spec).to receive_messages(design_document: 'design_doc', view_name: 'my_view',
-                                     map_function: '<map_code>', reduce_function: '<reduce_code>',
-                                     list_name: nil, list_function: nil,
-                                     lib: { test: '<test_code>' })
-    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
-      @couchrest_db,
-      'design_doc',
-      { 'my_view' => {
-        map: '<map_code>',
-        reduce: '<reduce_code>'
-      } }, nil, { test: '<test_code>' }, anything
-    )
-    @db.view(@spec)
-  end
-
-  it 'initializes a view query with only map/reduce functions' do
-    allow(@spec).to receive_messages(design_document: 'design_doc', view_name: 'my_view',
-                                     map_function: '<map_code>', reduce_function: '<reduce_code>',
-                                     lib: nil, list_name: nil, list_function: nil)
-    expect(CouchPotato::View::ViewQuery).to receive(:new).with(
-      @couchrest_db,
-      'design_doc',
-      { 'my_view' => {
-        map: '<map_code>',
-        reduce: '<reduce_code>'
-      } }, nil, nil, anything
-    )
-    @db.view(@spec)
-  end
-
   it 'sets itself on returned docs that have an accessor' do
     allow(@result).to receive(:respond_to?).and_return(false)
     allow(@result).to receive(:respond_to?).with(:database=).and_return(true)

data/spec/unit/rspec_matchers_spec.rb

@@ -36,22 +36,6 @@ describe CouchPotato::RSpec::MapToMatcher do
     expect(spec).to map({}).to([nil, "2013-05-17T15:00:00.000Z"])
   end
 
-  it "should work with commonJS modules that use 'exports'" do
-    spec = double(
-      :map_function => "function(doc) { var test = require('views/lib/test'); emit(null, test.test); }",
-      :lib => {:test => "exports.test = 'test';"}
-    )
-    expect(spec).to map({}).to([nil, "test"])
-  end
-
-  it "should work with commonJS modules that use 'module.exports'" do
-    spec = double(
-      :map_function => "function(doc) { var test = require('views/lib/test'); emit(null, test.test); }",
-      :lib => {:test => "module.exports.test = 'test';"}
-    )
-    expect(spec).to map({}).to([nil, "test"])
-  end
-
   describe "failing specs" do
     before(:each) do
       @view_spec = double(:map_function => "function(doc) {emit(doc.name, null)}")
@@ -145,22 +129,6 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
     expect(spec).to map_reduce({}).to({"key" => nil, "value" => "2013-05-17T15:00:00.000Z"})
   end
 
-  it "should handle CommonJS requires for modules that use 'exports'" do
-    spec = double(
-      :map_function => "function() { var test = require('views/lib/test'); emit(null, test.test); }",
-      :reduce_function => "function(keys, values) { return 'test' }",
-      :lib => {:test => "exports.test = 'test'"})
-    expect(spec).to map_reduce({}).to({"key" => nil, "value" => "test"})
-  end
-
-  it "should handle CommonJS requires for modules that use 'module.exports'" do
-    spec = double(
-      :map_function => "function() { var test = require('views/lib/test'); emit(null, test.test); }",
-      :reduce_function => "function(keys, values) { return 'test' }",
-      :lib => {:test => "module.exports.test = 'test'"})
-    expect(spec).to map_reduce({}).to({"key" => nil, "value" => "test"})
-  end
-
   it "should handle sum function" do
     spec = double(
       :map_function => "function(doc) { emit(null, doc.age); }",
@@ -240,13 +208,13 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
     it "should have a nice error message for failing should" do
       expect {
         expect(@view_spec).to map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 9})
-      }.to raise_error('Expected to map/reduce to [{"key"=>nil, "value"=>9}] but got [{"key"=>nil, "value"=>8}].')
+      }.to raise_error(%r{Expected to map/reduce to \[{"key"\s*=>\s*nil, "value"\s*=>\s*9}\] but got \[{"key"\s*=>\s*nil, "value"\s*=>\s*8}\].})
     end
 
     it "should have a nice error message for failing should not" do
       expect {
         expect(@view_spec).not_to map_reduce(@docs).with_options(:group => false).to({"key" => nil, "value" => 8})
-      }.to raise_error('Expected not to map/reduce to [{"key"=>nil, "value"=>8}] but did.')
+      }.to raise_error(%r{Expected not to map/reduce to \[{"key"\s*=>\s*nil, "value"\s*=>\s*8}\] but did.})
     end
   end
 
@@ -283,35 +251,3 @@ describe CouchPotato::RSpec::MapReduceToMatcher do
   end
 end
 
-describe CouchPotato::RSpec::ListAsMatcher do
-  before(:each) do
-    @view_spec = double(: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
-    expect(@view_spec).to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
-  end
-
-  it "should not pass if the function does not return the expected json" do
-    expect(@view_spec).not_to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
-  end
-
-  it "should work with date values" do
-    spec = double(:list_function => "function() { send(JSON.stringify([{date: new Date(1368802800000)}])); }")
-    expect(spec).to 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
-      expect {
-        expect(@view_spec).to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello there'}])
-      }.to 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
-      expect {
-        expect(@view_spec).not_to list({'rows' => [{:text => 'hello'}]}).as([{'text' => 'hello world'}])
-      }.to raise_error('Expected to not list as [{"text"=>"hello world"}] but did.')
-    end
-  end
-end

data/spec/unit/view_query_spec.rb

@@ -8,6 +8,11 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     CouchPotato::View::ViewQuery.clear_cache
   end
 
+  after(:each) do
+    CouchPotato::Config.single_design_document = false
+    CouchPotato::Config.digest_view_names = false
+  end
+
   it 'does not pass a key if conditions are empty' do
     expect(db).to receive(:view).with(anything, {})
     CouchPotato::View::ViewQuery.new(db, '', {:view0 => {}}).query_view!
@@ -16,14 +21,13 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
   it 'updates a view if it does not exist' do
     expect(db).to receive(:save_doc).with(
       {
-        'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}},
-        'lists' => {},
+        'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
         "_id" => "_design/design",
         "language" => "javascript"
         }
     )
 
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, {'test' => "<lib_code>"}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}).query_view!
   end
 
   it 'only updates a view once' do
@@ -50,33 +54,19 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     expect(db).to receive(:save_doc).with(
       {
         'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
-        'lists' => {}, "_id" => "_design/design", "language" => "erlang"
+        "_id" => "_design/design", "language" => "erlang"
       }
     )
 
     CouchPotato::View::ViewQuery.new(db, 'design',
       {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}},
-      nil, nil, :erlang).query_view!
+      :erlang).query_view!
   end
 
   it "does not update a view when the views object haven't changed" do
     allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}})
     expect(db).not_to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, nil).query_view!
-  end
-
-  it "does not update a view when the list function hasn't changed" do
-    allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}, 'lists' => {'list0' => '<list_code>'}})
-    expect(db).not_to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list0 => '<list_code>').query_view!
-  end
-
-  it "does not update a view when the lib function hasn't changed" do
-    allow(db).to receive(:get).and_return({'views' => {'view' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}, 'lib' => {'test' => '<lib_code>'}}})
-
-    expect(db).not_to receive(:save_doc)
-
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}, nil, {'test' => "<lib_code>"}).query_view!
+    CouchPotato::View::ViewQuery.new(db, 'design', {:view => {:map => '<map_code>', :reduce => '<reduce_code>'}}).query_view!
   end
 
   it 'updates a view when the map function has changed' do
@@ -91,88 +81,28 @@ describe CouchPotato::View::ViewQuery, 'query_view!' do
     CouchPotato::View::ViewQuery.new(db, 'design', :view3 => {:map => '<new map_code>'}).query_view!
   end
 
-  it 'updates a view when the lib hash has changed' do
-    allow(db).to receive(:get).and_return({'views' => {'view4' => {'map' => '<map_code>'}}}, 'lib' => {'test' => "<test_lib>"})
-
-    expect(db).to receive(:save_doc)
-
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view4 => {:map => '<map_code>'}}, nil, {:test => "<test_lib>"}).query_view!
-  end
-
-  it "doesn't override libs with different names" do
-    allow(db).to receive(:get).and_return({'views' => {'view5' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}})
-    expect(db).to receive(:save_doc).with({
-      'views' => {
-        'view5' => {'map' => '<map_code>'},
-        'lib' => {'test' => '<test_lib>', 'test1' => '<test1_lib>'}
-      }
-    })
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view5 => {:map => '<map_code>'}}, nil, {'test1' => '<test1_lib>'}).query_view!
-  end
-
-  it 'overrides libs with the same name' do
-    allow(db).to receive(:get).and_return({'views' => {'view6' => {'map' => '<map_code>'}, 'lib' => {'test' => "<test_lib>"}}})
-
-    expect(db).to receive(:save_doc).with({
-      'views' => {
-        'view6' => {'map' => '<map_code>'},
-        'lib' => {'test' => '<test1_lib>'}
-      },
-    })
-
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view6 => {:map => '<map_code>'}}, nil, {'test' => '<test1_lib>'}).query_view!
-  end
-
-  it 'does not pass in reduce or lib keys if there is no lib or reduce object' do
-    allow(db).to receive(:get).and_return({'views' => {}})
-    expect(db).to receive(:save_doc).with({'views' => {'view7' => {'map' => '<map code>'}}})
-    CouchPotato::View::ViewQuery.new(db, 'design', :view7 => {:map => '<map code>', :reduce => nil}).query_view!
-  end
-
   it 'updates a view when the reduce function has changed' do
     allow(db).to receive(:get).and_return({'views' => {'view8' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}})
     expect(db).to receive(:save_doc)
     CouchPotato::View::ViewQuery.new(db, 'design', :view8 => {:map => '<map_code>', :reduce => '<new reduce_code>'}).query_view!
   end
 
-  it 'updates a view when the list function has changed' do
-    allow(db).to receive(:get).and_return({
-      'views' => {'view9' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
-      'lists' => {'list1' => '<list_code>'}
-      })
-    expect(db).to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view9 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
-  end
+  it 'adds a digest of all views to the design document if single_design_doc is true' do
+    CouchPotato::Config.single_design_document = true
+    CouchPotato::Config.digest_view_names = true
 
-  it "updates a view when there wasn't a list function but now there is one" do
-    allow(db).to receive(:get).and_return({
-      'views' => {'view10' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
-      })
-    expect(db).to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view10 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!
-  end
-
-  it "does not update a view when there is a list function but no list function is passed" do
-    allow(db).to receive(:get).and_return({
-      'views' => {'view11' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}},
-      'lists' => {'list1' => '<list_code>'}
-      })
-    expect(db).not_to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view11 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
-  end
-
-  it "does not update a view when there were no lists before and no list function is passed" do
-    allow(db).to receive(:get).and_return({
-      'views' => {'view12' => {'map' => '<map_code>', 'reduce' => '<reduce_code>'}}
-      })
-    expect(db).not_to receive(:save_doc)
-    CouchPotato::View::ViewQuery.new(db, 'design', {:view12 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, {}).query_view!
-  end
+    allow(db).to receive(:get).and_return(nil)
+    allow(db).to receive(:save_doc).and_return(true)
+    view_class = double('view_class',
+      views: {view: {map: '<map_code>'}},
+      execute_view: double('view_spec', view_name: 'view', map_function: '<map_code>', reduce_function: nil))
+    allow(CouchPotato).to receive(:views).and_return([view_class])
 
-  it "queries the database directly when querying a list" do
-    allow(db).to receive(:name){'my_database'}
+    CouchPotato::View::ViewQuery.new(
+      db, 
+      'couch_potato',
+      {:view => {:map => '<map_code>'}}).query_view!
 
-    expect(db.connection).to receive(:get).with('/my_database/_design/my_design/_list/list1/view13?key=1')
-    CouchPotato::View::ViewQuery.new(db, 'my_design', {:view13 => {:map => '<map_code>', :reduce => '<reduce_code>'}}, :list1 => '<new_list_code>').query_view!(:key => 1)
+    expect(db).to have_received(:save_doc).with(hash_including({"_id" => "_design/couch_potato-56d286b4f0cd3a50fdd2ad428034d08a6483311539f7e138c45e781611b9dbbc"}))
   end
-end
+end

data/spec/view_updates_spec.rb

@@ -7,8 +7,27 @@ describe "automatic view updates" do
   end
   
   it "should update a view that doesn't match the given functions" do
-    CouchPotato::View::ViewQuery.new(@db, 'test_design1', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view! # create view
-    CouchPotato::View::ViewQuery.new(@db, 'test_design1', {'test_view' => {:map => 'function(doc) {emit(doc.id, null)}', :reduce => 'function(key, values) {return sum(values)}'}}, nil).query_view!
+    CouchPotato::View::ViewQuery.new(
+      @db, 
+      'test_design1', {
+        'test_view' => {
+          :map => 'function(doc) { }',
+          :reduce => 'function(key, values) { return []; }'
+        }
+      }
+    ).query_view! # create view
+    CouchPotato::View::ViewQuery.clear_cache
+    CouchPotato::View::ViewQuery.new(
+      @db,
+      'test_design1', 
+      {
+        'test_view' => {
+          :map => 'function(doc) {emit(doc.id, null)}',
+          :reduce => 'function(key, values) {return sum(values)}'
+        }
+      }
+    ).query_view!
+
     expect(CouchPotato.database.load('_design/test_design1')['views']['test_view']).to eq({
       'map' => 'function(doc) {emit(doc.id, null)}',
       'reduce' => 'function(key, values) {return sum(values)}'
@@ -16,9 +35,38 @@ describe "automatic view updates" do
   end
   
   it "should only update a view once to avoid writing the view for every request" do
-    CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view! # create view
-    CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {emit(doc.id, null)}', :reduce => 'function(key, values) {return sum(values)}'}}, nil).query_view!
-    CouchPotato::View::ViewQuery.new(@db, 'test_design2', {'test_view' => {:map => 'function(doc) {}', :reduce => 'function() {}'}}, nil).query_view!
+    CouchPotato::View::ViewQuery.new(
+      @db,
+      'test_design2',
+      {
+        'test_view' => {
+          :map => 'function(doc) {}',
+          :reduce => 'function() {}'
+        }
+      }
+    ).query_view! # create view
+    CouchPotato::View::ViewQuery.clear_cache
+    CouchPotato::View::ViewQuery.new(
+      @db,
+      'test_design2',
+      {
+        'test_view' => {
+          :map => 'function(doc) {emit(doc.id, null)}',
+          :reduce => 'function(key, values) {return sum(values)}'
+        }
+      }
+    ).query_view!
+    CouchPotato::View::ViewQuery.new(
+      @db,
+      'test_design2',
+      {
+        'test_view' => {
+          :map => 'function(doc) {}',
+          :reduce => 'function() {}'
+        }
+      }
+    ).query_view!
+
     expect(CouchPotato.database.load('_design/test_design2')['views']['test_view']).to eq({
       'map' => 'function(doc) {emit(doc.id, null)}',
       'reduce' => 'function(key, values) {return sum(values)}'

data/spec/views_spec.rb

@@ -225,7 +225,7 @@ describe 'views' do
 
   describe 'with array as key' do
     it 'should create a map function with the composite key' do
-      expect(CouchPotato::View::ViewQuery).to receive(:new) do |_db, _design_name, view, _list|
+      expect(CouchPotato::View::ViewQuery).to receive(:new) do |_db, _design_name, view|
         expect(view['key_array_timeline'][:map]).to match(/emit\(\[doc\['time'\], doc\['state'\]\]/)
 
         double('view query', query_view!: { 'rows' => [] })
@@ -362,39 +362,6 @@ describe 'views' do
     end
   end
 
-  describe 'list functions' do
-    class Coworker
-      include CouchPotato::Persistence
-
-      property :name
-
-      view :all_with_list, key: :name, list: :append_doe
-      view :all, key: :name
-
-      list :append_doe, <<-JS
-        function(head, req) {
-          var row;
-          send('{"rows": [');
-          while(row = getRow()) {
-            row.doc.name = row.doc.name + ' doe';
-            send(JSON.stringify(row));
-          };
-          send(']}');
-        }
-      JS
-    end
-
-    it 'should use the list function declared at class level' do
-      @db.save! Coworker.new(name: 'joe')
-      expect(@db.view(Coworker.all_with_list).first.name).to eq('joe doe')
-    end
-
-    it 'should use the list function passed at runtime' do
-      @db.save! Coworker.new(name: 'joe')
-      expect(@db.view(Coworker.all(list: :append_doe)).first.name).to eq('joe doe')
-    end
-  end
-
   describe 'with stale views' do
     it 'does not return deleted documents' do
       build = Build.new