elastictastic 0.5.0

data/spec/examples/search_spec.rb

@@ -0,0 +1,382 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+#
+# Here we describe the functionality for constructing queries, which is (sort of)
+# what the Search module does. See spec/examples/scope_spec to test running the
+# search and dealing with the results
+#
+describe Elastictastic::Search do
+  describe '#to_params' do
+    {
+      'query' => { 'match_all' => {} },
+      'filter' => { 'ids' => { 'values' => 1 }},
+      'from' => 10,
+      'sort' => { 'created_at' => 'desc' },
+      'highlight' => { 'fields' => { 'body' => {}}},
+      'fields' => %w(title body),
+      'script_fields' => { 'rtitle' => { 'script' => "_source.title.reverse()" }},
+      'preference' => '_local',
+      'facets' => { 'tags' => { 'terms' => { 'field' => 'tags' }}}
+    }.each_pair do |method, value|
+      it "should build scope for #{method} param" do
+        Post.__send__(method, value).params.should == { method => value }
+      end
+    end
+
+    it 'should raise ArgumentError if no value passed' do
+      expect { Post.query }.to raise_error(ArgumentError)
+    end
+
+    it 'should not cast single arg to an array' do
+      Post.fields('title').params.should == { 'fields' => 'title' }
+    end
+
+    it 'should take multiple args and convert them to an array' do
+      Post.fields('title', 'body').params.should ==
+        { 'fields' => %w(title body) }
+    end
+
+    it 'should chain scopes' do
+      Post.from(30).size(15).params.should == { 'from' => 30, 'size' => 15 }
+    end
+
+    it 'should not chain destructively' do
+      scope = Post.from(20)
+      scope.size(10)
+      scope.params.should == { 'from' => 20 }
+    end
+  end
+
+  describe 'merging' do
+    let(:scope) { Post }
+
+    it 'should merge two simple queries into a bool' do
+      scope.query { term(:title => 'Pizza') }.query { term(:comments_count => 0) }.params.should == {
+        'query' => {
+          'bool' => {
+            'must' => [
+              { 'term' => { 'title' => 'Pizza' }},
+              { 'term' => { 'comments_count' => 0 }}
+            ]
+          }
+        }
+      }
+    end
+
+    it 'should merge three simple queries into a bool' do
+      scope = self.scope.query { term(:title => 'pizza') }
+      scope = scope.query { term(:comments_count => 1) }
+      scope = scope.query { term(:tags => 'delicious') }
+      scope.params.should == {
+        'query' => {
+          'bool' => {
+            'must' => [
+              { 'term' => { 'title' => 'pizza' }},
+              { 'term' => { 'comments_count' => 1 }},
+              { 'term' => { 'tags' => 'delicious' }}
+            ]
+          }
+        }
+      }
+    end
+
+    it 'should merge a new query into an existing boolean query' do
+      scope = self.scope.query { bool { must({ 'term' => { 'title' => 'pizza' }}, { 'term' => { 'comments_count' => 1 }}) }}
+      scope = scope.query { term(:tags => 'delicious') }
+      scope.params.should == {
+        'query' => {
+          'bool' => {
+            'must' => [
+              { 'term' => { 'title' => 'pizza' }},
+              { 'term' => { 'comments_count' => 1 }},
+              { 'term' => { 'tags' => 'delicious' }}
+            ]
+          }
+        }
+      }
+    end
+
+    it 'should merge a new query into an existing filtered query' do
+      scope = self.scope.query do
+        filtered do
+          query { term('title' => 'pizza') }
+          filter { term('comments_count' => 1) }
+        end
+      end
+      scope = scope.query { term('tags' => 'delicious') }
+      scope.params['query'].should == {
+        'filtered' => {
+          'query' => { 'bool' => { 'must' => [{ 'term' => { 'title' => 'pizza' }}, { 'term' => { 'tags' => 'delicious' }}] }},
+          'filter' => { 'term' => { 'comments_count' => 1 }}
+        }
+      }
+    end
+
+    it 'should merge two filtered queries' do
+      scope = self.scope.query do
+        filtered do
+          query { term('title' => 'pizza') }
+          filter { term('comments_count' => 1) }
+        end
+      end
+      scope = scope.query do
+        filtered do
+          query { term('title' => 'pepperoni') }
+          filter { term('tags' => 'delicious') }
+        end
+      end
+      scope.params.should == {
+        'query' => {
+          'filtered' => {
+            'query' => { 'bool' => { 'must' => [
+              { 'term' => { 'title' => 'pizza' }},
+              { 'term' => { 'title' => 'pepperoni' }}
+            ]}},
+            'filter' => { 'and' => [
+              { 'term' => { 'comments_count' => 1 }},
+              { 'term' => { 'tags' => 'delicious' }}
+            ]}
+          }
+        }
+      }
+    end
+
+    it 'should merge a regular query with a constant-score filter query' do
+      scope = self.scope.query('term' => { 'title' => 'pizza' })
+      scope = scope.query { constant_score { filter { term('tags' => 'delicious') }}}
+      scope.params.should == {
+        'query' => {
+          'filtered' => {
+            'query' => { 'term' => { 'title' => 'pizza' }},
+            'filter' => { 'term' => { 'tags' => 'delicious' }}
+          }
+        }
+      }
+    end
+
+    it 'should merge two constant-score filter queries' do
+      scope = self.scope.query { constant_score { filter { term('tags' => 'delicious') }}}
+      scope = scope.query { constant_score { filter { term('comments_count' => 0) }}}
+      scope.params.should == {
+        'query' => {
+          'constant_score' => {
+            'filter' => {
+              'and' => [
+                { 'term' => { 'tags' => 'delicious' }},
+                { 'term' => { 'comments_count' => 0 }}
+              ]
+            }
+          }
+        }
+      }
+    end
+
+    it 'should merge a constant-score filter query into a constant-score conjunction query' do
+      scope = self.scope.query { constant_score { filter('and' => [{ 'term' => { 'title' => 'pizza' }}, { 'term' => { 'tags' => 'delicious' }}]) }}
+      scope = scope.query { constant_score { filter { term('comments_count' => 0) }}}
+      scope.params.should == {
+        'query' => {
+          'constant_score' => {
+            'filter' => {
+              'and' => [
+                { 'term' => { 'title' => 'pizza' }},
+                { 'term' => { 'tags' => 'delicious' }},
+                { 'term' => { 'comments_count' => 0 }}
+              ]
+            }
+          }
+        }
+      }
+    end
+
+    it 'should merge two filters' do
+      scope = self.scope.filter('term' => { 'comments_count' => 0 })
+      scope = scope.filter('term' => { 'tags' => 'delicious' })
+      scope.params.should == {
+        'filter' => { 'and' => [
+          { 'term' => { 'comments_count' => 0 }},
+          { 'term' => { 'tags' => 'delicious' }}
+        ]}
+      }
+    end
+
+    it 'should merge filter into conjunction' do
+      scope = self.scope.filter('and' => [{ 'term' => { 'title' => 'pizza' }}, { 'term' => { 'comments_count' => 0 }}])
+      scope = scope.filter('term' => { 'tags' => 'delicious' })
+      scope.params.should == {
+        'filter' => { 'and' => [
+          { 'term' => { 'title' => 'pizza' }},
+          { 'term' => { 'comments_count' => 0 }},
+          { 'term' => { 'tags' => 'delicious' }}
+        ]}
+      }
+    end
+    
+    it 'should override from when chaining' do
+      scope.from(10).from(20).params.should == { 'from' => 20 }
+    end
+
+    it 'should not override from when not given' do
+      scope.from(10).size(10).params.should == { 'from' => 10, 'size' => 10 }
+    end
+
+    it 'should override size when chaining' do
+      scope.size(10).size(15).params.should == { 'size' => 15 }
+    end
+
+    it 'should concatenate chained sorts' do
+      scope.sort('title' => 'asc').sort('comments_count' => 'desc').params.should == {
+        'sort' => [{ 'title' => 'asc' }, { 'comments_count' => 'desc' }]
+      }
+    end
+
+    it 'should concatenate chained sort onto multiple sorts' do
+      scope.sort({ 'title' => 'asc' }, { 'comments_count' => 'desc' }).sort('created_at' => 'desc').params.should == {
+        'sort' => [{ 'title' => 'asc' }, { 'comments_count' => 'desc' }, { 'created_at' => 'desc' }]
+      }
+    end
+
+    it 'should merge highlight fields' do
+      scope.highlight { fields('title' => {}) }.highlight { fields('tags' => {}) }.params.should == {
+        'highlight' => { 'fields' => { 'title' => {}, 'tags' => {} }}
+      }
+    end
+
+    it 'should move global highlight settings into fields when merging' do
+      scope = self.scope.highlight do
+        fields('title' => {})
+        number_of_fragments(0)
+      end
+      scope = scope.highlight do
+        fields('tags' => {})
+        number_of_fragments(1)
+      end
+      scope.params.should == {
+        'highlight' => {
+          'fields' => {
+            'title' => { 'number_of_fragments' => 0 },
+            'tags' => { 'number_of_fragments' => 1 }
+          }
+        }
+      }
+    end
+
+    it 'should not override field-specific highlight settings when moving global settings' do
+      scope = self.scope.highlight do
+        fields(:title => { :number_of_fragments => 0 }, :tags => {})
+        number_of_fragments 1
+      end
+      scope = scope.highlight do
+        fields('comments.body' => {})
+        number_of_fragments 2
+      end
+      scope.params.should == {
+        'highlight' => {
+          'fields' => {
+            'title' => { 'number_of_fragments' => 0 },
+            'tags' => { 'number_of_fragments' => 1 },
+            'comments.body' => { 'number_of_fragments' => 2 }
+          }
+        }
+      }
+    end
+
+    it 'should concatenate fields' do
+      scope.fields('title').fields('tags').params.should == {
+        'fields' => %w(title tags)
+      }
+    end
+
+    it 'should concatenate onto arrays of fields' do
+      scope.fields('title', 'comments.body').fields('tags').params.should == {
+        'fields' => %w(title comments.body tags)
+      }
+    end
+
+    it 'should merge script fields' do
+      scope.script_fields(:test1 => { 'script' => '1' }).script_fields(:test2 => { 'script' => '2' }).params.should == {
+        'script_fields' => { 'test1' => { 'script' => '1' }, 'test2' => { 'script' => '2' }}
+      }
+    end
+
+    it 'should overwrite chained preference' do
+      scope.preference('_local').preference('_primary').params.should ==
+        { 'preference' => '_primary' }
+    end
+
+    it 'should merge facets' do
+      scope = self.scope.facets(:title => { :terms => { :field => 'title' }})
+      scope = scope.facets(:tags => { :terms => { :field => 'tags' }})
+      scope.params.should == {
+        'facets' => {
+          'title' => { 'terms' => { 'field' => 'title' }},
+          'tags' => { 'terms' => { 'field' => 'tags' }}
+        }
+      }
+    end
+  end
+
+  describe 'block builder' do
+    it 'should build scopes with a block' do
+      Post.sort { title 'asc' }.params.should ==
+        { 'sort' => { 'title' => 'asc' }}
+    end
+
+    it 'should accept multiple calls within a block' do
+      scope = Post.sort do
+        title 'asc'
+        created_at 'desc'
+      end
+      scope.params.should ==
+        { 'sort' => { 'title' => 'asc', 'created_at' => 'desc' }}
+    end
+
+    it 'should turn varargs into array' do
+      Post.highlight { fields 'body', 'comments.body' }.params.should ==
+        { 'highlight' => { 'fields' => %w(body comments.body) }}
+    end
+
+    it 'should accept nested calls within a block' do
+      scope = Post.query do
+        query_string { query 'test testor' }
+      end
+      scope.params.should ==
+        { 'query' => { 'query_string' => { 'query' => 'test testor' }}}
+    end
+
+    it 'should set value to empty object (Hash) if none passed' do
+      scope = Post.query { match_all }.params.should ==
+        { 'query' => { 'match_all' => {} }}
+    end
+  end
+
+  describe 'class methods' do
+    let(:named_scope) do
+      Post.from(10).search_keywords('hey guy')
+    end
+
+    it 'should delegate to class singleton' do
+      named_scope.params['query'].should == {
+        'query_string' => { 'query' => 'hey guy', 'fields' => %w(title body) }
+      }
+    end
+
+    it 'should retain current scope' do
+      named_scope.params['from'].should == 10
+    end
+  end
+
+  describe 'class methods directly on type-in-index' do
+    let(:named_scope) { Post.in_index('my_index').search_keywords('hey guy') }
+
+    it 'should delegate to class singleton when called on type_in_index' do
+      named_scope.params['query'].should == {
+        'query_string' => { 'query' => 'hey guy', 'fields' => %w(title body) }
+      }
+    end
+
+    it 'should use proper index in scope' do
+      named_scope.index.name.should == 'my_index'
+    end
+  end
+end

data/spec/examples/spec_helper.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../environment', __FILE__)
+require 'fakeweb'
+
+require File.expand_path('../../support/fakeweb_request_history', __FILE__)
+
+RSpec.configure do |config|
+  config.before(:all) do
+    FakeWeb.allow_net_connect = false
+  end
+
+  config.after(:each) do
+    FakeWeb.requests.clear
+    FakeWeb.clean_registry
+  end
+end

data/spec/examples/validation_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Elastictastic::Validations do
+  include Elastictastic::TestHelpers
+
+  let(:post) { Post.new(:title => 'INVALID') }
+
+  describe 'with invalid data' do
+    it 'should not be valid' do
+      post.should_not be_valid
+    end
+
+    it 'should not persist to ElasticSearch on save' do
+      expect { post.save }.to_not raise_error(FakeWeb::NetConnectNotAllowedError)
+    end
+
+    it 'should return false for save' do
+      post.save.should be_false
+    end
+
+    it 'should raise Elastictastic::RecordInvalid for save!' do
+      expect { post.save! }.to raise_error(Elastictastic::RecordInvalid)
+    end
+  end
+
+  describe 'with valid data' do
+    let(:post) { Post.new }
+
+    before { stub_elasticsearch_create('default', 'post') }
+
+    it 'should be valid' do
+      post.should be_valid
+    end
+
+    it 'should persist to ElasticSearch on save' do
+      post.save
+      FakeWeb.last_request.should be
+    end
+
+    it 'should return true from save' do
+      post.save.should be_true
+    end
+
+    it 'should persist to ElasticSearch without error on save!' do
+      post.save!
+      FakeWeb.last_request.should be
+    end
+  end
+
+  context 'with invalid nested document' do
+    let(:post) do
+      Post.new.tap do |post|
+        post.author = Author.new(:name => 'INVALID')
+      end
+    end
+
+    it 'should not be valid' do
+      post.should_not be_valid
+    end
+
+    it 'should have an error for author' do
+      post.errors['author'].should be
+    end
+  end
+end

data/spec/models/author.rb

@@ -0,0 +1,9 @@
+class Author
+  include Elastictastic::NestedDocument
+
+  field :id, :type => 'integer'
+  field :name
+  field :email, :index => 'not_analyzed'
+
+  validates :name, :exclusion => %w(INVALID)
+end

data/spec/models/blog.rb

@@ -0,0 +1,5 @@
+class Blog
+  include Elastictastic::Document
+
+  has_many :posts
+end

data/spec/models/comment.rb

@@ -0,0 +1,5 @@
+class Comment
+  include Elastictastic::NestedDocument
+
+  field :body
+end

data/spec/models/post.rb

@@ -0,0 +1,41 @@
+class Post
+  include Elastictastic::Document
+
+  field :title
+  field :comments_count, :type => 'integer'
+  field :tags, :index => 'analyzed' do
+    field :non_analyzed, :index => 'not_analyzed'
+  end
+  field :created_at, :type => 'date'
+  field :published_at, :type => 'date'
+
+  embed :author
+  embed :comments
+
+  belongs_to :blog
+
+  attr_accessible :title
+
+  validates :title, :exclusion => %w(INVALID)
+
+  def observers_that_ran
+    @observers_that_ran ||= Set[]
+  end
+
+  def self.search_keywords(keywords)
+    query do
+      query_string do
+        query(keywords)
+        fields 'title', 'body'
+      end
+    end
+  end
+
+  def self.from_hash(hash)
+    new.tap do |post|
+      hash.each_pair do |field, value|
+        post.__send__("#{field}=", value)
+      end
+    end
+  end
+end

data/spec/models/post_observer.rb

@@ -0,0 +1,11 @@
+class PostObserver < Elastictastic::Observer
+  %w(create update save destroy).each do |lifecycle|
+    %w(before after).each do |phase|
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{phase}_#{lifecycle}(post)
+          post.observers_that_ran << :#{phase}_#{lifecycle}
+        end
+      RUBY
+    end
+  end
+end

data/spec/support/fakeweb_request_history.rb

@@ -0,0 +1,13 @@
+class <<FakeWeb
+  def last_request=(request)
+    requests << request
+  end
+
+  def last_request
+    requests.last
+  end
+
+  def requests
+    @requests ||= []
+  end
+end