daedal 0.0.2

data/spec/unit/daedal/queries/dis_max_query_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'daedal/queries'
+
+describe Daedal::Queries::DisMaxQuery do
+
+  subject do
+    Daedal::Queries::DisMaxQuery
+  end
+
+  let(:match_query) do
+    Daedal::Queries::MatchQuery
+  end
+
+  let(:hash_query) do
+    {dis_max: {queries: []}}
+  end
+
+  context 'with no initial queries specified' do
+    let(:query) do
+      subject.new
+    end
+
+    it 'will give an empty dis max query' do
+      expect(query.queries).to eq Array.new
+    end
+
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_query.to_json
+    end
+
+    context 'with a tie breaker specified' do
+      before do
+        hash_query[:dis_max][:tie_breaker] = 2.0
+      end
+      let(:query_with_min) do
+        subject.new(tie_breaker: 2)
+      end
+      it 'will set the tie_breaker parameter' do
+        expect(query_with_min.tie_breaker).to eq 2.0
+      end
+      it 'will have the correct hash representation' do
+        expect(query_with_min.to_hash).to eq hash_query
+      end
+      it 'will have the correct json representation' do
+        expect(query_with_min.to_json).to eq hash_query.to_json
+      end
+    end
+
+    context 'with a boost specified' do
+      before do
+        hash_query[:dis_max][:boost] = 2
+      end
+      let(:query_with_boost) do
+        subject.new(boost: 2)
+      end
+      it 'will set the boost parameter' do
+        expect(query_with_boost.boost).to eq 2
+      end
+      it 'will have the correct hash representation' do
+        expect(query_with_boost.to_hash).to eq hash_query
+      end
+      it 'will have the correct json representation' do
+        expect(query_with_boost.to_json).to eq hash_query.to_json
+      end
+    end
+  end
+
+  context 'with initial array of queries specified' do
+
+    let(:queries) do
+      [match_query.new(field: :a, query: :b), match_query.new(field: :c, query: :d)]
+    end
+
+    let(:query) do
+      subject.new(queries: queries)
+    end
+
+    before do
+      hash_query[:dis_max][:queries] = queries.map {|q| q.to_hash}
+    end
+
+    it 'will create a dis_max query with the appropriate initial array of queries' do
+      expect(query.queries).to eq queries
+    end
+
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with an initial array of non queries specified' do
+    it 'will raise an error' do
+      expect {subject.new(queries: [:foo])}.to raise_error
+    end
+  end
+
+  context 'with a query (not in an array) specified' do
+    let(:mq) do
+      match_query.new(field: :a, query: :b)
+    end
+
+    let(:query) do
+      subject.new(queries: mq)
+    end
+
+    it 'will convert the input into an array of the single query' do
+      expect(query.queries).to eq([mq])
+    end
+  end
+
+  context 'when adding more queries' do
+    let(:query) do
+      subject.new
+    end
+    let(:mq) do
+      match_query.new(field: :a, query: :b)
+    end
+
+    context 'with the #add_query method' do
+      before do
+        query.add_query mq
+      end
+      it 'will add a query' do
+        expect(query.queries).to eq [mq]
+      end
+
+      context 'twice' do
+        before do
+          query.add_query mq
+        end
+        it 'will append the second query' do
+          expect(query.queries).to eq [mq, mq]
+        end
+      end
+
+      context 'with a non-valid query' do
+        it 'will raise an error' do
+          expect{query.add_query :foo}.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/unit/daedal/queries/filtered_query_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'daedal/queries'
+
+describe Daedal::Queries::FilteredQuery do
+
+  subject do
+    Daedal::Queries::FilteredQuery
+  end
+
+  let(:match_query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  let(:term_filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  let(:hash_query) do
+    {filtered: {query: match_query.to_hash, filter: term_filter.to_hash}}
+  end
+
+  context 'with no query or filter specified' do
+
+    let(:base_filter) do
+      Daedal::Filters::BaseFilter.new
+    end
+    let(:match_all_query) do
+      Daedal::Queries::MatchAllQuery.new
+    end
+    let(:query) do
+      subject.new
+    end
+
+    it 'will create an empty filtered query with a match_all query and a blank filter' do
+      expect(query.query.to_hash).to eq match_all_query.to_hash
+      expect(query.filter.to_hash).to eq base_filter.to_hash
+    end
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq({filtered: {query: {match_all: {}}, filter: {}}})
+    end
+  end
+
+  context 'with a query and a filter specified' do
+    let(:query) do
+      subject.new(query: match_query, filter: term_filter)
+    end
+
+    it 'will create a filtered query with the correct values' do
+      expect(query.query).to eq match_query
+      expect(query.filter).to eq term_filter
+    end
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_query
+    end
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+end

data/spec/unit/daedal/queries/match_all_query_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'daedal/queries'
+
+describe Daedal::Queries::MatchAllQuery do
+
+  subject do
+    Daedal::Queries::MatchAllQuery.new
+  end
+
+  context 'when calling #new' do
+    it 'will have the correct hash representation' do
+      expect(subject.to_hash).to eq({match_all: {}})
+    end
+    it 'will have the correct json representation' do
+      expect(subject.to_json).to eq({match_all: {}}.to_json)
+    end
+  end
+
+end

data/spec/unit/daedal/queries/match_query_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+require 'daedal/queries'
+
+describe Daedal::Queries::MatchQuery do
+
+  subject do
+    Daedal::Queries::MatchQuery
+  end
+
+  let(:base_query) do
+    {match: {foo: {query: :bar}}}
+  end
+
+  context 'without a field or term given' do
+    it 'will raise an error' do
+      expect {subject.new}.to raise_error
+    end
+  end
+
+  context 'without a term given' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo)}.to raise_error
+    end
+  end
+
+  context 'with a field and term given' do
+
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar)
+    end
+
+    it 'will create a match query object that has the correct field and term' do
+      expect(match_query.field).to eq :foo
+      expect(match_query.query).to eq :bar
+    end
+
+    it 'will have the other options set to nil' do
+      expect(match_query.minimum_should_match).to eq nil
+      expect(match_query.cutoff_frequency).to eq nil
+      expect(match_query.type).to eq nil
+      expect(match_query.analyzer).to eq nil
+      expect(match_query.boost).to eq nil
+      expect(match_query.fuzziness).to eq nil
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context "with an operator of :and specified" do
+
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, operator: :and)
+    end
+
+    before do
+      base_query[:match][:foo][:operator] = :and
+    end
+
+    it 'will set the operator to :and' do
+      expect(match_query.operator).to eq :and
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non-valid operator specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, operator: :foo)}.to raise_error
+    end
+  end
+
+  context 'with a phrase type specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, type: :phrase)
+    end
+
+    before do
+      base_query[:match][:foo][:type] = :phrase
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.type).to eq :phrase
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non-valid type specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, type: :foo)}.to raise_error
+    end
+  end
+
+  context 'with a minimum should match of 2 specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, minimum_should_match: 2)
+    end
+
+    before do
+      base_query[:match][:foo][:minimum_should_match] = 2
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.minimum_should_match).to eq 2
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non-integer minimum should match specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, minimum_should_match: 'foo')}.to raise_error
+    end
+  end
+
+  context 'with a cutoff frequency of 0.5 specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, cutoff_frequency: 0.5)
+    end
+
+    before do
+      base_query[:match][:foo][:cutoff_frequency] = 0.5
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.cutoff_frequency).to eq 0.5
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non-float cutoff frequency specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, cutoff_frequency: 'foo')}.to raise_error
+    end
+  end
+
+  context 'with an analyzer of :foo specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, analyzer: :foo)
+    end
+
+    before do
+      base_query[:match][:foo][:analyzer] = :foo
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.analyzer).to eq :foo
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a boost of 2 specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, boost: 2)
+    end
+
+    before do
+      base_query[:match][:foo][:boost] = 2
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.boost).to eq 2
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non integer boost specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, boost: 'foo')}.to raise_error
+    end
+  end
+
+  context 'with a fuzziness of 0.5 specified' do
+    let(:match_query) do
+      subject.new(field: :foo, query: :bar, fuzziness: 0.5)
+    end
+
+    before do
+      base_query[:match][:foo][:fuzziness] = 0.5
+    end
+
+    it 'will set the phrase type to :phrase' do
+      expect(match_query.fuzziness).to eq 0.5
+    end
+
+    it 'will have the correct hash representation' do
+      expect(match_query.to_hash).to eq base_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(match_query.to_json).to eq base_query.to_json
+    end
+  end
+
+  context 'with a non float or integer fuzziness specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: :foo, query: :bar, fuzziness: 'foo')}.to raise_error
+    end
+  end
+end