CloudSesame 0.6.8 → 0.7.0

data/spec/cloud_sesame/query/ast/abstract/single_expression_operator_spec.rb

@@ -0,0 +1,70 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        describe SingleExpressionOperator do
+
+          let(:context) { {} }
+          let(:options) { {} }
+          let(:block) { Proc.new {} }
+
+          subject { SingleExpressionOperator.new(context, options, &block) }
+
+          it 'should be a type of operator' do
+            expect(MultiExpressionOperator.ancestors).to include(Operator)
+          end
+
+          describe '#child' do
+            it 'should be nil by default' do
+              expect(subject.child).to be_nil
+            end
+          end
+
+          describe '#is_for' do
+            it 'should forward the field and field options to it\'s child' do
+              subject.child = OpenStruct.new is_for: ""
+              expect(subject.child).to receive(:is_for).with(:test, :options)
+              subject.is_for :test, :options
+            end
+          end
+
+          describe '#<<' do
+            it 'should set the object as child' do
+              child = OpenStruct.new()
+              expect { subject << child }.to change{ subject.child }.from(nil).to(child)
+            end
+          end
+
+          describe '#compile' do
+            before {
+              subject.child = OpenStruct.new compile: ""
+              allow(subject.child).to receive(:compile).and_return(" ")
+            }
+            it 'should compile it\'s child and detailed set to false' do
+              expect(subject.child).to receive(:compile).with(SingleExpressionOperator::DETAILED)
+              subject.compile
+            end
+            context 'when theres boost options' do
+              it 'should include boost value in the compiled value' do
+                subject.options[:boost] = 1
+                expect(subject.compile).to include("boost=1")
+              end
+            end
+            context 'when theres no boost options' do
+              it 'should not include boost value in the compiled value' do
+                expect(subject.compile).to_not include("boost=")
+              end
+            end
+            context 'when theres a symbol' do
+              before { SingleExpressionOperator::SYMBOL = "test_symbol"}
+              it 'should include the symbol in the compiled value' do
+                expect(subject.compile).to include "(test_symbol"
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/cloud_sesame/query/ast/abstract/value_spec.rb

@@ -0,0 +1,118 @@
+module CloudSesame
+	module Query
+		module AST
+			module Abstract
+				describe Value do
+
+					subject { Value.new(raw_value) }
+
+					describe 'initialize' do
+						context 'given the value is not nil' do
+							let(:raw_value) { 1 }
+							it 'should accept and store a value' do
+								expect(subject.value).to eq raw_value
+							end
+							it 'should default changed to true' do
+								expect(subject.changed).to be_truthy
+							end
+						end
+						context 'given the value is nil' do
+							let(:raw_value) { nil }
+							it 'should accept and store a value' do
+								expect(subject.value).to eq raw_value
+							end
+							it 'should default changed to false' do
+								expect(subject.changed).to be_falsey
+							end
+						end
+					end
+
+					describe '#value setter' do
+						context 'given a different value' do
+							let(:raw_value) { 2 }
+							let(:new_value) { 1 }
+							before { subject.compile }
+							it 'should set changed to true' do
+								expect{ subject.value = new_value }.to change{ subject.changed }.from(be_falsey).to(be_truthy)
+							end
+							it 'should set the value' do
+								expect{ subject.value = new_value }.to change{ subject.value }.from(raw_value).to(new_value)
+							end
+						end
+						context 'given the same value' do
+							let(:raw_value) { 2 }
+							let(:new_value) { 2 }
+							before { subject.compile }
+							it 'should not set changed to true' do
+								expect{ subject.value = new_value }.to_not change{ subject.changed }.from(be_falsey)
+							end
+						end
+					end
+
+					describe '#compile' do
+						let(:raw_value) { 2 }
+						context 'the value is changed' do
+							it 'should compile the value' do
+								expect(subject).to receive(:recompile).with(raw_value)
+								subject.compile
+							end
+							it 'should update the compiled value' do
+								expect{ subject.compile }.to change{ subject.compiled }.to(raw_value)
+							end
+							it 'should toggle the changed status to false' do
+								expect{ subject.compile }.to change{ subject.changed }.from(true).to(false)
+							end
+						end
+						context 'the value is the same' do
+							before { subject.compile }
+							it 'should not recompile' do
+								expect(subject).to_not receive(:recompile)
+								subject.compile
+							end
+							it 'should not change the compiled value' do
+								expect{ subject.compile }.to_not change{ subject.compiled }
+							end
+						end
+					end
+
+					describe '#to_s' do
+						let(:raw_value) { 2 }
+						it 'should return the value in string format' do
+							expect(subject.to_s).to eq raw_value.to_s
+						end
+					end
+
+					describe '#==' do
+						context 'given a Value object' do
+							let(:raw_value) { 1 }
+							let(:value) { Value.new(raw_value) }
+							it 'should compare values based on their compiled value' do
+								expect(value).to receive(:compile).and_call_original
+								subject == value
+							end
+							it 'should return true if compiled values are the same' do
+								expect(subject == value).to be_truthy
+							end
+						end
+						context 'given a raw value' do
+							let(:raw_value) { double(:string) }
+							let(:value) { 1 }
+							it 'should compare the value with the raw value' do
+								expect(subject.value).to receive(:==).and_return(true)
+								subject == value
+							end
+							it 'should compare the value with the compiled value if raw value is different' do
+								response = double(:compiled_value)
+								expect(subject).to receive(:compile).and_return(response)
+								expect(response).to receive(:==)
+								subject == value
+							end
+						end
+					end
+
+
+				end
+			end
+		end
+	end
+end

data/spec/cloud_sesame/query/ast/and_spec.rb

@@ -4,7 +4,7 @@ module CloudSesame
       describe And do
 
         it 'should be a type of operator' do
-          expect(And.ancestors).to include(MultiExpressionOperator)
+          expect(And.ancestors).to include(Abstract::MultiExpressionOperator)
         end
 
         it 'should have symbol :and' do

data/spec/cloud_sesame/query/ast/or_spec.rb

@@ -4,7 +4,7 @@ module CloudSesame
       describe Or do
 
         it 'should be a type of operator' do
-          expect(Or.ancestors).to include(MultiExpressionOperator)
+          expect(Or.ancestors).to include(Abstract::MultiExpressionOperator)
         end
 
         it 'should have symbol :or' do

data/spec/cloud_sesame/query/ast/range_value_spec.rb

@@ -6,19 +6,13 @@ module CloudSesame
 				describe 'initialize' do
 					shared_examples 'initialize with initial value' do
 						it 'should be an array' do
-							expect(subject.data).to be_kind_of(Array)
+							expect(subject.value).to be_kind_of(Array)
 						end
 						it 'should not be empty' do
-							expect(subject.data).to_not be_empty
+							expect(subject.value).to_not be_empty
 						end
 						it 'should capture the range information' do
-							expect(subject.data).to eq data
-						end
-						context 'when begin and end value exists' do
-							it 'should convert begin and end value to Value' do
-								expect(subject.data[1]).to be_kind_of(Value) if data[1]
-								expect(subject.data[2]).to be_kind_of(Value) if data[2]
-							end
+							expect(subject.value).to eq data
 						end
 					end
 
@@ -37,7 +31,7 @@ module CloudSesame
 					context 'when given a range value in string format' do
 						{
 							"[0, nil}" => ['[', 0, nil, '}'],
-							"{, 100]" => ['{', nil, 100, ']'],
+							"{, 100]" => ['{', '', '100', ']'],
 						}.each do |before_value, after_value|
 							subject { RangeValue.new(before_value) }
 							let(:data) { after_value }
@@ -49,7 +43,7 @@ module CloudSesame
 						subject { RangeValue.new }
 						let(:data) { [] }
 						it 'should set the data to the default value' do
-							expect(subject.data).to eq ['{', nil, nil, '}']
+							expect(subject.value).to eq ['{', nil, nil, '}']
 						end
 					end
 				end

data/spec/cloud_sesame/query/builder_spec.rb

@@ -1,11 +1,17 @@
-require 'spec_helper'
+require_relative 'dsl/field_accessors_spec'
 
 module CloudSesame
   module Query
     describe Builder do
-      let(:client) { {} }
-      let(:searchable_class) { "Test" }
-      subject { Builder.new(client, searchable_class) }
+
+      it_behaves_like 'FieldAccessors' do
+        subject { Builder.new({}, "Searchable") }
+        before {
+            Builder.send(:include, DSL::FieldAccessors)
+            Domain::Block.send(:include, DSL::FieldAccessors)
+          allow(_scope).to receive(:context).and_return(context)
+        }
+      end
 
     end
   end

data/spec/cloud_sesame/query/domain/block_spec.rb

@@ -1,8 +1,23 @@
+require_relative '../dsl/field_accessors_spec'
+
 module CloudSesame
 	module Query
 		module Domain
 			describe Block do
 
+				# Module Specs
+				# =======================================
+				it_behaves_like 'FieldAccessors' do
+					let(:scope) { AST::Root.new(context, {}) }
+					subject { Block.new(self, context) }
+					before do
+						Block.send(:include, DSL::FieldAccessors)
+						subject.instance_variable_set(:@_scopes, [scope])
+					end
+				end
+
+				# Class Specs
+				# =======================================
 				class Caller
 
 					def initialize
@@ -18,7 +33,6 @@ module CloudSesame
 
 				[
 					DSL::BlockStyledOperators,
-					DSL::FieldAccessors,
 					DSL::ScopeAccessors,
 					DSL::Operators,
 					DSL::BindCaller
@@ -63,13 +77,6 @@ module CloudSesame
 					end
 				end
 
-				# def _eval(node, _scope, _return = _scope, &block)
-				# 	_scopes.push node
-				# 	instance_eval &block
-				# 	_scope << node
-				# 	_scopes.pop
-				# 	_scope.is_a?(AST::Root) ? _return : node
-				# end
 				describe '#_eval' do
 
 					let(:node) { AST::And.new({}, {}) }

data/spec/cloud_sesame/query/dsl/field_accessors_spec.rb

@@ -1,52 +1,90 @@
-require 'spec_helper'
-
 module CloudSesame
-	module Query
-		module DSL
-			describe FieldAccessors do
-
-				# Setup Test Class
-				class Product
-					include CloudSesame
-					define_cloudsearch {
-						field :name
-						field :tags
-					}
-				end
-
-				subject(:cloudsearch) { Product.cloudsearch.builder }
-
-				context 'when field is registered' do
-					it 'should create a literal node' do
-						expect(AST::Literal).to receive(:new).with(:name, "my name", {})
-						subject.name "my name"
-					end
-					it 'should belong to the dsl context' do
-						expect{ subject.name "name" }.to change{ subject.request.filter_query.root.children.size }.by(1)
-					end
-					it 'should return the dsl scope if called from the root' do
-						expect(subject.tags "men").to eq subject
-					end
-					it 'should return the field array if called from inside a block' do
-						array = nil
-						subject.and { array = tags("men") }
-						expect(array).to be_kind_of(AST::FieldArray)
-						expect(array).to include(AST::Literal)
-					end
-					it 'shoudl set the field array#field' do
-						array = nil
-						subject.and { array = tags("men") }
-						expect(array.field).to eq :tags
-					end
-				end
-
-				context 'when field is not registered' do
-					it 'should raise an error' do
-						expect{ subject.description("description") }.to raise_error NoMethodError
-					end
-				end
-
-			end
-		end
-	end
+  module Query
+    module DSL
+      shared_examples_for 'FieldAccessors' do
+        let(:field_name) { :test_field_name }
+        let(:_scope) { subject.send(:_scope) }
+        let(:context) { { fields: { field_name => {} } } }
+        let(:_return) { subject.send(:_return) }
+        let(:options) { context[:fields][field_name] }
+
+        describe '#literal' do
+
+          it 'should tell the scope children what field is it for' do
+            expect(subject.send(:_scope).children).to receive(:field=).with(field_name)
+            subject.literal(field_name)
+          end
+
+          it 'should tell the scope children what to return' do
+            allow(subject).to receive(:_return).and_return(_return)
+            expect(subject.send(:_scope).children).to receive(:_return=).with(_return)
+            subject.literal(field_name)
+          end
+
+          it 'should insert all the values into the children' do
+            values = [1, 2, 3, 4, 5]
+            expect(subject.send(:_scope).children).to receive(:insert).with(values)
+            subject.literal(field_name, *values)
+          end
+
+          context 'given a block' do
+            let(:block) { Proc.new { "1" } }
+            let(:caller) { self }
+
+            it 'should evalute the block with Domain::Literal' do
+              domain = Domain::Literal.new(field_name, options, caller)
+              expect(Domain::Literal).to receive(:new).with(field_name, options, self).and_return(domain)
+              expect(domain).to receive(:_eval) do |&received_block|
+                received_block == block
+              end
+              subject.literal(field_name, &block)
+            end
+
+            it 'should add the evaluated value to values' do
+              expect(subject.send(:_scope).children).to receive(:insert).with(include(AST::Literal))
+              subject.literal(field_name, &block)
+
+            end
+          end
+
+        end
+
+        context 'when field is registered' do
+          let(:value) { "value" }
+          before { DSL::FieldAccessors.__define_accessor__(field_name) }
+          it 'should create a literal node' do
+            expect(AST::Literal).to receive(:new).with(field_name, value, options)
+            subject.send(field_name, value)
+          end
+          it 'should belong to the scope object' do
+            expect{ subject.send(field_name, value) }.to change{ subject.send(:_scope).children.size }.by(1)
+          end
+          it 'should return the dsl scope if called from the root' do
+            if subject.send(:_scope).is_a?(Builder)
+              expect(subject.send(field_name, value)).to eq subject
+            end
+          end
+
+          it 'should return the field array if called from inside a block' do
+            array = nil
+            subject.and { array = send(field_name, value) }
+            expect(array).to be_kind_of(AST::FieldArray)
+            expect(array).to include(AST::Literal)
+          end
+          it 'should set the field array#field' do
+            array = nil
+            subject.and { array = send(field_name, value)  }
+            expect(array.field).to eq field_name
+          end
+        end
+
+        context 'when field is not registered' do
+          it 'should raise an error' do
+            expect{ subject.unregistered("description") }.to raise_error NoMethodError
+          end
+        end
+
+      end
+    end
+  end
 end

data/spec/cloud_sesame/query/dsl/field_array_methods_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module CloudSesame
 	module Query
 		module DSL

data/spec/cloud_sesame/query/node/facet_spec.rb

@@ -5,26 +5,12 @@ module CloudSesame
     module Node
       describe Facet do
         let(:facet) { Facet.new(facet_options) }
-        describe '#facet' do
-          context 'when default facet is defined' do
-            let(:facet_options) { { price: { size: 100 } } }
-            it 'should return the default facet options' do
-              expect(facet_options).to include(facet_options)
-            end
-          end
-          context 'when default facet is not defined' do
-            let(:facet_options) { {} }
-            it 'should return an empty facet options' do
-              expect(facet_options).to include(facet_options)
-            end
-          end
-        end
 
         describe '#compile' do
           context 'when facet is not empty' do
             let(:facet_options) { { price: { size: 100 } } }
             it 'should return stringified JSON facet' do
-              expect(facet.compile).to include facet: JSON.dump(facet_options)
+              expect(facet.compile).to eq JSON.dump(facet_options)
             end
           end
           context 'when facet is empty' do

data/spec/cloud_sesame/query/node/filter_query_spec.rb

@@ -11,8 +11,22 @@ module CloudSesame
             expect(subject.root).to receive(:compile)
             subject.compile
           end
-          it 'should return an hash with filter query' do
-            expect(subject.compile).to include(filter_query: subject.root.compile )
+          context 'when compiled value is nil' do
+            it 'should return nil' do
+              expect(subject.compile).to be_nil
+            end
+          end
+          context 'when compiled value is empty' do
+            it 'should return nil' do
+              expect(subject.compile).to be_nil
+            end
+          end
+          context 'when compiled value is not empty' do
+            let(:value) { "compiled value" }
+            it 'should return the compiled value' do
+              allow(subject.root).to receive(:compile).and_return(value)
+              expect(subject.compile).to eq value
+            end
           end
         end
 

data/spec/cloud_sesame/query/node/page_spec.rb

@@ -10,7 +10,7 @@ module CloudSesame
           context 'when arguments passed in' do
             let(:arguments) { { page: 2, size: 13 } }
             it 'should initialize the page with the page argument' do
-              expect(node.page).to eq 2
+              expect(node.page).to eq 1
             end
             it 'should initialize the size with the size argument' do
               expect(node.size).to eq 13
@@ -36,7 +36,8 @@ module CloudSesame
             page: 3, size: 13, expect_start: 26
           }].each do |arguments|
             it 'should calculate and return the starting point' do
-              node = Page.new arguments
+              node = Page.new(size: arguments[:size])
+              node.page = arguments[:page]
               expect(node.start).to eq arguments[:expect_start]
             end
           end

data/spec/cloud_sesame/query/node/query_options_spec.rb

@@ -45,7 +45,7 @@ module CloudSesame
             let(:context) { {fields: { description: { weight: 2 }, name: {} } } }
             it 'should return a hash with query_options and fields as JSON' do
               expected_result = { fields: ['description^2', 'name'] }
-              expect(query_options.compile).to include(query_options: JSON.dump(expected_result))
+              expect(query_options.compile).to eq JSON.dump(expected_result)
             end
           end
         end

data/spec/cloud_sesame/query/node/query_parser_spec.rb

@@ -17,17 +17,11 @@ module CloudSesame
           it 'should default to simple if not passed in from context' do
             expect(subject.type).to eq('simple')
           end
-          context 'when default context passed in' do
-            let(:context) { {query_parser: 'structured'} }
-            it 'should default to the context value' do
-              expect(subject.type).to eq('structured')
-            end
-          end
         end
 
         describe '#compile' do
           it 'should return a hash with query_parser type' do
-            expect(subject.compile).to eq({query_parser: 'simple'})
+            expect(subject.compile).to eq 'simple'
           end
         end
 

data/spec/cloud_sesame/query/node/query_spec.rb

@@ -5,27 +5,12 @@ module CloudSesame
     module Node
       describe Query do
         let(:context) {{ }}
-        let(:node) { Query.new(context) }
         subject { Query.new(context) }
 
-        describe '#query' do
-          context 'when context include query on initialize' do
-            let(:query_string) { "hello world" }
-            let(:context) { { query: query_string }}
-            it 'should set query to context query' do
-              expect(subject.query).to eq query_string
-            end
-          end
-          context 'when context does not include query on initialize' do
-            it 'should just return nil' do
-              expect(subject.query).to eq nil
-            end
-          end
-        end
-
         describe '#compile' do
 
           shared_examples 'common query compile actions' do
+            before { subject.query = query_string }
             context 'and query is nil' do
               let(:query_string) { nil }
               it 'should return nil' do
@@ -41,18 +26,20 @@ module CloudSesame
             context 'and query contains one word' do
               let(:query_string) { "oneword" }
               it 'should include the original string inside parenthesis' do
-                expect(subject.compile[:query]).to include("(#{ query_string })")
+                expect(subject.compile).to include("(#{ query_string })")
               end
             end
             context 'and query contains multiple words' do
               let(:query_string) { "one three fourty longword" }
               it 'should include the original string inside parenthesis' do
-                expect(subject.compile[:query]).to include("(#{ query_string })")
+                expect(subject.compile).to include("(#{ query_string })")
               end
             end
           end
 
           shared_examples 'with additional parser defined' do |parser_name|
+            before { subject.query = query_string }
+
             context 'and query string is nil' do
               let(:query_string) { nil }
               it "should not trigger #{ parser_name }" do
@@ -72,30 +59,25 @@ module CloudSesame
               it "should trigger #{ parser_name }" do
                 result = parser.compile(query_string)
                 expect(parser).to receive(:compile).with(query_string).and_call_original
-                expect(subject.compile[:query]).to include(result)
+                expect(subject.compile).to include(result)
               end
             end
           end
 
           context 'when both fuzziness and sloppiness are not defined' do
-            let(:context) {{ query: query_string }}
+            let(:context) {{ }}
+
             include_examples 'common query compile actions'
           end
           context 'when fuzziness is defined' do
             let(:parser) { Fuzziness.new }
-            let(:context) {{
-              query: query_string,
-              fuzziness: parser
-            }}
+            let(:context) {{ fuzziness: parser }}
             include_examples 'common query compile actions'
             include_examples 'with additional parser defined', "fuzziness"
           end
           context 'when sloppiness is defined' do
             let(:parser) { Sloppiness.new(3) }
-            let(:context) {{
-              query: query_string,
-              sloppiness: parser
-            }}
+            let(:context) {{ sloppiness: parser }}
             include_examples 'common query compile actions'
             include_examples 'with additional parser defined', "sloppiness"
           end