daedal-sl 0.0.0 → 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+def append_load_path(*paths)
+  full_path = File.join([File.dirname(__FILE__), ".."] << paths)
+  $: << File.expand_path(full_path)
+end
+
+append_load_path('')
+append_load_path('lib')
+
+require 'daedal-sl'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/unit/daedal-sl/and_filter_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe DaedalSL::AndFilter do
+
+  subject do
+    DaedalSL::AndFilter.new(:parent, {})
+  end
+
+  let(:filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  context '#filter' do
+    before { subject.filter { filter } }
+    it "adds the filter given by executing the block to the and filter's filter list" do
+      expect(subject.base.filters.first).to eq filter
+    end
+  end
+
+end

data/spec/unit/daedal-sl/block_query_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe DaedalSL::BlockQuery do
+
+  let(:parent_class) do
+    class ParentClass
+      def data
+        :data
+      end
+    end
+    ParentClass
+  end
+
+  subject do
+    class DummyClass < DaedalSL::BlockQuery
+      def initialize(data, options)
+        @query_type = Daedal::Queries::MatchQuery
+        super
+      end
+    end
+    DummyClass.new(parent_class.new, {field: :foo, query: :bar})
+  end
+
+  context '#initialize' do
+    it 'sets @data, makes it readable' do
+      expect(subject.data).to eq :data
+    end
+    it 'sets @base, makes it readable' do
+      expect(subject.base.to_hash).to eq(Daedal::Queries::MatchQuery.new(field: :foo, query: :bar).to_hash)
+    end
+  end
+
+  context 'class method #build' do
+    it 'creates a new instance of the class, instance_evals a block, returns' do
+      expect(DummyClass).to receive(:new).with(parent_class, {field: :foo, query: :bar}).and_return(subject)
+      expect(subject).to receive(:foo)
+      DummyClass.build(parent_class, {field: :foo, query: :bar}) do
+        foo
+      end
+    end
+  end
+
+end

data/spec/unit/daedal-sl/bool_filter_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe DaedalSL::BoolFilter do
+
+  subject do
+    DaedalSL::BoolFilter.new(:parent, {})
+  end
+
+  let(:filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  context '#must' do
+    before { subject.must { filter } }
+    it "adds the filter given by executing the block to the bool filter's must list" do
+      expect(subject.base.must.first).to eq filter
+    end
+  end
+
+  context '#should' do
+    before { subject.should { filter } }
+    it "adds the filter given by executing the block to the bool filter's should list" do
+      expect(subject.base.should.first).to eq filter
+    end
+  end
+
+  context '#must_not' do
+    before { subject.must_not { filter } }
+    it "adds the filter given by executing the block to the bool filter's must_not list" do
+      expect(subject.base.must_not.first).to eq filter
+    end
+  end
+
+end

data/spec/unit/daedal-sl/bool_query_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe DaedalSL::BoolQuery do
+
+  subject do
+    DaedalSL::BoolQuery.new(:parent, {})
+  end
+
+  let(:query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  context '#must' do
+    before { subject.must { query } }
+    it "adds the query given by executing the block to the bool query's must list" do
+      expect(subject.base.must.first).to eq query
+    end
+  end
+
+  context '#should' do
+    before { subject.should { query } }
+    it "adds the query given by executing the block to the bool query's should list" do
+      expect(subject.base.should.first).to eq query
+    end
+  end
+
+  context '#must_not' do
+    before { subject.must_not { query } }
+    it "adds the query given by executing the block to the bool query's must_not list" do
+      expect(subject.base.must_not.first).to eq query
+    end
+  end
+
+end

data/spec/unit/daedal-sl/builder_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe DaedalSL::Builder do
+
+  subject { DaedalSL::Builder.new }
+
+  context '#query' do
+    context 'with a block' do
+      before do
+        subject.query { :foo }
+      end
+      it 'will yield the block and set that to @query' do
+        expect(subject.instance_variable_get(:@query)).to eq :foo
+      end
+    end
+  end
+
+  context '#filter' do
+    context 'with a block' do
+      before do
+        subject.filter { :foo }
+      end
+      it 'will yield the block and set that to @filter' do
+        expect(subject.instance_variable_get(:@filter)).to eq :foo
+      end
+    end
+  end
+
+  context '#from' do
+    before do
+      subject.from(5)
+    end
+    it 'will set the from parameter in the base hash correctly' do
+      expect(subject.instance_variable_get(:@options)[:from]).to eq 5
+    end
+  end
+
+  context '#size' do
+    before do
+      subject.size(5)
+    end
+    it 'will set the size parameter in the base hash correctly' do
+      expect(subject.instance_variable_get(:@options)[:size]).to eq 5
+    end
+  end
+
+  context '#paginate' do
+    it 'will convert the page and per_page into from and size, and call those methods' do
+      expect(subject).to receive(:from).with(14)
+      expect(subject).to receive(:size).with(7)
+      subject.paginate page: 3, per_page: 7
+    end
+  end
+
+  context '#fields' do
+    before { subject.fields(:foo, :bar) }
+    it 'will set the fields for the query' do
+      expect(subject.instance_variable_get(:@options)[:fields]).to eq [:foo, :bar]
+    end
+  end
+
+  context '#to_hash' do
+    context 'when a query is given' do
+      before do
+        subject.instance_variable_set(:@query, Daedal::Queries::MatchQuery.new(field: :foo, query: :bar))
+      end
+      it 'will convert @query to a hash' do
+        expect(subject.to_hash).to eq({query: {match: {foo: {query: :bar}}}})
+      end
+    end
+    context 'when a query is not given' do
+      it 'will use the default match_all query' do
+        expect(subject.to_hash).to eq({query: {match_all: {}}})
+      end
+    end
+    context 'when a filter is given' do
+      before do
+        subject.instance_variable_set(:@filter, Daedal::Filters::TermFilter.new(field: :foo, term: :bar))
+      end
+      it 'will convert @filter to a hash' do
+        expect(subject.to_hash).to eq({query: {match_all: {}}, filter: {term: {foo: :bar}}})
+      end
+    end
+    context 'when from and size were specified' do
+      before do
+        subject.from 3
+        subject.size 10
+      end
+      it 'will set them up appropriately in the query' do
+        expect(subject.to_hash).to eq({query: {match_all: {}}, from: 3, size: 10})
+      end
+    end
+  end
+
+end

data/spec/unit/daedal-sl/dis_max_query_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe DaedalSL::DisMaxQuery do
+
+  subject do
+    DaedalSL::DisMaxQuery.new(:parent, {})
+  end
+
+  let(:query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  context '#query' do
+    before { subject.query { query } }
+    it "adds the query given by executing the block to the bool query's query list" do
+      expect(subject.base.queries.first).to eq query
+    end
+  end
+
+end

data/spec/unit/daedal-sl/nested_bool_filter_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe DaedalSL::NestedBoolFilter do
+
+  subject do
+    DaedalSL::NestedBoolFilter.new(:parent, path: :foo)
+  end
+
+  let(:filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  context '#must' do
+    before { subject.must { filter } }
+    it "adds the filter given by executing the block to the bool filter's must list" do
+      expect(subject.base.filter.must.first).to eq filter
+    end
+  end
+
+  context '#should' do
+    before { subject.should { filter } }
+    it "adds the filter given by executing the block to the bool filter's should list" do
+      expect(subject.base.filter.should.first).to eq filter
+    end
+  end
+
+  context '#must_not' do
+    before { subject.must_not { filter } }
+    it "adds the filter given by executing the block to the bool filter's must_not list" do
+      expect(subject.base.filter.must_not.first).to eq filter
+    end
+  end
+
+end

data/spec/unit/daedal-sl/nested_bool_query_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe DaedalSL::NestedBoolQuery do
+
+  subject do
+    DaedalSL::NestedBoolQuery.new(:parent, path: :foo)
+  end
+
+  let(:query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  context '#must' do
+    before { subject.must { query } }
+    it "adds the query given by executing the block to the bool query's must list" do
+      expect(subject.base.query.must.first).to eq query
+    end
+  end
+
+  context '#should' do
+    before { subject.should { query } }
+    it "adds the query given by executing the block to the bool query's should list" do
+      expect(subject.base.query.should.first).to eq query
+    end
+  end
+
+  context '#must_not' do
+    before { subject.must_not { query } }
+    it "adds the query given by executing the block to the bool query's must_not list" do
+      expect(subject.base.query.must_not.first).to eq query
+    end
+  end
+
+end

data/spec/unit/daedal-sl/nested_dis_max_query_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe DaedalSL::NestedDisMaxQuery do
+
+  subject do
+    DaedalSL::NestedDisMaxQuery.new(:parent, path: :foo)
+  end
+
+  let(:query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  context '#query' do
+    before { subject.query { query } }
+    it "adds the query given by executing the block to the bool query's query list" do
+      expect(subject.base.query.queries.first).to eq query
+    end
+  end
+
+end

data/spec/unit/daedal-sl/or_filter_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe DaedalSL::OrFilter do
+
+  subject do
+    DaedalSL::OrFilter.new(:parent, {})
+  end
+
+  let(:filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  context '#filter' do
+    before { subject.filter { filter } }
+    it "adds the filter given by executing the block to the and filter's filter list" do
+      expect(subject.base.filters.first).to eq filter
+    end
+  end
+
+end

data/spec/unit/daedal-sl/query_helpers_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe DaedalSL::QueryHelpers do
+
+  subject do
+    class QueryHelpersDummyClass
+      include DaedalSL::QueryHelpers
+      def data
+        :data
+      end
+    end
+    QueryHelpersDummyClass.new
+  end
+
+  context '#match_all' do
+    it 'will return a match all query' do
+      expect(Daedal::Queries::MatchAllQuery).to receive(:new).and_return(:foo)
+      expect(subject.match_all).to eq :foo
+    end
+  end
+
+  context '#match' do
+    it 'will return a match query' do
+      expect(Daedal::Queries::MatchQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.match(:foo)).to eq :bar
+    end
+  end
+
+  context '#fuzzy' do
+    it 'will return a fuzzy query' do
+      expect(Daedal::Queries::FuzzyQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.fuzzy(:foo)).to eq :bar
+    end
+  end
+
+  context '#geo_distance_filter' do
+    it 'will return a geo distance filter' do
+      expect(Daedal::Filters::GeoDistanceFilter).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.geo_distance_filter(:foo)).to eq :bar
+    end
+  end
+
+  context '#multi_match' do
+    it 'will return a multi match query' do
+      expect(Daedal::Queries::MultiMatchQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.multi_match(:foo)).to eq :bar
+    end
+  end
+
+  context '#prefix' do
+    it 'will return a prefix query' do
+      expect(Daedal::Queries::PrefixQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.prefix(:foo)).to eq :bar
+    end
+  end
+
+  context '#query_string' do
+    it 'will return a query string query' do
+      expect(Daedal::Queries::QueryStringQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.query_string(:foo)).to eq :bar
+    end
+  end
+
+  context '#term_filter' do
+    it 'will return a term filter' do
+      expect(Daedal::Filters::TermFilter).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.term_filter(:foo)).to eq :bar
+    end
+  end
+
+  context '#range_filter' do
+    it 'will return a range filter' do
+      expect(Daedal::Filters::RangeFilter).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.range_filter(:foo)).to eq :bar
+    end
+  end
+
+  context '#terms_filter' do
+    it 'will return a terms filter' do
+      expect(Daedal::Filters::TermsFilter).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.terms_filter(:foo)).to eq :bar
+    end
+  end
+
+  context '#exists_filter' do
+    it 'will return an exists filter' do
+      expect(Daedal::Filters::ExistsFilter).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.exists_filter(:foo)).to eq :bar
+    end
+  end
+
+  context '#filtered_query' do
+    it 'will return a filtered query' do
+      expect(Daedal::Queries::FilteredQuery).to receive(:new).with(:foo).and_return(:bar)
+      expect(subject.filtered_query(:foo)).to eq :bar
+    end
+  end
+
+  context '#bool_query' do
+    it 'will return a bool query' do
+      expect(DaedalSL::BoolQuery).to receive(:build).with(subject, {}).and_return(:bar)
+      expect(subject.bool_query({}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:bool=>{:should=>[{:match=>{:foo=>{:query=>:bar}}}], :must=>[{:match=>{:data=>{:query=>:data}}}], :must_not=>[{:match=>{:foo=>{:query=>:bar}}}], :boost=>10.0}}
+      result = subject.bool_query(boost: 10) do
+        must { match field: data, query: data }
+        should { match field: :foo, query: :bar }
+        must_not { match field: :foo, query: :bar }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#bool_filter' do
+    it 'will return a bool filter' do
+      expect(DaedalSL::BoolFilter).to receive(:build).with(subject, {}).and_return(:bar)
+      expect(subject.bool_filter({}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:bool=>{:should=>[{:term=>{:foo=>:bar}}], :must=>[{:term=>{:data=>:data}}], :must_not=>[{:term=>{:foo=>:bar}}]}}
+      result = subject.bool_filter do
+        must { term_filter field: data, term: data }
+        should { term_filter field: :foo, term: :bar }
+        must_not { term_filter field: :foo, term: :bar }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#dis_max' do
+    it 'will return a dis max query' do
+      expect(DaedalSL::DisMaxQuery).to receive(:build).with(subject, {}).and_return(:bar)
+      expect(subject.dis_max({}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:dis_max=>{:queries=>[{:match=>{:data=>{:query=>:data}}}], :boost=>10.0}}
+      result = subject.dis_max(boost: 10) do
+        query { match field: data, query: data }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#and_filter' do
+    it 'will return a and filter' do
+      expect(DaedalSL::AndFilter).to receive(:build).with(subject, {}).and_return(:bar)
+      expect(subject.and_filter({}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:and=>[{:term=>{:data=>:data}}]}
+      result = subject.and_filter(boost: 10) do
+        filter { term_filter field: data, term: data }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#or_filter' do
+    it 'will return a and filter' do
+      expect(DaedalSL::OrFilter).to receive(:build).with(subject, {}).and_return(:bar)
+      expect(subject.or_filter({}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:or=>[{:term=>{:data=>:data}}]}
+      result = subject.or_filter(boost: 10) do
+        filter { term_filter field: data, term: data }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#nested_bool_query' do
+    it 'will return a nested bool query' do
+      expect(DaedalSL::NestedBoolQuery).to receive(:build).with(subject, {path: :foo}).and_return(:bar)
+      expect(subject.nested_bool_query({path: :foo}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:nested=>{:path=>:foo, :query=>{:bool=>{:should=>[{:match=>{:foo=>{:query=>:bar}}}], :must=>[{:match=>{:data=>{:query=>:data}}}], :must_not=>[{:match=>{:foo=>{:query=>:bar}}}]}}}}
+      result = subject.nested_bool_query(path: :foo) do
+        must { match field: data, query: data }
+        should { match field: :foo, query: :bar }
+        must_not { match field: :foo, query: :bar }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#nested_bool_filter' do
+    it 'will return a nested bool query' do
+      expect(DaedalSL::NestedBoolFilter).to receive(:build).with(subject, {path: :foo}).and_return(:bar)
+      expect(subject.nested_bool_filter({path: :foo}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:nested=>{:path=>:foo, :filter=>{:bool=>{:should=>[{:term=>{:foo=>:bar}}], :must=>[{:term=>{:data=>:data}}], :must_not=>[{:term=>{:foo=>:bar}}]}}}}
+      result = subject.nested_bool_filter(path: :foo) do
+        must { term_filter field: data, term: data }
+        should { term_filter field: :foo, term: :bar }
+        must_not { term_filter field: :foo, term: :bar }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+  context '#nested_dis_max_query' do
+    it 'will return a nested bool query' do
+      expect(DaedalSL::NestedDisMaxQuery).to receive(:build).with(subject, {path: :foo}).and_return(:bar)
+      expect(subject.nested_dis_max_query({path: :foo}, &:foo)).to eq :bar
+    end
+    it 'sets up the parent correctly to allow @data and the other query helpers to be used' do
+      expected_result = {:nested=>{:path=>:foo, :query=>{:dis_max=>{:queries=>[{:match=>{:data=>{:query=>:data}}}]}}}}
+      result = subject.nested_dis_max_query(path: :foo) do
+        query { match field: data, query: data }
+      end
+      expect(result.to_hash).to eq expected_result
+    end
+  end
+
+end