slingshot-rb 0.0.1

data/test/fixtures/articles/1.json

@@ -0,0 +1 @@
+{"title" : "One", "tags" : ["ruby"]}

data/test/fixtures/articles/2.json

@@ -0,0 +1 @@
+{"title" : "Two", "tags" : ["ruby", "python"]}

data/test/fixtures/articles/3.json

@@ -0,0 +1 @@
+{"title" : "Three", "tags" : ["java"]}

data/test/fixtures/articles/4.json

@@ -0,0 +1 @@
+{"title" : "Four", "tags" : ["erlang"]}

data/test/fixtures/articles/5.json

@@ -0,0 +1 @@
+{"title" : "Five", "tags" : ["javascript", "java"]}

data/test/integration/facets_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Slingshot
+
+  class FacetsIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Facets" do
+
+      should "return results scoped to current query" do
+        q = 'tags:ruby'
+        s = Slingshot.search('articles-test') do
+          query { string q }
+          facet 'tags' do
+            terms :tags
+          end
+        end
+        facets = s.results.facets['tags']['terms']
+        assert_equal 2, facets.count
+        assert_equal 'ruby', facets.first['term']
+        assert_equal 2,      facets.first['count']
+      end
+
+      should "allow to specify global facets and query-scoped facets" do
+        q = 'tags:ruby'
+        s = Slingshot.search('articles-test') do
+          query { string q }
+          facet 'scoped-tags' do
+            terms :tags
+          end
+          facet 'global-tags', :global => true do
+            terms :tags
+          end
+        end
+
+        scoped_facets = s.results.facets['scoped-tags']['terms']
+        global_facets = s.results.facets['global-tags']['terms']
+
+        assert_equal 2, scoped_facets.count
+        assert_equal 5, global_facets.count
+      end
+
+    end
+
+  end
+
+end

data/test/integration/query_string_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Slingshot
+
+  class QueryStringIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Searching for query string" do
+
+      should "find article by title" do
+        q = 'title:one'
+        assert_equal 1, search(q).results.count
+        assert_equal 'One', search(q).results.first['_source']['title']
+      end
+
+      should "find articles by title with boosting" do
+        q = 'title:one^100 OR title:two'
+        assert_equal 2, search(q).results.count
+        assert_equal 'One', search(q).results.first['_source']['title']
+      end
+
+      should "find articles by tags" do
+        q = 'tags:ruby AND tags:python'
+        assert_equal 1, search(q).results.count
+        assert_equal 'Two', search(q).results.first['_source']['title']
+      end
+
+      should "find any article with tags" do
+        q = 'tags:ruby OR tags:python OR tags:java'
+        assert_equal 4, search(q).results.count
+      end
+
+    end
+
+    private
+
+    def search(q)
+      Slingshot.search('articles-test') { query { string q } }
+    end
+
+  end
+
+end

data/test/integration/sort_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Slingshot
+
+  class SortIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Sort" do
+
+      should "sort by title" do
+        q = '*'
+        s = Slingshot.search('articles-test') do
+          query { string q }
+          sort  { title }
+        end
+
+        assert_equal 5, s.results.count
+        assert_equal 'Five', s.results.first['_source']['title']
+      end
+
+      should "sort by title, descending" do
+        q = '*'
+        s = Slingshot.search('articles-test') do
+          query { string q }
+          sort  { title :desc }
+        end
+
+        assert_equal 5, s.results.count
+        assert_equal 'Two', s.results.first['_source']['title']
+      end
+
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'turn' unless ENV["TM_FILEPATH"]
+require 'pathname'
+
+require 'slingshot'
+
+class Test::Unit::TestCase
+
+  def fixtures_path
+    Pathname( File.expand_path( 'fixtures', File.dirname(__FILE__) ) )
+  end
+
+  def fixture_file(path)
+    File.read File.expand_path( path, fixtures_path )
+  end
+
+end
+
+module Test::Integration
+  URL = "http://localhost:9200"
+
+  def setup
+    begin
+      ::RestClient.get URL
+    rescue Errno::ECONNREFUSED
+      abort "\n\n#{'-'*87}\n[ABORTED] You have to run ElasticSearch on #{URL} for integration tests\n#{'-'*87}\n\n"
+    end
+
+    ::RestClient.delete "#{URL}/articles-test"     rescue nil
+    ::RestClient.post   "#{URL}/articles-test", ''
+    fixtures_path.join('articles').entries.each do |f|
+      filename = f.to_s
+      next if filename =~ /^\./
+      ::RestClient.put "#{URL}/articles-test/article/#{File.basename(filename, '.*')}",
+                       fixtures_path.join('articles').join(f).read
+    end
+    ::RestClient.post "#{URL}/articles-test/_refresh", ''
+  end
+
+  def teardown
+    ::RestClient.delete "#{URL}/articles-test"  rescue nil
+  end
+end

data/test/unit/client_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Slingshot
+
+  class ClientTest < Test::Unit::TestCase
+
+    context "Base" do
+      setup { @http ||= Client::Base.new }
+
+      should "have abstract methods" do
+        assert_raise(ArgumentError) { @http.post               }
+        assert_raise(ArgumentError) { @http.post 'URL'         }
+        assert_raise(NoMethodError) { @http.post 'URL', 'DATA' }
+
+        assert_raise(ArgumentError) { @http.delete       }
+        assert_raise(NoMethodError) { @http.delete 'URL' }
+      end
+    end
+
+    context "RestClient" do
+
+      should "be default" do
+        assert_equal Client::RestClient, Configuration.client
+      end
+
+      should "respond to post and delete" do
+        assert_respond_to Client::RestClient, :post
+        assert_respond_to Client::RestClient, :delete
+      end
+      
+    end
+
+  end
+
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Slingshot
+
+  class ConfigurationTest < Test::Unit::TestCase
+
+    context "Configuration" do
+      setup do
+        Configuration.instance_variable_set(:@url,    nil)
+        Configuration.instance_variable_set(:@client, nil)
+      end
+
+      should "return default URL" do
+        assert_equal 'http://localhost:9200', Configuration.url
+      end
+
+      should "allow setting and retrieving the URL" do
+        assert_nothing_raised { Configuration.url 'http://example.com' }
+        assert_equal 'http://example.com', Configuration.url
+      end
+
+      should "return default client" do
+        assert_equal Client::RestClient, Configuration.client
+      end
+
+      should "allow setting and retrieving the client" do
+        assert_nothing_raised { Configuration.client Client::Base }
+        assert_equal Client::Base, Configuration.client
+      end
+    end
+
+  end
+
+end

data/test/unit/index_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module Slingshot
+
+  class IndexTest < Test::Unit::TestCase
+
+    context "Index" do
+
+      setup do
+        @index = Slingshot::Index.new 'dummy'
+      end
+
+      should "create new index" do
+        Configuration.client.expects(:post).returns('{"ok":true,"acknowledged":true}')
+        assert @index.create
+      end
+
+      should "not raise exception and just return false when trying to create existing index" do
+        Configuration.client.expects(:post).raises(RestClient::BadRequest)
+        assert_nothing_raised { assert ! @index.create }
+      end
+
+      should "delete index" do
+        Configuration.client.expects(:delete).returns('{"ok":true,"acknowledged":true}')
+        assert @index.delete
+      end
+
+      should "not raise exception and just return false when deleting non-existing index" do
+        Configuration.client.expects(:delete).returns('{"error":"[articles] missing"}')
+        assert_nothing_raised { assert ! @index.delete }
+        Configuration.client.expects(:delete).raises(RestClient::BadRequest)
+        assert_nothing_raised { assert ! @index.delete }
+      end
+
+      should "refresh the index" do
+        Configuration.client.expects(:post).returns('{"ok":true,"_shards":{}}')
+        assert_nothing_raised { assert @index.refresh }
+      end
+
+      context "when storing" do
+
+        should "properly set type from args" do
+          Configuration.client.expects(:post).with("#{Configuration.url}/dummy/article/", '{"title":"Test"}').returns('{"ok":true,"_id":"test"}').twice
+          @index.store 'article', :title => 'Test'
+          @index.store :article,  :title => 'Test'
+        end
+
+        should "set default type" do
+          Configuration.client.expects(:post).with("#{Configuration.url}/dummy/document/", '{"title":"Test"}').returns('{"ok":true,"_id":"test"}')
+          @index.store :title => 'Test'
+        end
+
+        should "call #to_indexed_json on non-String documents" do
+          document = { :title => 'Test' }
+          Configuration.client.expects(:post).returns('{"ok":true,"_id":"test"}')
+          document.expects(:to_indexed_json)
+          @index.store document
+        end
+
+        should "raise error when storing neither String nor object with #to_indexed_json method" do
+          class MyDocument;end; document = MyDocument.new
+          assert_raise(ArgumentError) { @index.store document }
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/results_collection_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Slingshot
+
+  class ResultsCollectionTest < Test::Unit::TestCase
+
+    context "Collection" do
+      setup do
+        @default_response = { 'hits' => { 'hits' => [1, 2, 3] } }
+      end
+
+      should "be iterable" do
+        assert_respond_to Results::Collection.new(@default_response), :each
+        assert_nothing_raised do
+          Results::Collection.new(@default_response).each { |item| item + 1 }
+          Results::Collection.new(@default_response).map { |item| item + 1 }
+        end
+      end
+
+      should "be initialized with parsed json" do
+        assert_nothing_raised do
+          collection = Results::Collection.new( @default_response )
+          assert_equal [1,2,3], collection.results
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_facet_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Slingshot::Search
+
+  class FacetTest < Test::Unit::TestCase
+
+    context "Facet" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Sort.new, :to_json
+      end
+
+      context "generally" do
+
+        should "encode facets with defaults for current query" do
+          assert_equal( { :foo => { :terms => {:field=>'bar'} } }.to_json, Facet.new('foo').terms(:bar).to_json )
+        end
+
+        should "encode facets as global" do
+          assert_equal( { :foo => { :terms => {:field=>'bar'}, :global => true } }.to_json,
+                        Facet.new('foo', :global => true).terms(:bar).to_json )
+        end
+
+        should "encode facet options" do
+          assert_equal( { :foo => { :terms => {:field=>'bar'}, :size => 5 } }.to_json,
+                        Facet.new('foo', :size => 5).terms(:bar).to_json )
+          assert_equal( { :foo => { :terms => {:field=>'bar'}, :size => 5 } }.to_json,
+                        Facet.new('foo').terms(:bar, :size => 5).to_json )
+        end
+
+        should "encode facets when passed as a block" do
+          f = Facet.new('foo') do
+            terms :bar
+          end
+          assert_equal( { :foo => { :terms => {:field=>'bar'} } }.to_json, f.to_json )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_query_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Slingshot::Search
+
+  class QueryTest < Test::Unit::TestCase
+
+    context "Query" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Query.new, :to_json
+      end
+
+      should "allow search for single term" do
+        assert_equal( { :term => { :foo => 'bar' } }, Query.new.term(:foo, 'bar') )
+      end
+
+      should "allow search for multiple terms" do
+        assert_equal( { :terms => { :foo => ['bar', 'baz'] } }, Query.new.terms(:foo, ['bar', 'baz']) )
+      end
+
+      should "allow set minimum match when searching for multiple terms" do
+        assert_equal( { :terms => { :foo => ['bar', 'baz'], :minimum_match => 2 } },
+                      Query.new.terms(:foo, ['bar', 'baz'], :minimum_match => 2) )
+      end
+
+      should "allow search with a query string" do
+        assert_equal( { :query_string => { :query => 'title:foo' } },
+                      Query.new.string('title:foo') )
+      end
+
+      should "allow set default field when searching with a query string" do
+        assert_equal( { :query_string => { :query => 'foo', :default_field => 'title' } },
+                      Query.new.string('foo', :default_field => 'title') )
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_sort_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Slingshot::Search
+
+  class SortTest < Test::Unit::TestCase
+
+    context "Sort" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Sort.new, :to_json
+      end
+
+      should "encode simple strings" do
+        assert_equal [:foo].to_json, Sort.new.foo.to_json
+      end
+
+      should "encode method arguments" do
+        assert_equal [:foo => 'desc'].to_json, Sort.new.foo('desc').to_json
+      end
+
+      should "encode hash" do
+        assert_equal [ :foo => { :reverse => true } ].to_json, Sort.new.foo(:reverse => true).to_json
+      end
+
+      should "encode multiple sort fields" do
+        assert_equal [:foo, :bar].to_json, Sort.new.foo.bar.to_json
+      end
+
+      should "encode fields when passed as a block to constructor" do
+        s = Sort.new do
+          foo
+          bar 'desc'
+          _score
+        end
+        assert_equal [ :foo, {:bar => 'desc'}, :_score ].to_json, s.to_json
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+module Slingshot
+
+  class SearchTest < Test::Unit::TestCase
+
+    context "Search" do
+
+      should "be initialized with index/indices" do
+        assert_raise(ArgumentError) { Search::Search.new }
+      end
+
+      should "have the query method" do
+        assert_respond_to Search::Search.new('index'), :query
+      end
+
+      should "store indices as an array" do
+        s = Search::Search.new('index1') do;end
+        assert_equal ['index1'], s.indices
+
+        s = Search::Search.new('index1', 'index2') do;end
+        assert_equal ['index1', 'index2'], s.indices
+      end
+
+      should "return curl snippet for debugging" do
+        s = Search::Search.new('index') do
+          query { string 'title:foo' }
+        end
+        assert_equal %q|curl -X POST "http://localhost:9200/index/_search?pretty=true" -d | +
+                     %q|'{"query":{"query_string":{"query":"title:foo"}}}'|,
+                     s.to_curl
+      end
+
+      should "allow chaining" do
+        assert_nothing_raised do
+          Search::Search.new('index').query { }.sort { title 'desc' }.size(5).sort { name 'asc' }.from(1)
+        end
+      end
+
+      should "perform the search" do
+        Configuration.client.expects(:post).returns('{"hits":[]}')
+        Results::Collection.expects(:new).returns([])
+        s = Search::Search.new('index')
+        s.perform
+        assert_not_nil s.results
+        assert_not_nil s.response
+      end
+
+      context "sort" do
+
+        should "allow sorting by multiple fields" do
+          s = Search::Search.new('index') do
+            sort do
+              title 'desc'
+              _score
+            end
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal [{'title' => 'desc'}, '_score'], hash['sort']
+        end
+        
+      end
+
+      context "facets" do
+
+        should "allow searching for facets" do
+          s = Search::Search.new('index') do
+            facet('foo1') { terms :bar, :global => true }
+            facet('foo2', :global => true) { terms :bar }
+            facet('foo3') { terms :baz }
+          end
+          assert_equal 3, s.facets.keys.size
+          assert_not_nil s.facets['foo1']
+          assert_not_nil s.facets['foo2']
+          assert_not_nil s.facets['foo3']
+        end
+
+      end
+
+      context "with from/size" do
+
+        should "set the values in request" do
+          s = Search::Search.new('index') do
+            size 5
+            from 3
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal 5, hash['size']
+          assert_equal 3, hash['from']
+        end
+
+        should "set the fields limit in request" do
+          s = Search::Search.new('index') do
+            fields :title
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal 'title', hash['fields']
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/slingshot_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Slingshot
+
+  class SlingshotTest < Test::Unit::TestCase
+
+    context "Slingshot" do
+
+      should "have the DSL methods available" do
+        assert_respond_to Slingshot, :search
+        assert_respond_to Slingshot, :index
+      end
+    end
+
+  end
+
+end