CloudSesame 0.7.5 → 0.7.7

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

@@ -0,0 +1,136 @@
+module CloudSesame
+  module Query
+    module AST
+      describe Literal do
+
+        let(:field) { :literal }
+        let(:value) { "value" }
+        let(:options) { {} }
+        subject { Literal.new(field, value, options) }
+
+        describe '#initialize' do
+          context 'when the value is given' do
+
+            it 'should create an lazy object' do
+              expect(LazyObject).to receive(:new)
+              subject
+            end
+
+            context 'and the options contains field type' do
+              let(:field_type) { class_double(Value) }
+              let(:options) {{ type: field_type }}
+              before { allow(LazyObject).to receive(:new) { |&b| b.call } }
+
+              it 'should parse value with field type inside the lazy object' do
+                expect(field_type).to receive(:parse).with(value)
+                subject
+              end
+            end
+
+            context 'and the options does not contain type' do
+              before { allow(LazyObject).to receive(:new) { |&b| b.call } }
+
+              it 'should create a lazy object' do
+                expect(Value).to receive(:parse).with(value)
+                subject
+              end
+            end
+
+          end
+
+          context 'when the value is nil' do
+            let(:value) { nil }
+            it 'should not parse the value using lazy object' do
+              expect(LazyObject).to_not receive(:new)
+              subject
+            end
+          end
+
+          context 'when the options is nil' do
+            let(:options) { nil }
+            it 'should use the default options' do
+              expect(subject.options).to eq({ type: Value })
+            end
+          end
+        end
+
+        describe '#applied' do
+          let(:included) { true }
+          context 'when value is given' do
+            it 'should return an hash contains field value and included' do
+              expect(subject.applied(included)).to include(
+                field: field,
+                value: CloudSesame::Query::AST::StringValue.new(value),
+                included: included
+              )
+            end
+          end
+          context 'when value is not given' do
+            let(:value) { nil }
+            it 'should return nothing' do
+              expect(subject.applied(included)).to be_nil
+            end
+          end
+        end
+
+        describe '#actual_field_name' do
+          context 'when options contains :as value' do
+            let(:actual_field_name) { :field1 }
+            let(:options) { { as: actual_field_name } }
+            it 'should use the :as value as the actual field name' do
+              expect(subject.actual_field_name).to eq actual_field_name
+            end
+          end
+          context 'when options does not contain :as value' do
+            it 'should use the field as the actual field name' do
+              expect(subject.actual_field_name).to eq field
+            end
+          end
+        end
+
+        describe '#compile' do
+          context 'when value is not present' do
+            let(:value) { nil }
+            it 'should return nothing' do
+              expect(subject.compile).to be_nil
+            end
+          end
+          context 'when value is present' do
+            it 'should compile the value' do
+              expect(subject.value).to receive(:compile)
+              subject.compile
+            end
+            it 'should compile into standard format by default' do
+              expect(subject.compile).to eq "#{ field }:#{ subject.value.compile }"
+            end
+          end
+          context 'when request detailed format' do
+            it 'should compile into detailed format' do
+              expect(subject.compile(true)).to eq("field='#{ field }' #{ subject.value.compile }")
+            end
+          end
+        end
+
+        describe '#is_for' do
+          let(:new_field) { :new_literal }
+          it 'should set the field' do
+            expect{ subject.is_for(new_field, nil) }.to change{ subject.field }.from(field).to(new_field)
+          end
+          context 'when options is present' do
+            let(:options) { { old: "value" } }
+            let(:new_options) { { new: "new value" } }
+            it 'should take the options and merge with existing options' do
+              expect{ subject.is_for(field, new_options) }.to change{ subject.options }.from(options.clone).to(options.merge(new_options))
+            end
+          end
+          context 'when options is not present' do
+            it 'should do nothing with the existing options' do
+              expect{ subject.is_for(field, nil) }.to_not change{ subject.options }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module CloudSesame
+  module Query
+    module AST
+      describe Not do
+
+        let(:context) {{}}
+        subject { Not.new(context) }
+
+        it 'should be a type of operator' do
+          expect(Not.ancestors).to include(Abstract::SingleExpressionOperator)
+        end
+
+        it 'should have symbol :not' do
+          expect(Not::SYMBOL).to eq :not
+        end
+
+        describe '#applied' do
+          let(:included) { false }
+          let(:child) { instance_double(Abstract::SingleExpressionOperator) }
+          before { subject << child }
+          it 'should inverse included and broadcast to it\'s child' do
+            expect(child).to receive(:applied).with(!included)
+            subject.applied(included)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module CloudSesame
+  module Query
+    module AST
+      describe Phrase do
+        it 'should be a type of operator' do
+          expect(Phrase.ancestors).to include(Abstract::SingleExpressionOperator)
+        end
+
+        it 'should have symbol :term' do
+          expect(Phrase::SYMBOL).to eq :phrase
+        end
+
+        it 'should be set to detailed' do
+          expect(Phrase::DETAILED).to eq true
+        end
+
+      end
+    end
+  end
+end

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

@@ -3,48 +3,263 @@ module CloudSesame
 		module AST
 			describe RangeValue do
 
-				describe 'initialize' do
-					shared_examples 'initialize with initial value' do
-						it 'should be an array' do
-							expect(subject.value).to be_kind_of(Array)
+				let(:type) { nil }
+				subject { RangeValue.new(initial_value, type) }
+
+				describe '#initialize' do
+
+					shared_examples 'determine lower bound, begin, end' do
+						it 'should determine the lower bound' do
+							expect(subject.lower_bound).to eq lower_bound
+						end
+						it 'should determine the begin value' do
+							expect(subject.begin).to eq start_value
+						end
+						it 'should determine the end value' do
+							expect(subject.end).to eq end_value
+						end
+						it 'should determine the upper bound' do
+							expect(subject.upper_bound).to eq upper_bound
+						end
+					end
+
+					shared_examples 'possible upper bound' do
+						context 'when upper bound is included' do
+							let(:upper_bound) { ']' }
+							include_examples 'determine lower bound, begin, end'
 						end
-						it 'should not be empty' do
-							expect(subject.value).to_not be_empty
+						context 'when upper bound is excluded' do
+							let(:upper_bound) { '}' }
+							include_examples 'determine lower bound, begin, end'
+						end
+					end
+
+					context 'when given a ruby range object' do
+						let(:start_value) { 10 }
+						let(:end_value) { 20 }
+
+						let(:lower_bound) { '[' }
+						context 'when upper bound is included' do
+							let(:upper_bound) { ']' }
+							let(:initial_value) { start_value..end_value }
+							include_examples 'determine lower bound, begin, end'
+						end
+						context 'when lower bound is excluded' do
+							let(:initial_value) { start_value...end_value }
+							let(:upper_bound) { '}' }
+							include_examples 'determine lower bound, begin, end'
+						end
+					end
+
+					context 'when given a aws range string' do
+						let(:start_value) { "10" }
+						let(:end_value) { "20" }
+						let(:initial_value) { "#{ lower_bound }#{ start_value },#{ end_value }#{ upper_bound }" }
+
+						context 'when lower bound is included' do
+							let(:lower_bound) { '[' }
+							include_examples 'possible upper bound'
 						end
-						it 'should capture the range information' do
-							expect(subject.value).to eq data
+						context 'when lower bound is excluded' do
+							let(:lower_bound) { '{' }
+							include_examples 'possible upper bound'
 						end
 					end
 
-					context 'when given a range value' do
-						{
-							(0..10) => ['[', 0, 10, ']'],
-							(0...10) => ['[', 0, 10, '}'],
-							(Date.today..(Date.today + 3)) => ['[', Date.today, Date.today + 3, ']']
-						}.each do |before_value, after_value|
-							subject { RangeValue.new(before_value) }
-							let(:data) { after_value }
-							include_examples 'initialize with initial value'
+					context 'when given no initial value' do
+						let(:initial_value) { nil }
+						let(:lower_bound) { "[" }
+						let(:upper_bound) { "]" }
+						let(:start_value) { nil }
+						let(:end_value) { nil }
+						include_examples 'determine lower bound, begin, end'
+					end
+
+					context 'when given type' do
+						let(:start_value) { 10 }
+						let(:end_value) { 20 }
+						let(:initial_value) { start_value..end_value }
+						let(:type) { Value }
+						it 'should parse the start and end value with type' do
+							expect(type).to receive(:parse).with(end_value)
+							expect(type).to receive(:parse).with(start_value)
+							subject
+						end
+						it 'should convert start and end value to value object' do
+							expect(subject.begin).to be_kind_of(Abstract::Value)
+							expect(subject.end).to be_kind_of(Abstract::Value)
 						end
 					end
 
-					context 'when given a range value in string format' do
-						{
-							"[0, nil}" => ['[', 0, nil, '}'],
-							"{, 100]" => ['{', '', '100', ']'],
-						}.each do |before_value, after_value|
-							subject { RangeValue.new(before_value) }
-							let(:data) { after_value }
-							include_examples 'initialize with initial value'
+					context 'when given no type' do
+						let(:initial_value) { 10..20 }
+
+						it 'should not parse the start and end value' do
+							expect(type).to_not receive(:parse)
+							subject
+						end
+						it 'should keep the original start and end value' do
+							expect(subject.begin).to be_kind_of(Numeric)
+							expect(subject.end).to be_kind_of(Numeric)
 						end
 					end
 
-					context 'when value is not given' do
-						subject { RangeValue.new }
-						let(:data) { [] }
-						it 'should set the data to the default value' do
-							expect(subject.value).to eq ['{', nil, nil, '}']
+				end
+
+				describe '#parse' do
+					let(:begin_value) { 1 }
+		  		let(:end_value) { 10 }
+					let(:initial_value) { begin_value..end_value }
+
+					it 'should return self' do
+						expect(subject.parse(nil)).to eq subject
+					end
+
+				  context 'given type and type respond to parse' do
+				  	let(:parse_type) { Value }
+
+				  	context 'and begin and end value is not empty in string form' do
+							it 'should parse the begin and end value' do
+								expect(parse_type).to receive(:parse).with(end_value)
+								expect(parse_type).to receive(:parse).with(begin_value)
+								subject.parse(parse_type)
+							end
+				  	end
+				  	context 'and begin and end value is empty in string form' do
+							let(:begin_value) { nil }
+				  		let(:end_value) { nil }
+
+				  		it 'should not try to parse the begin and end value' do
+				  			expect(parse_type).to_not receive(:parse)
+				  			subject.parse(parse_type)
+				  		end
+				  	end
+				  end
+				  context 'given type does not respond to parse' do
+						let(:parse_type) { "Random Type" }
+						before { allow(parse_type).to receive(:respond_to?).and_return(false) }
+						it 'should not try to parse the begin and end value' do
+							expect(parse_type).to_not receive(:parse)
+							subject.parse(parse_type)
+						end
+				  end
+				  context 'given type is nil' do
+						let(:parse_type) { nil }
+						it 'should not try to parse the begin and end value' do
+							expect(parse_type).to_not receive(:parse)
+							subject.parse(parse_type)
 						end
+				  end
+				end
+
+				describe '#begin' do
+					let(:begin_value) { 1 }
+					let(:end_value) { 10 }
+					let(:initial_value) { begin_value..end_value }
+					it 'should return the begin value' do
+						expect(subject.begin).to eq begin_value
+					end
+				end
+
+				describe '#end' do
+					let(:begin_value) { 1 }
+					let(:end_value) { 10 }
+					let(:initial_value) { begin_value..end_value }
+					it 'should return the end value' do
+						expect(subject.end).to eq end_value
+					end
+				end
+
+				describe '#lower_bound' do
+					let(:lower_bound) { "{" }
+					let(:upper_bound) { "}" }
+					let(:begin_value) { "1" }
+					let(:end_value) { "10" }
+					let(:initial_value) { lower_bound + begin_value + ',' + end_value + upper_bound }
+					it 'should return the lower bound symbol' do
+						expect(subject.lower_bound).to eq lower_bound
+					end
+				end
+
+				describe '#upper_bound' do
+					let(:lower_bound) { "{" }
+					let(:upper_bound) { "}" }
+					let(:begin_value) { "1" }
+					let(:end_value) { "10" }
+					let(:initial_value) { lower_bound + begin_value + ',' + end_value + upper_bound }
+					it 'should return the upper bound symbol' do
+						expect(subject.upper_bound).to eq upper_bound
+					end
+				end
+
+				describe '#gt' do
+					let(:value) { 100 }
+					let(:initial_value) { nil }
+					it 'should set the begin value' do
+						expect{ subject.gt(value) }.to change{ subject.begin }.from(nil).to(value)
+					end
+					it 'should set the lower bound to be excluded' do
+						subject.gt(value)
+						expect(subject.lower_bound).to eq '{'
+					end
+				end
+
+				describe '#gte' do
+					let(:value) { 101 }
+					let(:initial_value) { nil }
+					it 'should set the begin value' do
+						expect{ subject.gte(value) }.to change{ subject.begin }.from(nil).to(value)
+					end
+					it 'should set the lower bound to be excluded' do
+						subject.gte(value)
+						expect(subject.lower_bound).to eq '['
+					end
+				end
+
+				describe '#lt' do
+					let(:value) { 100 }
+					let(:initial_value) { nil }
+					it 'should set the begin value' do
+						expect{ subject.lt(value) }.to change{ subject.end }.from(nil).to(value)
+					end
+					it 'should set the lower bound to be excluded' do
+						subject.lt(value)
+						expect(subject.upper_bound).to eq '}'
+					end
+				end
+
+				describe '#lte' do
+					let(:value) { 100 }
+					let(:initial_value) { nil }
+					it 'should set the begin value' do
+						expect{ subject.lte(value) }.to change{ subject.end }.from(nil).to(value)
+					end
+					it 'should set the lower bound to be excluded' do
+						subject.lte(value)
+						expect(subject.upper_bound).to eq ']'
+					end
+				end
+
+				describe '#to_s' do
+					let(:initial_value) { 10..255 }
+					it 'should return the compiled value' do
+						expect(subject.to_s).to eq subject.compile
+					end
+				end
+
+				describe '#==' do
+					let(:initial_value) { 10...255 }
+					let(:object) { "[10,255}" }
+				  it 'should convert the object comparing with to RangeValue' do
+				  	subject
+						expect(RangeValue).to receive(:new).with(object, Value).and_call_original
+						subject == object
+				  end
+				  it 'should return true when the parsed value are the same' do
+						expect(subject == object).to eq true
+				  end
+					it 'should return false when the parsed value is different' do
+						expect(subject == (10..255)).to eq false
 					end
 				end
 

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

@@ -0,0 +1,39 @@
+module CloudSesame
+  module Query
+    module AST
+      describe StringValue do
+
+        describe '.parse' do
+          let(:value) { "value" }
+
+          it 'should instantiate a StringValue' do
+            expect(StringValue).to receive(:new).with(value)
+            StringValue.parse(value)
+          end
+          it 'should return the StringValue' do
+            expect(StringValue.parse(value)).to be_kind_of(StringValue)
+          end
+        end
+
+        describe '.compile' do
+          subject { StringValue.new(value) }
+
+          context 'when value is not present' do
+            let(:value) { nil }
+            it 'should return nothing' do
+              expect(subject.compile).to eq nil
+            end
+          end
+          context 'when value is present' do
+            let(:value) { "value" }
+            it 'should return the escaped the value' do
+              expect(subject.compile).to eq "'#{ value }'"
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module CloudSesame
+  module Query
+    module AST
+      describe Term do
+        it 'should be a type of operator' do
+          expect(Term.ancestors).to include(Abstract::SingleExpressionOperator)
+        end
+
+        it 'should have symbol :term' do
+          expect(Term::SYMBOL).to eq :term
+        end
+
+        it 'should be set to detailed' do
+          expect(Term::DETAILED).to eq true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'bigdecimal'
+
+module CloudSesame
+  module Query
+    module AST
+      describe Value do
+
+        describe '.map_type' do
+          it 'should return self when type does not match' do
+            expect(Value.map_type(:random)).to eq(Value)
+          end
+          it 'should return the class matched the type' do
+            expect(Value.map_type(:string)).to eq(StringValue)
+            expect(Value.map_type(:numeric)).to eq(NumericValue)
+            expect(Value.map_type(:datetime)).to eq(DateValue)
+          end
+        end
+
+        describe '.parse' do
+          context 'when value is a RangeValue object' do
+            let(:begin_value) { 100 }
+            let(:end_value) { 200 }
+            let(:value) { RangeValue.new(begin_value..end_value) }
+            it 'should parse the RangeValue' do
+              expect(value).to receive(:parse).with(Value).and_call_original
+              expect(Value.parse(value)).to eq value
+            end
+          end
+          context 'when value is an ruby range object' do
+            let(:begin_value) { 100 }
+            let(:end_value) { 200 }
+            let(:value) { begin_value..end_value }
+            it 'should initialize a RangeValue' do
+              expect(RangeValue).to receive(:new).with(value, Value).and_call_original
+              expect(Value.parse(value)).to be_kind_of(RangeValue)
+            end
+          end
+          context 'when value is a AWS range string' do
+            let(:lower_bound) { '{' }
+            let(:upper_bound) { '}' }
+            let(:begin_value) { 100 }
+            let(:end_value) { 200 }
+            let(:value) { "#{ lower_bound }#{ begin_value },#{ end_value }#{ upper_bound }" }
+            it 'should initialize a RangeValue' do
+              expect(RangeValue).to receive(:new).with(value, Value).and_call_original
+              expect(Value.parse(value)).to be_kind_of(RangeValue)
+            end
+          end
+          context 'when value is a numeric value' do
+            let(:value) { 10 }
+            it 'should initialize a NumericValue' do
+              expect(NumericValue).to receive(:new).with(value, Value).and_call_original
+              expect(Value.parse(value)).to be_kind_of(NumericValue)
+            end
+          end
+          context 'when value is a string contains numeric' do
+            let(:value) { "10" }
+            it 'should initialize a NumericValue' do
+              expect(NumericValue).to receive(:new).with(value, Value).and_call_original
+              expect(Value.parse(value)).to be_kind_of(NumericValue)
+            end
+          end
+          context 'when value is not neither a range, numeric or range' do
+            let(:value) { [10] }
+            it 'should initialize a NumericValue' do
+              expect(StringValue).to receive(:new).with(value, Value).and_call_original
+              expect(Value.parse(value)).to be_kind_of(StringValue)
+            end
+          end
+        end
+
+        describe '.range_value?' do
+          it 'should return true when value is a ruby range object' do
+            expect(Value.range_value?(1..20)).to eq true
+          end
+          it 'should return true when value is a aws range string' do
+            expect(Value.range_value?("[1,20]")).to eq true
+            expect(Value.range_value?("[1,20}")).to eq true
+            expect(Value.range_value?("{,20]")).to eq true
+            expect(Value.range_value?("{1,}")).to eq true
+          end
+          it 'should return false when value is not a range' do
+            expect(Value.range_value?("abc")).to eq false
+            expect(Value.range_value?(['[', 2, 3, '}'])).to eq false
+          end
+        end
+
+        describe 'numeric_value?' do
+          it 'should return true when value is a integer, float, or bigdecimal' do
+            expect(Value.numeric_value?(1)).to eq true
+            expect(Value.numeric_value?(0.99)).to eq true
+            expect(Value.numeric_value?(BigDecimal.new("10"))).to eq true
+          end
+          it 'should return true when value matches string numeric format' do
+            expect(Value.numeric_value?("1")).to eq true
+            expect(Value.numeric_value?("0.99")).to eq true
+          end
+          it 'should return false when value is not a numeric' do
+            expect(Value.numeric_value?("abc")).to eq false
+            expect(Value.numeric_value?([1, 2, 3])).to eq false
+            expect(Value.numeric_value?(h: 2)).to eq false
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/cloud_sesame/query/builder_spec.rb

@@ -1,5 +1,5 @@
 require_relative 'dsl/applied_filter_query_spec'
-require_relative 'dsl/field_accessors_spec'
+require_relative 'dsl/literal_methods_spec'
 
 module CloudSesame
   module Query
@@ -9,11 +9,11 @@ module CloudSesame
         subject { Builder.new({}, "Searchable") }
       end
 
-      it_behaves_like DSL::FieldAccessors do
+      it_behaves_like DSL::LiteralMethods do
         subject { Builder.new({}, "Searchable") }
         before {
-          Builder.send(:include, DSL::FieldAccessors)
-          Domain::Block.send(:include, DSL::FieldAccessors)
+          Builder.send(:include, DSL::LiteralMethods)
+          Domain::Block.send(:include, DSL::LiteralMethods)
           allow(_scope).to receive(:context).and_return(context)
         }
       end