CloudSesame 0.1.0

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe Value do
+
+        let(:value) { Value.new("Shoes") }
+
+        describe '#initialize' do
+          it 'should store the value' do
+            expect(value.data).to eq("Shoes")
+          end
+        end
+
+        describe '#compile' do
+          shared_examples 'return raw data' do
+            it 'should just return the data' do
+              expect(value.compile).to eq value.data
+            end
+          end
+          context 'when data is a string' do
+            it 'should escape the string' do
+              expect(value.compile).to eq "'#{value.data}'"
+            end
+          end
+          context 'when data is a range' do
+            let(:value) { Value.new('[100,}') }
+            include_examples 'return raw data'
+          end
+          context 'when data is a digit' do
+            let(:value) { Value.new(100) }
+            include_examples 'return raw data'
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/cloud_sesame/query/builder_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Query
+    describe Builder do
+      let(:client) { {} }
+      let(:searchable_class) { "Test" }
+      subject { Builder.new(client, searchable_class) }
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module CloudSesame
+  module Query
+    module DSL
+      describe Base do
+
+        class TestClass
+          include Base
+        end
+
+        subject { TestClass.new }
+
+        shared_examples 'return self instance' do
+          it 'should return itself' do
+            expect(result).to eq subject
+          end
+        end
+
+        describe '#method_return' do
+          let(:result) { subject.send(:method_return) }
+          include_examples 'return self instance'
+        end
+
+        describe '#method_scope' do
+          let(:result) { subject.send(:method_scope) }
+          include_examples 'return self instance'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+module CloudSesame
+  module Query
+    module DSL
+      describe FilterQuery do
+
+        class TestClass
+          include Base
+          include FilterQuery
+          def initialize
+          end
+          def children
+            @children ||= AST::CompoundArray.new.set_scope(self)
+          end
+          def context
+            @context ||= {}
+          end
+        end
+
+        subject { TestClass.new }
+
+        describe '#and' do
+          it 'should create an AND node' do
+            expect(AST::And).to receive(:new).with({})
+            subject.and
+          end
+          it 'should add the AND node to it\s children' do
+            expect(AST::And).to receive(:new).with({})
+            expect{ subject.and }.to change{ subject.children.size }.by(1)
+          end
+          it 'should return it\'s own scope' do
+            expect(subject.and).to eq subject
+          end
+        end
+
+        describe '#or' do
+          it 'should create an OR node' do
+            expect(AST::Or).to receive(:new).with({})
+            subject.or
+          end
+          it 'should add the OR node to it\s children' do
+            expect(AST::Or).to receive(:new).with({})
+            expect{ subject.or }.to change{ subject.children.size }.by(1)
+          end
+          it 'should return it\'s own scope' do
+            expect(subject.and).to eq subject
+          end
+        end
+
+        describe 'literal' do
+
+          it 'should create a literal node' do
+            expect(AST::Literal).to receive(:new).with('description', '123', Hash)
+            subject.literal('description', '123')
+          end
+          it 'should add the literal node to it\'s children' do
+            expect{ subject.literal('description', '123') }.to change{ subject.children.size }.by(1)
+          end
+          it 'should return the literal node' do
+            expect(subject.literal('description', '123')).to be_kind_of(AST::Literal)
+          end
+
+          context 'when field is define in context' do
+            before { subject.context[:fields] = { description: {} } }
+            # it 'should be triggered by calling the field name as a method' do
+            #   expect(subject).to receive(:literal).with(:description, '123', {})
+            #   subject.description "123"
+            # end
+            # it 'should accept multiple values' do
+            #   expect(subject).to receive(:literal).exactly(3).times
+            #   subject.description "123", "456", "789"
+            # end
+
+            it 'should return literal nodes in an array' do
+              result = subject.description("123", "456", "789")
+              expect(result).to include(AST::Literal)
+            end
+          end
+
+          context 'when field is not defined' do
+            it 'should raise method missing error when calling the field name as a method' do
+              expect{ subject.not_defined() }.to raise_error(NoMethodError)
+            end
+          end
+        end
+
+        # describe 'prefix' do
+        #   it 'should set the literal prefix option to true' do
+        #     literals = (1..3).map { |i| AST::Literal.new(:int, i) }
+        #     subject.prefix(literals)
+
+        #     literals.each do |literal|
+        #       expect(literal.options).to include(prefix: true)
+        #     end
+
+        #   end
+        # end
+
+        describe 'included?' do
+          before { subject.context[:fields] = { tags: {}, description: {} } }
+          context 'when there is a field and no value' do
+            it 'should return true if the request contains the field in the filter query' do
+              subject.and{tags('women')}
+              expect(subject.included?(:tags)).to be_truthy
+            end
+
+            it 'should return false if the request does not contain the field in the filter query' do
+              subject.and{tags.not('women')}
+              expect(subject.included?(:tags)).to be_falsey
+            end
+
+          end
+          context 'when there is a field and a value' do
+            it 'should return true if the request contains the field and the value in the filter query' do
+              subject.and{tags('women')}
+              expect(subject.included?(:tags, 'women')).to be_truthy
+            end
+
+            it 'should return false if the request does not contain the field or the value in the filter query' do
+              subject.and{tags('women')}
+              expect(subject.included?(:tags, 'men')).to be_falsey
+              expect(subject.included?(:description, 'women')).to be_falsey
+            end
+          end
+        end
+
+
+        describe 'excluded?' do
+          before { subject.context[:fields] = { tags: {}, description: {} } }
+          context 'when there is a field and no value' do
+            it 'should return true if the request excludes the field in the filter query' do
+              subject.and{tags('women')}
+              expect(subject.excluded?(:tags)).to be_falsey
+            end
+
+            it 'should return false if the request does not exclude the field in the filter query' do
+              subject.and{tags.not('women')}
+              expect(subject.excluded?(:tags)).to be_truthy
+            end
+          end
+
+          context 'when there is a field and a value' do
+            it 'should return true if the request excludes the field and the value in the filter query' do
+              subject.and{tags.not('women')}
+              expect(subject.excluded?(:tags, 'women')).to be_truthy
+            end
+
+            it 'should return false if the request does not exclude the field or the value in the filter query' do
+              subject.and{tags('women')}
+              expect(subject.excluded?(:tags, 'men')).to be_falsey
+              expect(subject.excluded?(:tags, 'women')).to be_falsey
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/cloud_sesame/query/dsl_spec.rb

@@ -0,0 +1,96 @@
+# module CloudSesame
+#   module Query
+#     describe DSL do
+
+#       class TestClass
+#         include DSL
+#         def context
+#           @context ||= {}
+#         end
+#         def children
+#           @children ||= []
+#         end
+#       end
+
+#       subject { TestClass.new }
+
+#       describe '#and' do
+#         it 'should create an AND node' do
+#           expect(AST::And).to receive(:new).with({})
+#           subject.and
+#         end
+#         it 'should add the AND node to it\s children' do
+#           expect(AST::And).to receive(:new).with({})
+#           expect{ subject.and }.to change{ subject.children.size }.by(1)
+#         end
+#         it 'should return it\'s own scope' do
+#           expect(subject.and).to eq subject
+#         end
+#       end
+
+#       describe '#or' do
+#         it 'should create an OR node' do
+#           expect(AST::Or).to receive(:new).with({})
+#           subject.or
+#         end
+#         it 'should add the OR node to it\s children' do
+#           expect(AST::Or).to receive(:new).with({})
+#           expect{ subject.or }.to change{ subject.children.size }.by(1)
+#         end
+#         it 'should return it\'s own scope' do
+#           expect(subject.and).to eq subject
+#         end
+#       end
+
+#       describe 'literal' do
+
+#         it 'should create a literal node' do
+#           expect(AST::Literal).to receive(:new).with('description', '123', Hash)
+#           subject.literal('description', '123')
+#         end
+#         it 'should add the literal node to it\'s children' do
+#           expect{ subject.literal('description', '123') }.to change{ subject.children.size }.by(1)
+#         end
+#         it 'should return the literal node' do
+#           expect(subject.literal('description', '123')).to be_kind_of(AST::Literal)
+#         end
+
+#         context 'when field is define in context' do
+#           before { subject.context[:fields] = { description: {} } }
+#           it 'should be triggered by calling the field name as a method' do
+#             expect(subject).to receive(:literal).with(:description, '123', {})
+#             subject.description "123"
+#           end
+#           it 'should accept multiple values' do
+#             expect(subject).to receive(:literal).exactly(3).times
+#             subject.description "123", "456", "789"
+#           end
+
+#           it 'should return literal nodes in an array' do
+#             result = subject.description("123", "456", "789")
+#             expect(result).to include(AST::Literal)
+#           end
+#         end
+
+#         context 'when field is not defined' do
+#           it 'should raise method missing error when calling the field name as a method' do
+#             expect{ subject.not_defined() }.to raise_error(NoMethodError)
+#           end
+#         end
+#       end
+
+#       describe 'prefix' do
+#         it 'should set the literal prefix option to true' do
+#           literals = (1..3).map { |i| AST::Literal.new(:int, i) }
+#           subject.prefix(literals)
+
+#           literals.each do |literal|
+#             expect(literal.options).to include(prefix: true)
+#           end
+
+#         end
+#       end
+
+#     end
+#   end
+# end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Query
+    module Node
+      describe Abstract do
+        let(:context) { :context }
+        subject { Abstract.new(context) }
+
+        describe '#initialize' do
+          it 'should store context' do
+            expect(subject.context).to eq context
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Query
+    module Node
+      describe Facet do
+        let(:facet) { Facet.new(context) }
+        let(:context) { Domain::Context.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.facet).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.facet).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)
+            end
+          end
+          context 'when facet is empty' do
+            let(:facet_options) { { } }
+            it 'should return nil' do
+              expect(facet.compile).to eq nil
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Query
+    module Node
+      describe FilterQuery do
+        subject { FilterQuery.new({}) }
+
+        describe '#compile' do
+          it 'should compile root' do
+            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 )
+          end
+        end
+
+        describe '#root' do
+          it 'should instantiate and return an instance of Root' do
+            expect(AST::Root).to receive(:new).with(subject.context).and_call_original
+            expect(subject.root).to be_kind_of(AST::Root)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module Node
+      describe Page do
+        let(:node) { Page.new(arguments) }
+
+        describe '#initialize' do
+          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
+            end
+            it 'should initialize the size with the size argument' do
+              expect(node.size).to eq 13
+            end
+          end
+          context 'when arguments NOT passed in' do
+            let(:arguments) { {} }
+            it 'should default the page to 1' do
+              expect(node.page).to eq 1
+            end
+            it 'should default the size to 10' do
+              expect(node.size).to eq 10
+            end
+          end
+        end
+
+        describe 'start' do
+          [{
+            page: 1, size: 100, expect_start: 0
+          }, {
+            page: 2, size: 10, expect_start: 10
+          }, {
+            page: 3, size: 13, expect_start: 26
+          }].each do |arguments|
+            it 'should calculate and return the starting point' do
+              node = Page.new arguments
+              expect(node.start).to eq arguments[:expect_start]
+            end
+          end
+        end
+
+        describe '#run' do
+          let(:arguments) { { page: 3, size: 13 } }
+          it 'should return the calculated start' do
+            expect(node.compile).to include start: node.start
+          end
+          it 'should return the size' do
+            expect(node.compile).to include size: arguments[:size]
+          end
+        end
+
+      end
+    end
+  end
+end