couch_potato 1.7.0 → 1.10.1

data/spec/views_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class Build
@@ -5,20 +7,35 @@ class Build
 
   property :state
   property :time
-  property :type, :type => String, :default => 'Build'
-
-  view :timeline, :key => :time
-  view :count, :key => :time, :reduce => true
-  view :minimal_timeline, :key => :time, :properties => [:state], :type => :properties
-  view :key_array_timeline, :key => [:time, :state]
-  view :custom_timeline, :map => "function(doc) { emit(doc._id, {state: 'custom_' + doc.state}); }", :type => :custom
-  view :custom_timeline_returns_docs, :map => "function(doc) { emit(doc._id, null); }", :include_docs => true, :type => :custom
-  view :custom_with_reduce, :map => "function(doc) {if(doc.foreign_key) {emit(doc.foreign_key, 1);} else {emit(doc._id, 1)}}", :reduce => "function(key, values) {return({\"count\": sum(values)});}", :group => true, :type => :custom
-  view :custom_count_with_reduce, :map => "function(doc) {if(doc.foreign_key) {emit(doc.foreign_key, 1);} else {emit(doc._id, 1)}}", :reduce => "function(key, values) {return(sum(values));}", :group => true, :type => :custom
-  view :raw, :type => :raw, :map => "function(doc) {emit(doc._id, doc.state)}"
-  view :filtered_raw, :type => :raw, :map => "function(doc) {emit(doc._id, doc.state)}", :results_filter => lambda{|res| res['rows'].map{|row| row['value']}}
-  view :with_view_options, :group => true, :key => :time
-  view :all, :map => "function(doc) { if (doc && doc.type == 'Build') emit(doc._id, 1); }", :include_docs => true, :type => :custom
+  property :type, type: String, default: 'Build'
+
+  view :timeline, key: :time
+  view :count, key: :time, reduce: true
+  view :minimal_timeline, key: :time, properties: [:state], type: :properties
+  view :key_array_timeline, key: %i[time state]
+  view :custom_timeline, map: "function(doc) { emit(doc._id, {state: 'custom_' + doc.state}); }", type: :custom
+  view :custom_timeline_returns_docs, map: 'function(doc) { emit(doc._id, null); }', include_docs: true, type: :custom
+  view :custom_with_reduce, map: 'function(doc) {if(doc.foreign_key) {emit(doc.foreign_key, 1);} else {emit(doc._id, 1)}}', reduce: 'function(key, values) {return({"count": sum(values)});}', group: true, type: :custom
+  view :custom_count_with_reduce, map: 'function(doc) {if(doc.foreign_key) {emit(doc.foreign_key, 1);} else {emit(doc._id, 1)}}', reduce: 'function(key, values) {return(sum(values));}', group: true, type: :custom
+  view :raw, type: :raw, map: 'function(doc) {emit(doc._id, doc.state)}'
+  view :filtered_raw, type: :raw, map: 'function(doc) {emit(doc._id, doc.state)}', results_filter: ->(res) { res['rows'].map { |row| row['value'] } }
+  view :with_view_options, group: true, key: :time
+  view :all, map: "function(doc) { if (doc && doc.type == 'Build') emit(doc._id, 1); }", include_docs: true, type: :custom
+
+  module TimesToInt
+    def times_to_int
+      docs.map { |doc| doc.time.to_i }
+    end
+  end
+  view :flex_with_key, type: :flex, key: :time, extend_results: TimesToInt
+  view :flex_with_custom,
+       type: :flex,
+       map: <<~JS,
+         function(doc) {
+           emit(doc.time, 1);
+         }
+       JS
+       reduce: '_sum'
 end
 
 class CustomBuild < Build
@@ -30,8 +47,8 @@ class ErlangBuild
   property :name
   property :code
 
-  view :by_name, :key => :name, :language => :erlang
-  view :by_name_and_code, :key => [:name, :code], :language => :erlang
+  view :by_name, key: :name, language: :erlang
+  view :by_name_and_code, key: %i[name code], language: :erlang
 end
 
 describe 'views' do
@@ -42,7 +59,7 @@ describe 'views' do
 
   context 'in erlang' do
     it 'builds views with single keys' do
-      build = ErlangBuild.new(:name => 'erlang')
+      build = ErlangBuild.new(name: 'erlang')
       @db.save_document build
 
       results = @db.view(ErlangBuild.by_name('erlang'))
@@ -50,98 +67,98 @@ describe 'views' do
     end
 
     it 'does not crash couchdb when a document does not have the key' do
-      build = {'ruby_class' => 'ErlangBuild'}
+      build = { 'ruby_class' => 'ErlangBuild' }
       @db.couchrest_database.save_doc build
 
-      results = @db.view(ErlangBuild.by_name(:key => nil))
+      results = @db.view(ErlangBuild.by_name(key: nil))
       expect(results.size).to eq(1)
     end
 
     it 'builds views with composite keys' do
-      build = ErlangBuild.new(:name => 'erlang', :code => '123')
+      build = ErlangBuild.new(name: 'erlang', code: '123')
       @db.save_document build
 
-      results = @db.view(ErlangBuild.by_name_and_code(['erlang', '123']))
+      results = @db.view(ErlangBuild.by_name_and_code(%w[erlang 123]))
       expect(results).to eq([build])
     end
 
     it 'can reduce over erlang views' do
-      build = ErlangBuild.new(:name => 'erlang')
+      build = ErlangBuild.new(name: 'erlang')
       @db.save_document build
 
-      results = @db.view(ErlangBuild.by_name(:reduce => true))
+      results = @db.view(ErlangBuild.by_name(reduce: true))
       expect(results).to eq(1)
     end
   end
 
-  it "should return instances of the class" do
-    @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
+  it 'should return instances of the class' do
+    @db.save_document Build.new(state: 'success', time: '2008-01-01')
     results = @db.view(Build.timeline)
     expect(results.map(&:class)).to eq([Build])
   end
 
-  it "should return the ids if there document was not included" do
-    build = Build.new(:state => 'success', :time => '2008-01-01')
+  it 'should return the ids if there document was not included' do
+    build = Build.new(state: 'success', time: '2008-01-01')
     @db.save_document build
-    results = @db.view(Build.timeline(:include_docs => false))
+    results = @db.view(Build.timeline(include_docs: false))
     expect(results).to eq([build.id])
   end
 
-  it "should pass the view options to the view query" do
+  it 'should pass the view options to the view query' do
     query = double 'query'
     allow(CouchPotato::View::ViewQuery).to receive(:new).and_return(query)
-    expect(query).to receive(:query_view!).with(hash_including(:key => 1)).and_return('rows' => [])
-    @db.view Build.timeline(:key => 1)
+    expect(query).to receive(:query_view!).with(hash_including(key: 1)).and_return('rows' => [])
+    @db.view Build.timeline(key: 1)
   end
 
   it "should not return documents that don't have a matching JSON.create_id" do
-    CouchPotato.couchrest_database.save_doc({:time => 'x'})
+    CouchPotato.couchrest_database.save_doc({ time: 'x' })
     expect(@db.view(Build.timeline)).to eq([])
   end
 
-  it "should count documents" do
-    @db.save_document! Build.new(:state => 'success', :time => '2008-01-01')
-    expect(@db.view(Build.count(:reduce => true))).to eq(1)
+  it 'should count documents' do
+    @db.save_document! Build.new(state: 'success', time: '2008-01-01')
+    expect(@db.view(Build.count(reduce: true))).to eq(1)
   end
 
-  it "should count zero documents" do
-    expect(@db.view(Build.count(:reduce => true))).to eq(0)
+  it 'should count zero documents' do
+    expect(@db.view(Build.count(reduce: true))).to eq(0)
   end
 
-  describe "with multiple keys" do
-    it "should return the documents with matching keys" do
-      build = Build.new(:state => 'success', :time => '2008-01-01')
+  describe 'with multiple keys' do
+    it 'should return the documents with matching keys' do
+      build = Build.new(state: 'success', time: '2008-01-01')
       @db.save! build
-      expect(@db.view(Build.timeline(:keys => ['2008-01-01']))).to eq([build])
+      expect(@db.view(Build.timeline(keys: ['2008-01-01']))).to eq([build])
     end
 
-    it "should not return documents with non-matching keys" do
-      build = Build.new(:state => 'success', :time => '2008-01-01')
+    it 'should not return documents with non-matching keys' do
+      build = Build.new(state: 'success', time: '2008-01-01')
       @db.save! build
-      expect(@db.view(Build.timeline(:keys => ['2008-01-02']))).to be_empty
+      expect(@db.view(Build.timeline(keys: ['2008-01-02']))).to be_empty
     end
   end
 
-  describe "properties defined" do
-    it "assigns the configured properties" do
+  describe 'properties defined' do
+    it 'assigns the configured properties' do
       CouchPotato.couchrest_database.save_doc(:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build')
       expect(@db.view(Build.minimal_timeline).first.state).to eql('success')
     end
 
-    it "does 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')
       expect(@db.view(Build.minimal_timeline).first.time).to be_nil
     end
 
-    it "assigns 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']
       expect(@db.view(Build.minimal_timeline).first._id).to eql(id)
     end
   end
 
-  describe "no properties defined" do
-    it "should assign all properties to the objects by default" do
-      id = CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build'})['id']
+  describe 'no properties defined' do
+    it 'should assign all properties to the objects by default' do
+      id = CouchPotato.couchrest_database.save_doc({ :state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build' })['id']
       result = @db.view(Build.timeline).first
       expect(result.state).to eq('success')
       expect(result.time).to eq('2008-01-01')
@@ -149,116 +166,210 @@ describe 'views' do
     end
   end
 
-  describe "map function given" do
-    it "should still return instances of the class" do
-      CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+  describe 'map function given' do
+    it 'should still return instances of the class' do
+      CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
       expect(@db.view(Build.custom_timeline).map(&:class)).to eq([Build])
     end
 
-    it "should assign the properties from the value" do
-      CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+    it 'should assign the properties from the value' do
+      CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
       expect(@db.view(Build.custom_timeline).map(&:state)).to eq(['custom_success'])
     end
 
-    it "should assign the id" do
-      doc = CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+    it 'should assign the id' do
+      doc = CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
       expect(@db.view(Build.custom_timeline).map(&:_id)).to eq([doc['id']])
     end
 
-    it "should leave the other properties blank" do
-      CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+    it 'should leave the other properties blank' do
+      CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
       expect(@db.view(Build.custom_timeline).map(&:time)).to eq([nil])
     end
 
-    describe "that returns null documents" do
-      it "should return instances of the class" do
-        CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+    describe 'that returns null documents' do
+      it 'should return instances of the class' do
+        CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
         expect(@db.view(Build.custom_timeline_returns_docs).map(&:class)).to eq([Build])
       end
 
-      it "should assign the properties from the value" do
-        CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01'})
+      it 'should assign the properties from the value' do
+        CouchPotato.couchrest_database.save_doc({ state: 'success', time: '2008-01-01' })
         expect(@db.view(Build.custom_timeline_returns_docs).map(&:state)).to eq(['success'])
       end
 
-      it "should still return instance of class if document included JSON.create_id" do
-        CouchPotato.couchrest_database.save_doc({:state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => "Build"})
+      it 'should still return instance of class if document included JSON.create_id' do
+        CouchPotato.couchrest_database.save_doc({ :state => 'success', :time => '2008-01-01', JSON.create_id.to_sym => 'Build' })
         view_data = @db.view(Build.custom_timeline_returns_docs)
         expect(view_data.map(&:class)).to eq([Build])
         expect(view_data.map(&:state)).to eq(['success'])
       end
     end
 
-    describe "additional reduce function given" do
-      it "should still assign the id" do
+    describe 'additional reduce function given' do
+      it 'should still assign the id' do
         doc = CouchPotato.couchrest_database.save_doc({})
-        CouchPotato.couchrest_database.save_doc({:foreign_key => doc['id']})
+        CouchPotato.couchrest_database.save_doc({ foreign_key: doc['id'] })
         expect(@db.view(Build.custom_with_reduce).map(&:_id)).to eq([doc['id']])
       end
 
-      describe "when the additional reduce function is a typical count" do
-        it "should parse the reduce count" do
+      describe 'when the additional reduce function is a typical count' do
+        it 'should parse the reduce count' do
           doc = CouchPotato.couchrest_database.save_doc({})
-          CouchPotato.couchrest_database.save_doc({:foreign_key => doc['id']})
-          expect(@db.view(Build.custom_count_with_reduce(:reduce => true))).to eq(2)
+          CouchPotato.couchrest_database.save_doc({ foreign_key: doc['id'] })
+          expect(@db.view(Build.custom_count_with_reduce(reduce: true))).to eq(2)
         end
       end
     end
   end
 
-  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|
+  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(view['key_array_timeline'][:map]).to match(/emit\(\[doc\['time'\], doc\['state'\]\]/)
 
-        double('view query', :query_view! => {'rows' => []})
+        double('view query', query_view!: { 'rows' => [] })
       end
       @db.view Build.key_array_timeline
     end
   end
 
-  describe "raw view" do
-    it "should return the raw data" do
-      @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
+  describe 'raw view' do
+    it 'should return the raw data' do
+      @db.save_document Build.new(state: 'success', time: '2008-01-01')
       expect(@db.view(Build.raw)['rows'][0]['value']).to eq('success')
     end
 
-    it "should return filtred raw data" do
-      @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
+    it 'should return filtred raw data' do
+      @db.save_document Build.new(state: 'success', time: '2008-01-01')
       expect(@db.view(Build.filtered_raw)).to eq(['success'])
     end
 
-    it "should pass view options declared in the view declaration to the query" do
-     view_query = double 'view_query'
-     allow(CouchPotato::View::ViewQuery).to receive(:new).and_return(view_query)
-     expect(view_query).to receive(:query_view!).with(hash_including(:group => true)).and_return({'rows' => []})
-     @db.view(Build.with_view_options)
+    it 'should pass view options declared in the view declaration to the query' do
+      view_query = double 'view_query'
+      allow(CouchPotato::View::ViewQuery).to receive(:new).and_return(view_query)
+      expect(view_query).to receive(:query_view!).with(hash_including(group: true)).and_return({ 'rows' => [] })
+      @db.view(Build.with_view_options)
+    end
+  end
+
+  describe 'flex view' do
+    it 'supports a given key' do
+      @db.save_document Build.new(id: 'b1', state: 'success', time: '2008-01-01')
+      @db.save_document Build.new(state: 'success', time: '2008-01-02')
+
+      rows = @db.view(Build.flex_with_key('2008-01-01')).raw['rows']
+
+      expect(rows.map { |row| row['id'] }).to eq(['b1'])
+    end
+
+    it 'supports a given map function' do
+      @db.save_document Build.new(id: 'b1', time: '2008-01-01')
+      @db.save_document Build.new(time: '2008-01-02')
+
+      rows = @db.view(Build.flex_with_custom('2008-01-01')).raw['rows']
+
+      expect(rows.map { |row| row['id'] }).to eq(['b1'])
+    end
+
+    it 'supports a given reduce function' do
+      @db.save_document Build.new(time: '2008-01-01')
+      @db.save_document Build.new(time: '2008-01-02')
+
+      raw = @db.view(Build.flex_with_custom(reduce: true)).raw
+
+      expect(raw['rows'][0]['value']).to eq(2)
+    end
+
+    it 'returns ids' do
+      @db.save_document Build.new(id: 'b1')
+      @db.save_document Build.new(id: 'b2')
+
+      ids = @db.view(Build.flex_with_key).ids
+
+      expect(ids).to eq(%w[b1 b2])
+    end
+
+    it 'returns keys' do
+      @db.save_document Build.new(time: '1')
+      @db.save_document Build.new(time: '2')
+
+      ids = @db.view(Build.flex_with_key).keys
+
+      expect(ids).to eq(%w[1 2])
+    end
+
+    it 'returns values' do
+      @db.save_document Build.new(time: '1')
+      @db.save_document Build.new(time: '2')
+
+      ids = @db.view(Build.flex_with_key).values
+
+      expect(ids).to eq([1, 1])
+    end
+
+    it 'returns docs' do
+      @db.save_document Build.new(time: '1')
+
+      docs = @db.view(Build.flex_with_key(include_docs: true)).docs
+
+      expect(docs.map(&:time)).to eq(['1'])
+      expect(docs.first.database).to eq(@db)
+    end
+
+    it 'returns the value of reduce' do
+      @db.save_document Build.new(time: '1')
+      @db.save_document Build.new(time: '1')
+
+      value = @db.view(Build.flex_with_key(reduce: true)).reduce_value
+
+      expect(value).to eq(2)
+    end
+
+    it 'returns the raw results' do
+      @db.save_document Build.new(id: 'b1', time: '1')
+
+      raw = @db.view(Build.flex_with_key).raw
+
+      expect(raw).to eq(
+        'total_rows' => 1, 'offset' => 0,
+        'rows' => [{ 'id' => 'b1', 'key' => '1', 'value' => 1 }]
+      )
+    end
+
+    it 'returns the results via a custom method' do
+      @db.save_document Build.new(id: 'b1', time: '100')
+      @db.save_document Build.new(id: 'b2', time: '200')
+
+      custom = @db.view(Build.flex_with_key(include_docs: true)).times_to_int
+
+      expect(custom).to eq([100, 200])
     end
   end
 
-  describe "inherited views" do
-    it "should support parent views for objects of the subclass" do
-      @db.save_document CustomBuild.new(:state => 'success', :time => '2008-01-01')
+  describe 'inherited views' do
+    it 'should support parent views for objects of the subclass' do
+      @db.save_document CustomBuild.new(state: 'success', time: '2008-01-01')
       expect(@db.view(CustomBuild.timeline).size).to eq(1)
       expect(@db.view(CustomBuild.timeline).first).to be_kind_of(CustomBuild)
     end
 
-    it "should return instances of subclasses as well if a special view exists" do
-      @db.save_document Build.new(:state => 'success', :time => '2008-01-01')
-      @db.save_document CustomBuild.new(:state => 'success', :time => '2008-01-01', :server => 'Jenkins')
+    it 'should return instances of subclasses as well if a special view exists' do
+      @db.save_document Build.new(state: 'success', time: '2008-01-01')
+      @db.save_document CustomBuild.new(state: 'success', time: '2008-01-01', server: 'Jenkins')
       results = @db.view(Build.all)
       expect(results.map(&:class)).to eq([CustomBuild, Build])
     end
   end
 
-  describe "list functions" do
+  describe 'list functions' do
     class Coworker
       include CouchPotato::Persistence
 
       property :name
 
-      view :all_with_list, :key => :name, :list => :append_doe
-      view :all, :key => :name
+      view :all_with_list, key: :name, list: :append_doe
+      view :all, key: :name
 
       list :append_doe, <<-JS
         function(head, req) {
@@ -273,14 +384,14 @@ describe 'views' do
       JS
     end
 
-    it "should use the list function declared at class level" do
-      @db.save! Coworker.new(:name => 'joe')
+    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')
+    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
 
@@ -291,7 +402,7 @@ describe 'views' do
       @db.view(Build.timeline)
       @db.destroy build
 
-      expect(@db.view(Build.timeline(:stale => 'ok'))).to be_empty
+      expect(@db.view(Build.timeline(stale: 'ok'))).to be_empty
     end
   end
 end