daedal 0.0.3 → 0.0.4

data/lib/daedal/version.rb

@@ -0,0 +1,3 @@
+module Daedal
+  VERSION = '0.0.4'
+end

data/spec/unit/daedal/filters/and_filter_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'daedal/filters'
+
+describe Daedal::Filters::AndFilter do
+
+  subject do
+    Daedal::Filters::AndFilter
+  end
+
+  let(:term_filter) do
+    Daedal::Filters::TermFilter.new field: :foo, term: :bar
+  end
+
+  context 'without an initial array of filters' do
+    let(:filter) do
+      subject.new
+    end
+    let(:hash_filter) do
+      nil
+    end
+    it 'will have an empty array of filters set' do
+      expect(filter.filters).to eq []
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with an initial array of filters' do
+    let(:filter) do
+      subject.new filters: [term_filter]
+    end
+    let(:hash_filter) do
+      {:and => [term_filter.to_hash]}
+    end
+
+    it 'will have the correct filter array set' do
+      expect(filter.filters).to eq [term_filter]
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'when adding more filters' do
+    let(:filter) do
+      subject.new
+    end
+    let(:hash_filter) do
+      {:and => [term_filter.to_hash]}
+    end
+
+    before do
+      filter.filters << term_filter
+    end
+
+    it 'will append the filter' do
+      expect(filter.filters).to eq [term_filter]
+    end
+    it 'will end up with the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+
+    context 'twice' do
+      before do
+        filter.filters << term_filter
+        hash_filter[:and] << term_filter.to_hash
+      end
+      it 'will append the second filter' do
+        expect(filter.filters).to eq [term_filter, term_filter]
+      end
+      it 'will still have the correct hasha nd json representations' do
+        expect(filter.to_hash).to eq hash_filter
+        expect(filter.to_json).to eq hash_filter.to_json
+      end
+    end
+
+    context 'when adding an invalid filter' do
+      it 'will raise an error' do
+        expect{filter.filters << :foo}.to raise_error(Virtus::CoercionError)
+      end
+    end
+  end
+end

data/spec/unit/daedal/filters/geo_distance_filter_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'daedal/filters'
+
+describe Daedal::Filters::GeoDistanceFilter do
+
+  subject do
+    Daedal::Filters::GeoDistanceFilter
+  end
+
+  context 'without a field specified' do
+    it 'will raise an error' do
+      expect{subject.new(distance: 5, lat: 10, lon: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'without a distance specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, lat: 10, lon: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'without a lat specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, distance: 10, lon: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'without a lon specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, lat: 10, distance: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'with a field, distance, lat, and lon specified' do
+    let(:query) do
+      subject.new(field: :foo, distance: 5, lat: 10, lon: 30)
+    end
+    let(:hash_query) do
+      {geo_distance: {distance: '5.0km', foo: {lat: 10.0, lon: 30.0}}}
+    end
+
+    it 'will set the field and distance appropriately' do
+      expect(query.field).to eq :foo
+      expect(query.distance).to eq 5.0
+      expect(query.lat).to eq 10.0
+      expect(query.lon).to eq 30.0
+    end
+
+    it 'will use km as the default unit' do
+      expect(query.unit).to eq 'km'
+    end
+
+    it 'will have the correct hash and json representations' do
+      expect(query.to_hash).to eq hash_query
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with a distance unit specified' do
+    let(:query) do
+      subject.new(field: :foo, distance: 5, lat: 10, lon: 30, unit: 'mi')
+    end
+    let(:hash_query) do
+      {geo_distance: {distance: '5.0mi', foo: {lat: 10.0, lon: 30.0}}}
+    end
+
+    it 'will set the field and distance appropriately' do
+      expect(query.field).to eq :foo
+      expect(query.distance).to eq 5.0
+      expect(query.lat).to eq 10.0
+      expect(query.lon).to eq 30.0
+      expect(query.unit).to eq 'mi'
+    end
+
+    it 'will have the correct hash and json representations' do
+      expect(query.to_hash).to eq hash_query
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with an invalid unit specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, distance: 5, lat: 10, lon: 30, unit: 'foo')}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'with an invalid lat specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, distance: 5, lat: 'foo', lon: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'with an invalid lon specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, distance: 5, lat: 10, lon: 'foo')}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'with an invalid distance specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo, distance: 'foo', lat: 10, lon: 30)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+end

data/spec/unit/daedal/filters/range_filter_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'daedal/filters'
+
+describe Daedal::Filters::RangeFilter do
+
+  subject do
+    Daedal::Filters::RangeFilter
+  end
+
+  let(:hash_filter) do
+    {range: {foo: {gte: 1, lte: 2}}}
+  end
+
+  context 'without a field specified' do
+    it 'will raise an error' do
+      expect{subject.new(gte: 1, lte: 2)}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'without a gte, lte, lt, or gt specified' do
+    it 'will raise an error' do
+      expect{subject.new(field: :foo)}.to raise_error
+    end
+  end
+
+  context 'with number gte and lte' do
+    let(:filter) do
+      subject.new(field: :foo, gte: 1, lte: 2)
+    end
+    it 'will create a range filter with the appropriate fields' do
+      expect(filter.field).to eq :foo
+      expect(filter.gte).to eq 1
+      expect(filter.lte).to eq 2
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with string gte and lte' do
+    let(:filter) do
+      subject.new(field: :foo, gte: 'a', lte: 'b')
+    end
+    before do
+      hash_filter[:range][:foo][:gte] = 'a'
+      hash_filter[:range][:foo][:lte] = 'b'
+    end
+    it 'will create a range filter with the appropriate fields' do
+      expect(filter.field).to eq :foo
+      expect(filter.gte).to eq 'a'
+      expect(filter.lte).to eq 'b'
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with number gt and lt' do
+    let(:filter) do
+      subject.new(field: :foo, gt: 1, lt: 2)
+    end
+    let(:hash_filter) do
+      {range: {foo: {lt: 2, gt: 1}}}
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with string gt and lt' do
+    let(:filter) do
+      subject.new(field: :foo, gt: 'a', lt: 'b')
+    end
+    let(:hash_filter) do
+      {range: {foo: {lt: 'b', gt: 'a'}}}
+    end
+    it 'will create a range filter with the appropriate fields' do
+      expect(filter.field).to eq :foo
+      expect(filter.gt).to eq 'a'
+      expect(filter.lt).to eq 'b'
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+end

data/spec/unit/daedal/filters/term_filter_spec.rb

@@ -21,19 +21,19 @@ describe Daedal::Filters::TermFilter do
 
   context 'without a field or a term specified' do
     it 'will raise an error' do
-      expect {subject.new}.to raise_error
+      expect {subject.new}.to raise_error(Virtus::CoercionError)
     end
   end
 
   context 'without a field specified' do
     it 'will raise an error' do
-      expect {subject.new(term: term)}.to raise_error
+      expect {subject.new(term: term)}.to raise_error(Virtus::CoercionError)
     end
   end
 
   context 'without a term specified' do
     it 'will raise an error' do
-      expect {subject.new(field: field)}.to raise_error
+      expect {subject.new(field: field)}.to raise_error(Virtus::CoercionError)
     end
   end
 

data/spec/unit/daedal/filters/terms_filter_spec.rb

@@ -21,13 +21,13 @@ describe Daedal::Filters::TermsFilter do
 
   context 'without a field or a list of terms specified' do
     it 'will raise an error' do
-      expect {subject.new}.to raise_error
+      expect {subject.new}.to raise_error(Virtus::CoercionError)
     end
   end
 
   context 'without a field specified' do
     it 'will raise an error' do
-      expect {subject.new(terms: terms)}.to raise_error
+      expect {subject.new(terms: terms)}.to raise_error(Virtus::CoercionError)
     end
   end
 

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

@@ -111,7 +111,45 @@ describe Daedal::Queries::BoolQuery do
 
   context 'with an initial array of non queries specified' do
     it 'will raise an error' do
-      expect {subject.new(should: [:foo])}.to raise_error
+      expect {subject.new(should: [:foo])}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'with disable_coord specified' do
+    let(:query) do
+      subject.new(disable_coord: false)
+    end
+    before do
+      hash_query[:bool][:disable_coord] = false
+    end
+    it 'will set disable_coord properly' do
+      expect(query.disable_coord).to eq false
+    end
+    it 'will have the correct hash and json representations' do
+      expect(query.to_hash).to eq hash_query
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with name specified' do
+    let(:query) do
+      subject.new(name: :foo)
+    end
+    before do
+      hash_query[:bool][:_name] = :foo
+    end
+    it 'will set name properly' do
+      expect(query.name).to eq :foo
+    end
+    it 'will have the correct hash and json representations' do
+      expect(query.to_hash).to eq hash_query
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with a non boolean name specified' do
+    it 'will raise an error' do
+      expect{subject.new(name: [])}.to raise_error(Virtus::CoercionError)
     end
   end
 
@@ -156,7 +194,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect{query.should << :foo}.to raise_error
+          expect{query.should << :foo}.to raise_error(Virtus::CoercionError)
         end
       end
     end
@@ -181,7 +219,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect {query.must << :foo}.to raise_error
+          expect {query.must << :foo}.to raise_error(Virtus::CoercionError)
         end
       end
 
@@ -207,7 +245,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect {query.must_not << :foo}.to raise_error
+          expect {query.must_not << :foo}.to raise_error(Virtus::CoercionError)
         end
       end
     end

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

@@ -32,19 +32,19 @@ describe Daedal::Queries::ConstantScoreQuery do
 
   context 'without a boost specified' do
     it 'will raise an error' do
-      expect{subject.new(query: match_query)}.to raise_error
+      expect{subject.new(query: match_query)}.to raise_error(Virtus::CoercionError)
     end
   end
 
   context 'with a boost but an invalid query specified' do
     it 'will raise an error' do
-      expect {subject.new(boost: 5, query: :foo)}.to raise_error
+      expect {subject.new(boost: 5, query: :foo)}.to raise_error(Virtus::CoercionError)
     end
   end
 
   context 'with a boost but an invalid filter specified' do
     it 'will raise an error' do
-      expect {subject.new(boost: 5, filter: :foo)}.to raise_error
+      expect {subject.new(boost: 5, filter: :foo)}.to raise_error(Virtus::CoercionError)
     end
   end
 

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

@@ -98,7 +98,7 @@ describe Daedal::Queries::DisMaxQuery do
 
   context 'with an initial array of non queries specified' do
     it 'will raise an error' do
-      expect {subject.new(queries: [:foo])}.to raise_error
+      expect {subject.new(queries: [:foo])}.to raise_error(Virtus::CoercionError)
     end
   end
 
@@ -116,6 +116,22 @@ describe Daedal::Queries::DisMaxQuery do
     end
   end
 
+  context 'with name specified' do
+    let(:query) do
+      subject.new(name: :foo)
+    end
+    before do
+      hash_query[:dis_max][:_name] = :foo
+    end
+    it 'will set name properly' do
+      expect(query.name).to eq :foo
+    end
+    it 'will have the correct hash and json representations' do
+      expect(query.to_hash).to eq hash_query
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
   context 'when adding more queries' do
     let(:query) do
       subject.new
@@ -143,7 +159,7 @@ describe Daedal::Queries::DisMaxQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect{query.queries << :foo}.to raise_error
+          expect{query.queries << :foo}.to raise_error(Virtus::CoercionError)
         end
       end
     end