CloudSesame 0.1.6 → 0.2.0

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

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-module CloudSesame
-  module Query
-    module AST
-      describe Literal do
-        let(:literal) { Literal.new('description', 'Shoes') }
-        let(:value) { Value.new("Shoes") }
-
-        # before { allow(Value).to receive(:new).and_return(value) }
-
-        describe '#initialize' do
-          it 'should store field' do
-            expect(literal.field).to eq('description')
-          end
-          it 'should create value node and store it' do
-            expect(Value).to receive(:new).with('Shoes').and_return(value)
-            expect(literal.value).to be_kind_of Value
-          end
-        end
-
-        describe '#compile' do
-          context 'when options is empty' do
-            it 'should compile value' do
-              expect_any_instance_of(Value).to receive(:compile).and_return("'Shoes'")
-              literal.compile
-            end
-            it 'should join the field and compiled value with colon' do
-              expect(literal.compile).to eq("description:'Shoes'")
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require "spec_helper"
-
-module CloudSesame
-  module Query
-    module AST
-      describe MultiBranch do
-        let(:context) { {} }
-        let(:proc) { Proc.new { } }
-        let(:node) { MultiBranch.new(context, &proc) }
-
-        describe '#initialize' do
-          it 'should store the context' do
-            expect(node.context).to eq context
-          end
-          it 'should accepts an block and eval it' do
-            proc = Proc.new { test }
-            expect_any_instance_of(MultiBranch).to receive(:test)
-            MultiBranch.new(context, &proc)
-          end
-        end
-
-        describe '#children' do
-          it 'should instantiate an empty array' do
-            expect(CompoundArray).to receive(:new).and_call_original
-            node.children
-          end
-          it 'should return the array' do
-            node.children.concat([1,2,3])
-            expect(node.children).to eq [1,2,3]
-          end
-        end
-
-        describe '#compile_children' do
-          let(:children) {
-            [Value.new('value1'),
-              Value.new('value2')]
-          }
-          it 'should compile its children' do
-            children.each do |child|
-              expect(child).to receive(:compile)
-            end
-
-            node.children.concat(children)
-            node.compile_children
-          end
-
-          it 'should join its compiled children with a space' do
-            children.each do |child|
-              expect(child).to receive(:compile).and_call_original
-            end
-            node.children.concat(children)
-            expect(node.compile_children).to eq("'value1' 'value2'")
-          end
-        end
-
-        describe 'Query DSL' do
-          it 'should be included' do
-            expect(node).to respond_to(:and, :or)
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-module CloudSesame
-  module Query
-    module AST
-      describe MultiExpressionOperator do
-        let(:proc) { Proc.new {} }
-        let(:operator) { MultiExpressionOperator.new({}, &proc )}
-        before { MultiExpressionOperator.symbol = :symbol }
-
-        describe '#compile' do
-
-          it 'should return nil if children are empty' do
-            expect(operator.compile).to eq(nil)
-          end
-
-          it 'should return a string with the symbol and compile children' do
-            operator.children.push Literal.new(:price, 10)
-            expect(operator.compile).to eq("(symbol price:10)")
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-module CloudSesame
-  module Query
-    module AST
-      describe Or do
-        it 'should set the symbol to :or' do
-          expect(Or.symbol).to eq :or
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-module CloudSesame
-  module Query
-    module AST
-      describe Root do
-
-        let(:root) { Root.new({}) }
-
-        describe '#compile' do
-          before { root.children.concat(children) }
-
-          context 'when it has multiple children' do
-            let(:children) {
-              [Literal.new(:tags, "flash_deal"),
-                Literal.new(:tags, "sales")]
-            }
-            it 'should inject an default operator' do
-              expect(root.compile).to eq "(and tags:'flash_deal' tags:'sales')"
-            end
-          end
-          context 'when it has 1 child' do
-            let(:children) {
-              [Literal.new(:tags, "flash_deal")]
-            }
-            it 'should compile the child' do
-              expect(root).to receive(:compile_children)
-              root.compile
-            end
-          end
-          context 'when it has no children' do
-            let(:children) { [] }
-            it 'should compile the child' do
-              expect(root).to receive(:compile_children)
-              root.compile
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-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/dsl/filter_query_spec.rb

@@ -1,108 +0,0 @@
-module CloudSesame
-  module Query
-    module DSL
-      describe FilterQuery do
-
-        class TestClass
-          include Base
-          include FilterQuery
-          def initialize
-          end
-          def children
-            @children ||= AST::CompoundArray.new.scope_to 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 '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/node/request_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module CloudSesame
-  module Query
-    module Node
-      describe Request do
-        let(:context) { Domain::Context.new(filter_query: { fields: { tags: {} } }) }
-        let(:request) { Request.new(context) }
-
-        describe '#compile' do
-          context 'when request is empty' do
-            it 'should return an default request' do
-              expect(request.compile).to include(
-                query: "",
-                query_parser: "simple",
-                start: 0,
-                size: 10
-              )
-              expect(request.compile).to_not include(:query_options, :filter_query, :sort)
-            end
-            it 'should set query_parser to simple' do
-              expect(request.compile).to include(query_parser: 'simple')
-            end
-          end
-          context 'when theres query' do
-            before { request.query.query = "hello world" }
-            it 'should includ query string' do
-              expect(request.compile).to include(query: "hello world")
-            end
-            it 'should default query_parser to simple' do
-              expect(request.compile).to include(query_parser: 'simple')
-            end
-          end
-          context 'when theres query_options' do
-            it 'should include query_options' do
-              request.query_options.fields.concat [QueryOptionsField.new(:price)]
-              expect(request.compile).to include(:query_options)
-            end
-          end
-          context 'when theres filter query' do
-            before { request.filter_query.root.and { tags "sale" } }
-            let(:compiled) { request.filter_query.compile }
-            context 'with query' do
-              before { request.query.query = "hello" }
-              it 'should include filter query' do
-                expect(request.compile).to include(:filter_query)
-              end
-            end
-            context 'without query' do
-              before { request.query.query = "" }
-              it 'should include query instead' do
-                expect(request.compile).to include(:query)
-              end
-            end
-          end
-          context 'when theres page' do
-            it 'should include start and size' do
-              expect(request.compile).to include(:start, :size)
-            end
-          end
-          context 'when theres sort' do
-            before { request.sort[:price]= :asc }
-            it 'should include sort' do
-              expect(request.compile).to include(:sort)
-            end
-          end
-        end
-      end
-    end
-  end
-end