tire 0.4.3 → 0.5.0

data/test/unit/index_test.rb

@@ -126,21 +126,26 @@ module Tire
           assert_equal 1, response['tokens'].size
         end
 
-        should "properly encode parameters" do
+        should "properly encode parameters for analyzer" do
           Configuration.client.expects(:get).with do |url, payload|
-                                url == "#{@index.url}/_analyze?analyzer=whitespace&pretty=true"
+                                assert_equal "#{@index.url}/_analyze?analyzer=whitespace&pretty=true", url
                                end.returns(mock_response(@mock_analyze_response))
 
           @index.analyze("foo bar", :analyzer => 'whitespace')
 
+        end
+
+        should "properly encode parameters for field" do
           Configuration.client.expects(:get).with do |url, payload|
-                                url == "#{@index.url}/_analyze?field=title&pretty=true"
+                                assert_equal "#{@index.url}/_analyze?field=title&pretty=true", url
                                end.returns(mock_response(@mock_analyze_response))
 
           @index.analyze("foo bar", :field => 'title')
+        end
 
+        should "properly encode format parameter" do
           Configuration.client.expects(:get).with do |url, payload|
-                                url == "#{@index.url}/_analyze?analyzer=keyword&format=text&pretty=true"
+                                assert_equal "#{@index.url}/_analyze?analyzer=keyword&format=text&pretty=true", url
                                end.returns(mock_response(@mock_analyze_response))
 
           @index.analyze("foo bar", :analyzer => 'keyword', :format => 'text')
@@ -210,21 +215,21 @@ module Tire
 
         should "set type from Hash :type property" do
           Configuration.client.expects(:post).with do |url,document|
-            url == "#{@index.url}/article/"
+            assert_equal "#{@index.url}/article/", url
           end.returns(mock_response('{"ok":true,"_id":"test"}'))
           @index.store :type => 'article', :title => 'Test'
         end
 
         should "set type from Hash :_type property" do
           Configuration.client.expects(:post).with do |url,document|
-            url == "#{@index.url}/article/"
+            assert_equal "#{@index.url}/article/", url
           end.returns(mock_response('{"ok":true,"_id":"test"}'))
           @index.store :_type => 'article', :title => 'Test'
         end
 
         should "set type from Object _type method" do
           Configuration.client.expects(:post).with do |url,document|
-            url == "#{@index.url}/article/"
+            assert_equal "#{@index.url}/article/", url
           end.returns(mock_response('{"ok":true,"_id":"test"}'))
 
           article = Class.new do
@@ -236,7 +241,7 @@ module Tire
 
         should "set type from Object type method" do
           Configuration.client.expects(:post).with do |url,document|
-            url == "#{@index.url}/article/"
+            assert_equal "#{@index.url}/article/", url
           end.returns(mock_response('{"ok":true,"_id":"test"}'))
 
           article = Class.new do
@@ -248,7 +253,7 @@ module Tire
 
         should "properly encode namespaced document types" do
           Configuration.client.expects(:post).with do |url,document|
-            url == "#{@index.url}/my_namespace%2Fmy_model/"
+            assert_equal "#{@index.url}/my_namespace%2Fmy_model/", url
           end.returns(mock_response('{"ok":true,"_id":"123"}'))
 
           module MyNamespace
@@ -363,6 +368,29 @@ module Tire
           article = @index.retrieve 'my_namespace/my_model', 'id-1'
         end
 
+        should "allow to set routing" do
+          Configuration.client.expects(:get).with("#{@index.url}/article/id-1?routing=foo").
+                                             returns(mock_response('{"_id":"id-1"'))
+          article = @index.retrieve :article, 'id-1', :routing => 'foo'
+        end
+
+        should "allow to set routing and fields" do
+          Configuration.client.expects(:get).with do |url|
+            assert url.include?('routing=foo'), url
+            assert url.include?('fields=name'), url
+          end.returns(mock_response('{"_id":"id-1"'))
+
+          article = @index.retrieve :article, 'id-1', :routing => 'foo', :fields => 'name'
+        end
+
+        should "allow to set preference" do
+          Configuration.client.expects(:get).with do |url|
+            assert url.include?('preference=foo'), url
+          end.returns(mock_response('{"_id":"id-1"'))
+
+          article = @index.retrieve :article, 'id-1', :preference => 'foo'
+        end
+
       end
 
       context "when removing" do
@@ -694,8 +722,9 @@ module Tire
           query = { :query => { :query_string => { :query => 'foo' } } }
           Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
-                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
-                                               payload['query']['query_string']['query'] == 'foo'
+                                               assert_equal "#{Configuration.url}/_percolator/dummy/my-query",
+                                                            url
+                                               assert_equal 'foo', payload['query']['query_string']['query']
                                end.
                                returns(mock_response('{
                                                         "ok" : true,
@@ -711,8 +740,9 @@ module Tire
         should "register percolator query as a block" do
           Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
-                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
-                                               payload['query']['query_string']['query'] == 'foo'
+                                               assert_equal "#{Configuration.url}/_percolator/dummy/my-query",
+                                                            url
+                                               assert_equal 'foo', payload['query']['query_string']['query']
                                end.
                                returns(mock_response('{
                                                         "ok" : true,
@@ -733,9 +763,10 @@ module Tire
 
           Configuration.client.expects(:put).with do |url, payload|
                                                payload = MultiJson.decode(payload)
-                                               url == "#{Configuration.url}/_percolator/dummy/my-query" &&
-                                               payload['query']['query_string']['query'] == 'foo' &&
-                                               payload['tags'] == ['alert']
+                                               assert_equal "#{Configuration.url}/_percolator/dummy/my-query",
+                                                            url
+                                               assert_equal 'foo',     payload['query']['query_string']['query']
+                                               assert_equal ['alert'], payload['tags']
                                            end.
                                returns(mock_response('{
                                                         "ok" : true,
@@ -757,8 +788,8 @@ module Tire
         should "percolate document against all registered queries" do
           Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
-                                               url == "#{@index.url}/document/_percolate" &&
-                                               payload['doc']['title'] == 'Test'
+                                               assert_equal "#{@index.url}/document/_percolate", url
+                                               assert_equal 'Test', payload['doc']['title']
                                               end.
                                returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
@@ -769,8 +800,8 @@ module Tire
         should "percolate a typed document against all registered queries" do
           Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
-                                               url == "#{@index.url}/article/_percolate" &&
-                                               payload['doc']['title'] == 'Test'
+                                               assert_equal "#{@index.url}/article/_percolate", url
+                                               assert_equal 'Test', payload['doc']['title']
                                               end.
                                returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
@@ -782,9 +813,9 @@ module Tire
           Configuration.client.expects(:get).with do |url,payload|
                                                payload = MultiJson.decode(payload)
                                                # p [url, payload]
-                                               url == "#{@index.url}/document/_percolate" &&
-                                               payload['doc']['title']                   == 'Test' &&
-                                               payload['query']['query_string']['query'] == 'tag:alerts'
+                                               assert_equal "#{@index.url}/document/_percolate", url
+                                               assert_equal 'Test', payload['doc']['title']
+                                               assert_equal 'tag:alerts', payload['query']['query_string']['query']
                                               end.
                                returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
 
@@ -797,8 +828,7 @@ module Tire
           should "percolate document against all registered queries" do
             Configuration.client.expects(:post).
                                  with do |url, payload|
-                                   url     == "#{@index.url}/article/?percolate=*" &&
-                                   payload =~ /"title":"Test"/
+                                   assert_equal "#{@index.url}/article/?percolate=%2A", url
                                  end.
                                  returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
             @index.store( {:type => 'article', :title => 'Test'}, {:percolate => true} )
@@ -807,8 +837,7 @@ module Tire
           should "percolate document against specific queries" do
             Configuration.client.expects(:post).
                                  with do |url, payload|
-                                   url     == "#{@index.url}/article/?percolate=tag:alerts" &&
-                                   payload =~ /"title":"Test"/
+                                   assert_equal "#{@index.url}/article/?percolate=tag%3Aalerts", url
                                  end.
                                  returns(mock_response('{"ok":true,"_id":"test","matches":["alerts"]}'))
             response = @index.store( {:type => 'article', :title => 'Test'}, {:percolate => 'tag:alerts'} )
@@ -819,6 +848,19 @@ module Tire
 
       end
 
+      context "when passing parent document ID" do
+
+        should "set the :parent option in the request parameters" do
+          Configuration.client.expects(:post).
+            with do |url, payload|
+              assert_equal "#{Configuration.url}/dummy/document/?parent=1234", url
+            end.
+            returns(mock_response('{"ok":true,"_id":"test"}'))
+
+          @index.store({:title => 'Test'}, {:parent => 1234})
+        end
+      end
+
       context "reindexing" do
         setup do
           @results = {

data/test/unit/model_initialization_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class ModelWithIncorrectMapping
+  extend  ActiveModel::Naming
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  tire do
+    mapping do
+      indexes :title, :type => 'boo'
+    end
+  end
+end
+
+module Tire
+  module Model
+
+    class ModelInitializationTest < Test::Unit::TestCase
+
+      context "Model initialization" do
+
+        should "display a warning when creating the index fails" do
+          STDERR.expects(:puts)
+          result = ModelWithIncorrectMapping.create_elasticsearch_index
+          assert ! result, result.inspect
+        end
+
+      end
+    end
+  end
+end

data/test/unit/model_persistence_test.rb

@@ -24,16 +24,16 @@ module Tire
           setup do
             Model::Search.index_prefix 'prefix'
           end
-          
+
           teardown do
             Model::Search.index_prefix nil
           end
-          
+
           should "have configured prefix in index_name" do
             assert_equal 'prefix_persistent_articles', PersistentArticle.index_name
             assert_equal 'prefix_persistent_articles', PersistentArticle.new(:title => 'Test').index_name
           end
-          
+
         end
 
         should "have document_type" do
@@ -125,8 +125,13 @@ module Tire
           assert_equal ids.size, documents.count
         end
 
-        should "find all documents" do
-          Configuration.client.stubs(:get).returns(mock_response(@find_all.to_json))
+        should "find all documents with correct type" do
+          Configuration.client.expects(:get).
+                               with do |url,payload|
+                                 assert_equal "#{Configuration.url}/persistent_articles/persistent_article/_search", url
+                               end.
+                               times(3).
+                               returns(mock_response(@find_all.to_json))
           documents = PersistentArticle.all
 
           assert_equal 3, documents.count
@@ -134,8 +139,12 @@ module Tire
           assert_equal PersistentArticle.find(:all).map { |e| e.id }, PersistentArticle.all.map { |e| e.id }
         end
 
-        should "find first document" do
-          Configuration.client.expects(:get).returns(mock_response(@find_first.to_json))
+        should "find first document with correct type" do
+          Configuration.client.expects(:get).
+                               with do |url,payload|
+                                 assert_equal "#{Configuration.url}/persistent_articles/persistent_article/_search?size=1", url
+                               end.
+                               returns(mock_response(@find_first.to_json))
           document = PersistentArticle.first
 
           assert_equal 'First', document.attributes['title']
@@ -201,6 +210,11 @@ module Tire
             assert_equal false, article.hidden
           end
 
+          should "evaluate lambdas as default values" do
+            article = PersistentArticleWithDefaults.new
+            assert_equal Time.now.year, article.created_at.year
+          end
+
           should "not affect default value" do
             article = PersistentArticleWithDefaults.new :title => 'Test'
             article.tags << "ruby"

data/test/unit/model_search_test.rb

@@ -19,7 +19,7 @@ module Tire
       context "Model::Search" do
 
         setup do
-          @stub = stub('search') { stubs(:query).returns(self); stubs(:perform).returns(self); stubs(:results).returns([]) }
+          @stub = stub('search') { stubs(:query).returns(self); stubs(:perform).returns(self); stubs(:results).returns([]); stubs(:size).returns(true) }
           Tire::Index.any_instance.stubs(:exists?).returns(false)
         end
 
@@ -39,7 +39,7 @@ module Tire
         should "limit searching in index for documents matching the model 'document_type'" do
           Tire::Search::Search.
             expects(:new).
-            with(ActiveModelArticle.index_name, { :type => ActiveModelArticle.document_type }).
+            with('active_model_articles', { :type => 'active_model_article' }).
             returns(@stub).
             twice
 
@@ -121,6 +121,16 @@ module Tire
           assert_equal 'Article', document.title
         end
 
+        should "not pass the search option as URL parameter" do
+          Configuration.client.
+            expects(:get).with do |url, payload|
+              assert ! url.include?('sort')
+            end.
+            returns( mock_response({ 'hits' => { 'hits' => [] } }.to_json) )
+
+          ActiveModelArticle.search(@q, :sort => 'title:DESC').results
+        end
+
         context "searching with a block" do
           setup do
             Tire::Search::Search.any_instance.expects(:perform).returns(@stub)
@@ -191,14 +201,14 @@ module Tire
           should "allow to specify sort direction" do
             Tire::Search::Sort.any_instance.expects(:by).with('title', 'DESC')
 
-            ActiveModelArticle.search @q, :order => 'title DESC'
+            ActiveModelArticle.search @q, :order => 'title:DESC'
           end
 
           should "allow to specify more fields to sort on" do
             Tire::Search::Sort.any_instance.expects(:by).with('title', 'DESC')
             Tire::Search::Sort.any_instance.expects(:by).with('author.name', nil)
 
-            ActiveModelArticle.search @q, :order => ['title DESC', 'author.name']
+            ActiveModelArticle.search @q, :order => ['title:DESC', 'author.name']
           end
 
           should "allow to specify number of results per page" do
@@ -237,6 +247,25 @@ module Tire
 
         end
 
+        context "multi search" do
+
+          should "perform search request within corresponding index and type" do
+            Tire::Search::Multi::Search.
+              expects(:new).
+              with do |index, options, block|
+                assert_equal 'active_model_articles', index
+                assert_equal 'active_model_article',  options[:type]
+              end.
+              returns( mock(:results => []) )
+
+            ActiveModelArticle.multi_search do
+              search 'foo'
+              search 'xoo'
+            end
+          end
+
+        end
+
         should "not set callback when hooks are missing" do
           @model = ActiveModelArticle.new
           @model.expects(:update_elasticsearch_index).never
@@ -610,7 +639,7 @@ module Tire
 
           end
 
-          should "serialize mapped properties when mapping procs are set" do
+          should "evaluate :as mapping options passed as strings or procs" do
             class ::ModelWithMappingProcs
               extend  ActiveModel::Naming
               extend  ActiveModel::Callbacks
@@ -646,6 +675,28 @@ module Tire
             assert_equal 3, document['three']
           end
 
+          should "index :as mapping options passed as arbitrary objects" do
+            class ::ModelWithMappingOptionAsObject
+              extend  ActiveModel::Naming
+              extend  ActiveModel::Callbacks
+              include ActiveModel::Serialization
+              include Tire::Model::Search
+
+              mapping do
+                indexes :one,   :as => [1, 2, 3]
+              end
+
+              attr_reader :attributes
+
+              def initialize(attributes = {}); @attributes = attributes; end
+            end
+
+            model    = ::ModelWithMappingOptionAsObject.new
+            document = MultiJson.decode(model.to_indexed_json)
+
+            assert_equal [1, 2, 3], document['one']
+          end
+
         end
 
         context "with percolation" do

data/test/unit/multi_search_test.rb

@@ -0,0 +1,304 @@
+require 'test_helper'
+
+module Tire
+  class MultiSearchTest < Test::Unit::TestCase
+
+    context "Multi::Search" do
+      setup { Configuration.reset }
+
+      should "be initialized with index" do
+        @search = Tire::Search::Multi::Search.new 'foo'
+        assert_equal ['foo'], @search.indices
+      end
+
+      context "search definition" do
+        setup do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+        end
+
+        should "be enumerable" do
+          assert_respond_to @search_definitions, :each
+          assert_respond_to @search_definitions, :size
+        end
+
+        should "allow to add definition" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal 1, @search_definitions.size
+        end
+
+        should "return definition" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal 'bar', @search_definitions['foo']['query']
+        end
+
+        should "have names" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal ['foo'], @search_definitions.names
+        end
+      end
+
+      context "search results" do
+        setup do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+          @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new }
+          @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1},
+                                                          {'_id' => 2},
+                                                          {'_id' => 3}] }
+                                }]
+
+          @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+        end
+
+        should "be enumerable" do
+          assert_respond_to @results, :each
+          assert_respond_to @results, :each_pair
+          assert_respond_to @results, :each_with_index
+          assert_respond_to @results, :size
+        end
+
+        should "return named results" do
+          assert_instance_of Tire::Results::Collection, @results['foo']
+          assert_equal 1, @results['foo'].first.id
+        end
+
+        should "return nil for incorrect index" do
+          assert_nil @results['moo']
+          assert_nil @results[999]
+        end
+
+        should "iterate over results" do
+          @results.each do |results|
+            assert_instance_of Tire::Results::Collection, results
+          end
+        end
+
+        should "iterate over named results" do
+          @results.each_pair do |name, results|
+            assert_equal       'foo', name
+            assert_instance_of Tire::Results::Collection, results
+          end
+        end
+
+        should "be serializable to Hash" do
+          assert_instance_of Tire::Results::Collection, @results.to_hash['foo']
+        end
+
+        should "pass search options to collection" do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+          @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new(nil, :foo => 'bar') }
+          @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1}] } }]
+
+          @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+
+          assert_equal 'bar', @results['foo'].options[:foo]
+        end
+
+        context "error responses" do
+          setup do
+            @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+            @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new }
+            @search_definitions << { :name => 'xoo', :search => Tire::Search::Search.new }
+            @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1},
+                                                            {'_id' => 2},
+                                                            {'_id' => 3}] }
+                                   },
+                                   {'error' => 'SearchPhaseExecutionException ...'}
+                                  ]
+
+            @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+          end
+
+          should "return success/failure state" do
+            assert_equal true, @results['foo'].success?
+            assert_equal 3,    @results['foo'].size
+            assert_equal true, @results['xoo'].failure?
+          end
+        end
+      end
+
+      context "URL" do
+
+        should "have no index and type by default" do
+          @search = Tire::Search::Multi::Search.new
+          assert_equal '/_msearch', @search.path
+        end
+
+        should "have an index" do
+          @search = Tire::Search::Multi::Search.new 'foo'
+          assert_equal '/foo/_msearch', @search.path
+        end
+
+        should "have multiple indices" do
+          @search = Tire::Search::Multi::Search.new ['foo', 'bar']
+          assert_equal '/foo,bar/_msearch', @search.path
+        end
+
+        should "have index and type" do
+          @search = Tire::Search::Multi::Search.new 'foo', :type => 'bar'
+          assert_equal '/foo/bar/_msearch', @search.path
+        end
+
+        should "have index and multiple types" do
+          @search = Tire::Search::Multi::Search.new 'foo', :type => ['bar', 'bam']
+          assert_equal '/foo/bar,bam/_msearch', @search.path
+        end
+
+        should "contain host" do
+          @search = Tire::Search::Multi::Search.new
+          assert_equal 'http://localhost:9200/_msearch', @search.url
+        end
+
+      end
+
+      context "URL params" do
+
+        should "be empty when no params passed" do
+          @search = Tire::Search::Multi::Search.new 'foo'
+          assert_equal '', @search.params
+        end
+
+        should "serialize parameters" do
+          @search = Tire::Search::Multi::Search.new 'foo', :search_type => 'count'
+          assert_equal '?search_type=count', @search.params
+        end
+
+      end
+
+      context "search request" do
+        setup do
+          @search = Tire::Search::Multi::Search.new
+        end
+
+        should "have a collection of searches" do
+          @search.search :one
+          assert_instance_of Tire::Search::Multi::SearchDefinitions, @search.searches
+        end
+
+        should "be initialized with name" do
+          @search.search :one
+          assert_instance_of Tire::Search::Search, @search.searches[:one]
+        end
+
+        should "be initialized with options" do
+          @search.search :foo => 'bar'
+          assert_equal 'bar', @search.searches[0].options[:foo]
+        end
+
+        should "be initialized with name and options" do
+          @search.search :one, :foo => 'bar'
+          assert_instance_of Tire::Search::Search, @search.searches[:one]
+          assert_equal 'bar', @search.searches[:one].options[:foo]
+          assert_equal 'bar', @search.searches(:one).options[:foo]
+        end
+
+        should "pass the index name and options to the search object" do
+          @search.search :index => 'foo', :type => 'bar'
+          assert_equal ['foo'], @search.searches[0].indices
+          assert_equal ['bar'], @search.searches[0].types
+          assert_equal ['foo'], @search.searches(0).indices
+        end
+
+        should "pass options to Search object" do
+          @search.search :search_type => 'count'
+          assert_equal 'count', @search.searches[0].options[:search_type]
+        end
+
+      end
+
+      context "payload" do
+
+        should "serialize search payload header and body as Array" do
+          @search = Tire::Search::Multi::Search.new do
+            search :index => 'foo' do
+              query { all }
+              size 100
+            end
+          end
+
+          assert_equal 1, @search.searches.size
+          assert_equal 2, @search.to_array.size
+
+          assert_equal( 'foo', @search.to_array[0][:index] )
+          assert_equal( {:match_all => {}}, @search.to_array[1][:query] )
+          assert_equal( 100,   @search.to_array[1][:size] )
+        end
+
+        should "serialize search payload header and body for multiple searches" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') { query { all } }
+            search(:index => 'ooo') { query { term :foo, 'bar' } }
+          end
+
+          assert_equal 2, @search.searches.size
+          assert_equal 4, @search.to_array.size
+
+          assert_equal 'foo', @search.to_array[0][:index]
+          assert_equal 'ooo', @search.to_array[2][:index]
+          assert_equal 'match_all', @search.to_array[1][:query].keys.first.to_s
+          assert_equal 'term',      @search.to_array[3][:query].keys.first.to_s
+        end
+
+        should "serialize search parameters" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:search_type => 'count') { query { all } }
+          end
+
+          assert_equal 'count', @search.to_array[0][:search_type]
+        end
+
+        should "serialize search payload as a string" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') { query { all } }
+          end
+
+          assert_equal 2, @search.to_payload.split("\n").size
+        end
+
+        should "end with a new line" do
+          @search = Tire::Search::Multi::Search.new { search(:index => 'foo') { query { all } } }
+          assert_match /.*\n$/, @search.to_payload
+        end
+
+        should "leave header empty when no index is passed" do
+          @search = Tire::Search::Multi::Search.new do
+            search() { query { all } }
+          end
+
+          assert_equal( {}, @search.to_array.first )
+        end
+
+      end
+
+      context "perform" do
+        setup do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') do
+              query { all }
+              size 100
+            end
+          end
+          @response = mock_response '{ "responses" : [{"took":1,"hits":{"total":0,"hits":[]}}] }', 200
+        end
+
+        should "perform the request" do
+          Configuration.client.expects(:get).
+            with do |url, payload|
+              assert_equal 'http://localhost:9200/_msearch', url
+              assert       payload.include?('match_all')
+            end.
+            returns(@response)
+          @search.perform
+        end
+
+        should "log the request" do
+          Configuration.client.expects(:get).returns(@response)
+          @search.expects(:logged)
+          @search.perform
+        end
+
+      end
+
+    end
+
+  end
+end