elasticsearch-facetedsearch 0.0.4

data/spec/lib/elasticsearch/faceted_search/facet_group_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+module Elasticsearch
+  module FacetedSearch
+    describe FacetGroup do
+      let(:objects) { {"_type"=>"terms", "missing"=>0, "total"=>476, "other"=>0, "terms"=>[{"term"=>"t", "count"=>476}, {"term"=>"f", "count"=>5}, {"term"=>"F", "count"=>476}]} }
+      let(:key) { 'hd' }
+      let(:search) { Object.new }
+      let(:model) { described_class.new(search, key, objects) }
+
+      describe "#initializer" do
+        it "sets search" do
+          expect(model.search).to eq(search)
+        end
+        it "symbolizes the key" do
+          expect(key).to be_a(String)
+          expect(model.key).to eq(:hd)
+        end
+        it "sets the objects from the terms key" do
+          expect(model.objects).to eq({"t"=>476, "f"=>481})
+        end
+      end
+
+      describe "#items" do
+        it "builds the items" do
+          expect(model).to receive(:build_items).and_call_original
+          model.items
+        end
+      end
+
+      describe "#title" do
+        it "returns title set in class" do
+          expect(search).to receive(:class_facets) { {hd: {title: 'HD Media'}} }
+          expect(model.title).to eq('HD Media')
+        end
+        it "returns the key humanized if no key exists" do
+          expect(search).to receive(:class_facets) { {} }
+          expect(model.title).to eq('Hd')
+        end
+      end
+
+      describe "#selected_values" do
+        describe ":and" do
+          before(:each) do
+            expect(model).to receive(:operator).at_least(:once) { ',' }
+          end
+          it "returns array of selected items" do
+            expect(search).to receive(:search_params) { {hd: 'F,T'} }
+            expect(model.selected_values).to eq(['f','t'])
+          end
+          it "returns nothing when no key exists" do
+            expect(search).to receive(:search_params) { {hello: '1,2'} }
+            expect(model.selected_values).to eq([])
+          end
+          pending "only returns valid keys" do
+            expect(search).to receive(:search_params) { {hd: 'F,T,L'} }
+            expect(model.selected_values).to eq(['f','t'])
+          end
+        end
+
+        describe ":or" do
+          before(:each) do
+            expect(model).to receive(:operator).at_least(:once) { '|' }
+          end
+          it "returns array of selected items" do
+            expect(search).to receive(:search_params) { {hd: 'F|T'} }
+            expect(model.selected_values).to eq(['f','t'])
+          end
+          it "returns nothing when no key exists" do
+            expect(search).to receive(:search_params) { {hello: '1|2'} }
+            expect(model.selected_values).to eq([])
+          end
+          pending "only returns valid keys" do
+            expect(search).to receive(:search_params) { {hd: 'F|T|L'} }
+            expect(model.selected_values).to eq(['f','t'])
+          end
+        end
+
+        describe "nil" do
+          before(:each) do
+            expect(model).to receive(:operator).at_least(:once) { nil }
+          end
+          it "returns array of selected items" do
+            expect(search).to receive(:search_params) { {hd: 'F|T'} }
+            expect(model.selected_values).to eq('f|t')
+          end
+          it "returns nothing when no key exists" do
+            expect(search).to receive(:search_params) { {hello: '1|2'} }
+            expect(model.selected_values).to eq('')
+          end
+          pending "only returns valid keys" do
+            expect(search).to receive(:search_params) { {hd: 'F|T|L'} }
+            expect(model.selected_values).to eq('f|t')
+          end
+        end
+      end
+
+      describe "#group_params" do
+        describe ":and" do
+          before(:each) do
+            expect(model).to receive(:operator) { ',' }
+          end
+
+          it "returns empty string when no key exists" do
+            expect(search).to receive(:search_params) { {} }
+            expect(model.group_params).to eq([])
+          end
+          it "fetches the groups key" do
+            expect(search).to receive(:search_params) { {hd: '1,3', another: '2'} }
+            expect(model.group_params).to eq(['1','3'])
+          end
+        end
+        describe ":or" do
+          before(:each) do
+            expect(model).to receive(:operator) { '|' }
+          end
+
+          it "returns empty string when no key exists" do
+            expect(search).to receive(:search_params) { {} }
+            expect(model.group_params).to eq([])
+          end
+          it "fetches the groups key" do
+            expect(search).to receive(:search_params) { {hd: '1|3', another: '2'} }
+            expect(model.group_params).to eq(['1','3'])
+          end
+        end
+      end
+
+      describe "#group_params_string" do
+        it "returns empty string when no key exists" do
+          expect(search).to receive(:search_params) { {} }
+          expect(model.group_params_string).to eq('')
+        end
+        it "fetches the groups key" do
+          expect(search).to receive(:search_params) { {hd: '1', another: '2'} }
+          expect(model.group_params_string).to eq('1')
+        end
+      end
+
+      describe "#type" do
+        it "returns the class_facets's #type" do
+          expect(search).to receive(:class_facets) { {hd: {type: 'exclusive_or'}} }
+          expect(model.type).to eq('exclusive_or')
+        end
+        it "returns nil if raised" do
+          expect(search).to receive(:class_facets) { raise "Boom!" }
+          expect(model.type).to be_nil
+        end
+      end
+
+      describe "#operator" do
+        it "returns nil with a bad key" do
+          expect(model).to receive(:operator_for) { }
+          expect(model.operator).to be_nil
+        end
+        it "returns , for :and" do
+          expect(model).to receive(:operator_for) { :and }
+          expect(model.operator).to eq(',')
+        end
+        it "returns | for :or" do
+          expect(model).to receive(:operator_for) { :or }
+          expect(model.operator).to eq('|')
+        end
+      end
+
+      describe "#build_items" do
+        it "is private" do
+          expect {
+            model.build_items
+          }.to raise_error(NoMethodError)
+        end
+        it "returns a group of FacetItems" do
+          expect(model.send(:build_items).all?{|x| x.is_a?(Elasticsearch::FacetedSearch::FacetItem)}).to eq(true)
+        end
+      end
+
+      describe "#terms_collection" do
+        it "is private" do
+          expect {
+            model.terms_collection
+          }.to raise_error(NoMethodError)
+        end
+        it "returns mapped_objects if search does not respond to 'key'_collection?" do
+          expect(model).to receive(:mapped_objects) { 'hi' }
+          expect(model.send(:terms_collection)).to eq('hi')
+        end
+        it "returns collection from facet" do
+          expect(search).to receive(:hd_collection) { [{id: 1}, {id: 2}] }
+          expect(model.send(:terms_collection)).to eq([{id: 1}, {id: 2}])
+        end
+      end
+
+      describe "#hit_count_mapping" do
+        before(:each) do
+          @items = [{"term"=>"t", "count"=>476}, {"term"=>"f", "count"=>5}, {"term"=>"F", "count"=>476}]
+        end
+        it "is private" do
+          expect {
+            model.hit_count_mapping(@items)
+          }.to raise_error(NoMethodError)
+        end
+        it "returns merged hashes" do
+          expect(model.send(:hit_count_mapping, @items)).to eq({"t"=>476, "f"=>481})
+        end
+      end
+    end
+  end
+end

data/spec/lib/elasticsearch/faceted_search/facet_item_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+module Elasticsearch
+  module FacetedSearch
+    describe FacetItem do
+      let(:item) { {id: 't', term: "Yes", count: 476} }
+      let(:key) { :hd }
+      let(:group) { Object.new }
+      let(:model) { described_class.new(group, item) }
+      let(:mappings) { Elasticsearch::FacetedSearch::FacetGroup::OPERATOR_MAPPING }
+
+      before(:each) do
+        allow(group).to receive(:key) { key }
+      end
+
+      describe "#initialize" do
+        it "sets #group" do
+          expect(model.group).to eq(group)
+        end
+        it "sets #object" do
+          expect(model.object.id).to eq(item[:id])
+          expect(model.object.term).to eq(item[:term])
+          expect(model.object.count).to eq(item[:count])
+        end
+      end
+
+      describe "#selected?" do
+        describe "as string" do
+          before(:each) do
+            expect(group).to receive(:group_params) { 't' }
+          end
+
+          it "returns true when id matches" do
+            expect(model.id).to eq('t')
+            expect(model.selected?).to eq(true)
+          end
+
+          it "returns false when id is not found" do
+            expect(model).to receive(:id) { 'fff' }
+            expect(model.selected?).to eq(false)
+          end
+
+        end
+        describe "as array" do
+          before(:each) do
+            expect(group).to receive(:group_params) { ['f','t'] }
+          end
+          it "returns true when id matches" do
+            expect(model.selected?).to eq(true)
+          end
+          it "returns false when id is not found" do
+            expect(model).to receive(:id) { 'fff' }
+            expect(model.selected?).to eq(false)
+          end
+        end
+      end
+
+      describe "#params_for" do
+        describe ":unselected" do
+          before(:each) do
+            expect(group).to receive(:group_params).at_least(:once) { ['f'] }
+            allow(group).to receive(:operator_mappings) { '|' }
+          end
+          it "calls add_multivalue when 'multivalue'" do
+            expect(group).to receive(:type) { 'multivalue' }
+            expect(model).to receive(:add_multivalue).and_call_original
+            model.params_for
+          end
+          it "calls add_multivalue(:and) when 'multivalue_and'" do
+            expect(group).to receive(:type) { 'multivalue_and' }
+            expect(model).to receive(:add_multivalue).with(:and).and_call_original
+            model.params_for
+          end
+          it "calls add_multivalue(:or) when 'multivalue_or'" do
+            expect(group).to receive(:type) { 'multivalue_or' }
+            expect(model).to receive(:add_multivalue).with(:or).and_call_original
+            model.params_for
+          end
+          it "calls add_singlevalue when 'exclusive_or'" do
+            expect(group).to receive(:type) { 'exclusive_or' }
+            expect(model).to receive(:add_singlevalue).and_call_original
+            model.params_for
+          end
+        end
+
+        describe ":selected" do
+          before(:each) do
+            expect(group).to receive(:group_params).at_least(:once) { ['f','t'] }
+            allow(group).to receive(:operator_mappings) { '|' }
+          end
+          it "calls remove_multivalue when 'multivalue'" do
+            expect(group).to receive(:type) { 'multivalue' }
+            expect(model).to receive(:remove_multivalue).and_call_original
+            model.params_for
+          end
+          it "calls remove_multivalue(:and) when 'multivalue_and'" do
+            expect(group).to receive(:type) { 'multivalue_and' }
+            expect(model).to receive(:remove_multivalue).with(:and).and_call_original
+            model.params_for
+          end
+          it "calls remove_multivalue(:or) when 'multivalue_or'" do
+            expect(group).to receive(:type) { 'multivalue_or' }
+            expect(model).to receive(:remove_multivalue).with(:or).and_call_original
+            model.params_for
+          end
+          it "calls remove_singlevalue when 'exclusive_or'" do
+            expect(group).to receive(:type) { 'exclusive_or' }
+            expect(model).to receive(:remove_singlevalue).and_call_original
+            model.params_for
+          end
+        end
+      end
+
+      describe "#remove_multivalue" do
+        describe ":and" do
+          it "moves a value but keeps the rest" do
+            expect(group).to receive(:operator_mappings).with(:and) { mappings[:and] }
+            expect(group).to receive(:group_params) { ['1','2','3'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:remove_multivalue, :and)).to eq({hd: "2#{mappings[:and]}3"})
+          end
+          it "returns an empty hash if params is empty" do
+            expect(group).to receive(:operator_mappings) { mappings[:and] }
+            expect(group).to receive(:group_params) { ['1'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:remove_multivalue, :and)).to eq({hd: nil})
+          end
+        end
+
+        describe ":or" do
+          it "moves a value but keeps the rest" do
+            expect(group).to receive(:operator_mappings).with(:or) { mappings[:or] }
+            expect(group).to receive(:group_params) { ['1','2','3'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:remove_multivalue, :or)).to eq({hd: "2#{mappings[:or]}3"})
+          end
+          it "returns an empty hash if params is empty" do
+            expect(group).to receive(:operator_mappings) { mappings[:and] }
+            expect(group).to receive(:group_params) { ['1'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:remove_multivalue, :or)).to eq({hd: nil})
+          end
+        end
+      end
+
+      describe "#remove_singlevalue" do
+        it "returns a single hash" do
+          expect(model.send(:remove_singlevalue)).to eq({hd: nil})
+        end
+      end
+
+      describe "#add_multivalue" do
+        describe ":and" do
+          it "adds a value to the array" do
+            expect(model).to receive(:operator_mappings).with(:and) { mappings[:and] }
+            expect(group).to receive(:group_params) { ['2','3'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:add_multivalue, :and)).to eq({hd: "2#{mappings[:and]}3#{mappings[:and]}1"})
+          end
+          it "returns a single hash if params is empty" do
+            expect(model).to receive(:operator_mappings) { mappings[:and] }
+            expect(group).to receive(:group_params) { [] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:add_multivalue, :and)).to eq({hd: "1"})
+          end
+        end
+
+        describe ":or" do
+          it "adds a value to the array" do
+            expect(model).to receive(:operator_mappings).with(:or) { mappings[:or] }
+            expect(group).to receive(:group_params) { ['2','3'] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:add_multivalue, :or)).to eq({hd: "2#{mappings[:or]}3#{mappings[:or]}1"})
+          end
+          it "returns a single hash if params is empty" do
+            expect(model).to receive(:operator_mappings) { mappings[:and] }
+            expect(group).to receive(:group_params) { [] }
+            expect(model).to receive(:id).at_least(:once) { 1 }
+            expect(model.send(:add_multivalue, :or)).to eq({hd: "1"})
+          end
+        end
+      end
+
+      describe "#add_singlevalue" do
+        it "returns a single k/v pair" do
+          expect(model.send(:add_singlevalue)).to eq({hd: 't'})
+        end
+      end
+
+      describe "#matches?" do
+        it "compares a value to #id" do
+          expect(model.send(:matches?, 't')).to eq(true)
+        end
+        it "typecasts both to a string" do
+          expect(model).to receive(:id) { 'false' }
+          expect(model.send(:matches?, false)).to eq(true)
+        end
+      end
+    end
+  end
+end

data/spec/lib/elasticsearch/faceted_search/pagination_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class DummyPaginatedFacets
+  include Elasticsearch::FacetedSearch::FacetBase
+  facet_exclusive_or(:hd, 'media_hd', 'HD Media')
+
+  def limit
+    11
+  end
+
+  #mock
+  def type
+    'type_here'
+  end
+
+  #mock
+  def filter_hd?
+  end
+
+  #mock
+  def hd_value
+    true
+  end
+end
+
+module Elasticsearch
+  module FacetedSearch
+    describe Pagination do
+      let(:model) { DummyPaginatedFacets.new({}) }
+
+      describe "#total_count" do
+        it "returns hits total from ES result" do
+          expect(model).to receive(:search) { {'hits' => { 'total' => 20 }} }
+          expect(model.total_count).to eq(20)
+        end
+      end
+
+      describe "#total_pages" do
+        it "returns total number of pages" do
+          expect(model).to receive(:total_count) { 25 }
+          expect(model.total_pages).to eq(3)
+        end
+      end
+
+      describe "#limit_value" do
+        it "returns the limit from model" do
+          expect(model.limit).to eq(11)
+        end
+      end
+    end
+  end
+end