ssickles-tire 0.4.2

data/test/unit/active_model_lint_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Tire
+  module Model
+
+    class ActiveModelLintTest < Test::Unit::TestCase
+
+      include ActiveModel::Lint::Tests
+
+      def setup
+        @model = PersistentArticle.new :title => 'Test'
+      end
+
+    end
+
+  end
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Tire
+
+  class ConfigurationTest < Test::Unit::TestCase
+
+    def teardown
+      Tire::Configuration.reset
+      ENV['ELASTICSEARCH_URL'] = nil
+    end
+
+    context "Configuration" do
+      setup do
+        Configuration.instance_variable_set(:@url,    nil)
+        Configuration.instance_variable_set(:@client, nil)
+      end
+
+      teardown do
+        Configuration.reset
+      end
+
+      should "return default URL" do
+        assert_equal 'http://localhost:9200', Configuration.url
+      end
+
+      should "use environment variable, if present" do
+        ENV['ELASTICSEARCH_URL'] = 'http://es.example.com'
+        assert_equal 'http://es.example.com', 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 "strip trailing slash from the URL" do
+        assert_nothing_raised { Configuration.url 'http://slash.com:9200/' }
+        assert_equal 'http://slash.com:9200', Configuration.url
+      end
+
+      should "return default client" do
+        assert_equal HTTP::Client::RestClient, Configuration.client
+      end
+
+      should "return nil as logger by default" do
+        assert_nil Configuration.logger
+      end
+
+      should "return set and return logger" do
+        Configuration.logger STDERR
+        assert_not_nil Configuration.logger
+        assert_instance_of Tire::Logger, Configuration.logger
+      end
+
+      should "allow to reset the configuration for specific property" do
+        Configuration.url 'http://example.com'
+        assert_equal      'http://example.com', Configuration.url
+        Configuration.reset :url
+        assert_equal      'http://localhost:9200', Configuration.url
+      end
+
+      should "allow to reset the configuration for all properties" do
+        Configuration.url     'http://example.com'
+        Configuration.wrapper Hash
+        assert_equal          'http://example.com', Configuration.url
+        Configuration.reset
+        assert_equal          'http://localhost:9200', Configuration.url
+        assert_equal          HTTP::Client::RestClient, Configuration.client
+      end
+    end
+
+  end
+
+end

data/test/unit/http_client_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+require 'tire/http/clients/curb'
+
+module Tire
+  module HTTP
+
+    class ClientTest < Test::Unit::TestCase
+
+      context "RestClient" do
+
+        should "be default" do
+          assert_equal Client::RestClient, Configuration.client
+        end
+
+        should "respond to HTTP methods" do
+          assert_respond_to Client::RestClient, :get
+          assert_respond_to Client::RestClient, :post
+          assert_respond_to Client::RestClient, :put
+          assert_respond_to Client::RestClient, :delete
+          assert_respond_to Client::RestClient, :head
+        end
+
+        should "not rescue generic exceptions" do
+          Client::RestClient.expects(:get).raises(RuntimeError, "Something bad happened in YOUR code")
+
+          assert_raise(RuntimeError) do
+            Client::RestClient.get 'http://example.com'
+          end
+        end
+
+        should "not rescue ServerBrokeConnection errors" do
+          Client::RestClient.expects(:get).raises(RestClient::ServerBrokeConnection)
+
+          assert_raise(RestClient::ServerBrokeConnection) do
+            Client::RestClient.get 'http://example.com'
+          end
+        end
+
+        should "not rescue RequestTimeout errors" do
+          Client::RestClient.expects(:get).raises(RestClient::RequestTimeout)
+
+          assert_raise(RestClient::RequestTimeout) do
+            Client::RestClient.get 'http://example.com'
+          end
+        end
+
+      end
+
+      context "Curb" do
+        setup do
+          Configuration.client Client::Curb
+        end
+
+        teardown do
+          Configuration.client Client::RestClient
+        end
+
+        should "use POST method if request body passed" do
+          ::Curl::Easy.any_instance.expects(:http_post)
+
+          response = Configuration.client.get "http://localhost:3000", '{ "query_string" : { "query" : "apple" }}'
+        end
+
+        should "use GET method if request body is nil" do
+          ::Curl::Easy.any_instance.expects(:http_get)
+
+          response = Configuration.client.get "http://localhost:9200/articles/article/1"
+        end
+
+      end
+
+
+    end
+  end
+
+end

data/test/unit/http_response_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Tire
+  module HTTP
+
+    class ResponseTest < Test::Unit::TestCase
+
+      context "Response" do
+
+        should "take response body, code and headers on initialization" do
+          response = Response.new "http response body",
+                                  200,
+                                  :content_length => 20,
+                                  :content_encoding => 'gzip'
+
+          assert_equal "http response body", response.body
+          assert_equal 200, response.code
+        end
+
+        should "not require headers" do
+          assert_nothing_raised do
+            Response.new "Forbidden", 403
+          end
+        end
+
+        should "return success" do
+          responses = []
+          responses << Response.new('OK', 200)
+          responses << Response.new('Redirect', 302)
+
+          responses.each { |response| assert response.success? }
+
+          assert ! Response.new('NotFound', 404).success?
+        end
+
+        should "return failure" do
+          assert Response.new('NotFound', 404).failure?
+        end
+
+        should "return string representation" do
+          assert_equal "200 : Hello", Response.new('Hello', 200).to_s
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/index_alias_test.rb

@@ -0,0 +1,275 @@
+require 'test_helper'
+
+module Tire
+
+  class IndexAliasTest < Test::Unit::TestCase
+
+    context "Index Alias" do
+      teardown { Configuration.reset }
+
+      context "initialization" do
+
+        should "have a name and defaults" do
+          @alias = Alias.new :name => 'dummy'
+          assert_equal 'dummy', @alias.name
+          assert @alias.indices.empty?
+        end
+
+        should "have indices" do
+          @alias = Alias.new :indices => ['index_A', 'index_B']
+          assert_equal ['index_A', 'index_B'], @alias.indices.to_a
+        end
+
+        should "have single index" do
+          @alias = Alias.new :index => 'index_A'
+          assert_equal ['index_A'], @alias.indices.to_a
+          assert_equal ['index_A'], @alias.index.to_a
+        end
+
+        should "have properties" do
+          @alias = Alias.new :routing => '1'
+          assert_equal '1', @alias.routing
+        end
+
+        should "allow to add indices in a block" do
+          @alias = Alias.new do
+            index 'index_A'
+            index 'index_B'
+          end
+          assert_equal ['index_A', 'index_B'], @alias.indices.to_a
+
+          @alias = Alias.new do |a|
+            a.index 'index_A'
+            a.index 'index_B'
+          end
+          assert_equal ['index_A', 'index_B'], @alias.indices.to_a
+        end
+
+        should "allow to define filter with DSL" do
+          @alias = Alias.new do
+            filter :terms, :username => 'mary'
+          end
+
+          assert_equal( { :terms => { :username => 'mary' } }, @alias.filter )
+        end
+
+        should "allow chaining" do
+          @alias = Alias.new.name('my_alias').index('index_1').index('index_2').routing('1')
+
+          assert_equal 'my_alias',             @alias.name
+          assert_equal ['index_1', 'index_2'], @alias.indices.to_a
+          assert_equal '1',                    @alias.routing
+        end
+
+        should "be converted to JSON" do
+          @alias = Alias.new :name    => 'index_anne',
+                             :indices => ['index_2012_04', 'index_2012_03', 'index_2012_02'],
+                             :routing => 1,
+                             :filter  => { :terms => { :user => 'anne' } }
+          # p @alias.to_json
+          result = MultiJson.decode @alias.to_json
+
+          assert_equal 3, result['actions'].size
+          assert_equal 'index_2012_04', result['actions'][0]['add']['index']
+        end
+
+        should "be converted to string" do
+          @alias = Alias.new :name => 'my_alias'
+          assert_equal 'my_alias', @alias.to_s
+        end
+
+      end
+
+      context "updating" do
+        setup do
+          Configuration.client.expects(:get).
+                               returns( mock_response(                               %q|{"index_A":{"aliases":{}},"index_B":{"aliases":{"alias_john":{"filter":{"term":{"user":"john"}}},"alias_martha":{"filter":{"term":{"user":"martha"}}}}},"mongoid_articles":{"aliases":{}},"index_C":{"aliases":{"alias_martha":{"filter":{"term":{"user":"martha"}}}}}}|), 200 ).at_least_once
+        end
+
+        should "add indices to alias" do
+          Configuration.client.expects(:post).with do |url, json|
+            # puts json
+            MultiJson.decode(json)['actions'].any? do |a|
+              a['add']['index'] == 'index_A' &&
+              a['add']['alias'] == 'alias_martha'
+              end
+          end.returns(mock_response('{}'), 200)
+          
+          a = Alias.find('alias_martha')
+          a.indices.push 'index_A'
+          a.save
+        end
+
+        should "remove indices from alias" do
+          Configuration.client.expects(:post).with do |url, json|
+            # puts json
+            MultiJson.decode(json)['actions'].any? do |a|
+                a['remove'] &&
+                a['remove']['index'] == 'index_A' &&
+                a['remove']['alias'] == 'alias_martha'
+              end
+          end.returns(mock_response('{}'), 200)
+          
+          a = Alias.find('alias_martha')
+          a.indices.delete 'index_A'
+          a.save
+        end
+
+        should "change alias configuration" do
+          Configuration.client.expects(:post).with do |url, json|
+            # puts json
+            MultiJson.decode(json)['actions'].all? { |a| a['add']['routing'] == 'martha' }
+          end.returns(mock_response('{}'), 200)
+          
+          a = Alias.find('alias_martha')
+          a.routing('martha')
+          a.save
+        end
+
+      end
+
+      context "saving" do
+
+        should "send data to ElasticSearch" do
+          Configuration.client.expects(:post).with do |url, json|
+            url  == "#{Configuration.url}/_aliases" &&
+            json =~ /"index":"index_2012_05"/ &&
+            json =~ /"alias":"index_current"/
+          end.returns(mock_response('{}'), 200)
+
+          @alias = Alias.new :name => 'index_current', :index => 'index_2012_05'
+          @alias.save
+        end
+
+        should "log request" do
+          Tire.configure { logger '/dev/null' }
+
+          Configuration.client.expects(:post)
+          Configuration.logger.expects(:log_request)
+          Alias.new( :name => 'index_current', :index => 'index_2012_05' ).save
+        end
+
+      end
+
+      context "finding" do
+        setup do
+          Configuration.client.expects(:get).with do |url, json|
+              url  == "#{Configuration.url}/_aliases"
+            end.returns( mock_response(                               %q|{"index_A":{"aliases":{}},"index_B":{"aliases":{"alias_john":{"filter":{"term":{"user":"john"}}},"alias_martha":{"filter":{"term":{"user":"martha"}}}}},"index_C":{"aliases":{"alias_martha":{"filter":{"term":{"user":"martha"}}}}}}|), 200 )
+        end
+
+        should "find all aliases" do
+          aliases = Alias.all
+          # p aliases
+          assert_equal 2, aliases.size
+          assert_equal ['index_B', 'index_C'], aliases.select { |a| a.name == 'alias_martha'}.first.indices.to_a.sort
+        end
+
+        should "find aliases for a specific index" do
+          Configuration.client.unstub(:get)
+          Configuration.client.expects(:get).with do |url, json|
+              url  == "#{Configuration.url}/index_C/_aliases"
+            end.returns( mock_response(                               %q|{"index_C":{"aliases":{"alias_martha":{"filter":{"term":{"user":"martha"}}}}}}|), 200 )
+
+          aliases = Alias.all('index_C')
+          # p aliases
+          assert_equal 1, aliases.size
+          assert_equal ['index_C'], aliases.last.indices.to_a
+        end
+
+        should "find an alias" do
+          a = Alias.find('alias_martha')
+          assert_instance_of Alias, a
+          assert_equal ['index_B', 'index_C'], a.indices.to_a.sort
+        end
+
+        should "find an alias and configure it with a block" do
+          a = Alias.find('alias_martha') do |a|
+                a.indices.delete 'index_A'
+                a.indices.add    'index_D'
+              end
+
+          assert_equal ['index_B', 'index_C', 'index_D'], a.indices.to_a.sort
+        end
+
+      end
+
+      context "creating" do
+        setup do
+          Configuration.client.expects(:post).with do |url, json|
+            url  == "#{Configuration.url}/_aliases" &&
+            json =~ /"index":"index_2012_05"/ &&
+            json =~ /"alias":"index_current"/
+          end.returns(mock_response('{}'), 200)
+        end
+
+        should "create the alias" do
+          Alias.create :name => 'index_current', :index => 'index_2012_05'
+        end
+
+        should "create the alias with a block" do
+          Alias.create :name => 'index_current' do
+            index 'index_2012_05'
+          end
+        end
+
+      end
+
+    end
+
+    context "IndexCollection" do
+
+      should "be intialized with an array or arguments list" do
+        c1 = Alias::IndexCollection.new ['1', '2', '3']
+        c2 = Alias::IndexCollection.new '1', '2', '3'
+        assert_equal c1.to_a, c2.to_a
+      end
+
+      should "be iterable" do
+        c = Alias::IndexCollection.new '1', '2', '3'
+        assert_respond_to c, :each
+        assert_respond_to c, :size
+        assert_equal [1, 2, 3], c.map(&:to_i)
+      end
+
+      should "allow adding values" do
+        c = Alias::IndexCollection.new '1', '2'
+        c.add '3'
+        assert_equal 3, c.size
+        assert_equal ['1', '2', '3'], c.add_indices
+        assert_equal [],              c.remove_indices
+      end
+
+      should "allow removing values" do
+        c = Alias::IndexCollection.new '1', '2'
+        c.remove '1'
+        assert_equal 1, c.size
+        assert_equal ['2'], c.add_indices
+        assert_equal ['1'], c.remove_indices
+      end
+
+      should "clear everything" do
+        c = Alias::IndexCollection.new '1', '2'
+        c.clear
+        assert_equal 0, c.size
+        assert_equal [], c.add_indices
+        assert_equal ['1', '2'], c.remove_indices
+      end
+
+      should "respond to empty" do
+        c = Alias::IndexCollection.new
+        assert c.empty?, "#{c.inspect} should be empty"
+      end
+
+      should "remove values with a block" do
+        c = Alias::IndexCollection.new '1', '2', '3'
+
+        c.delete_if { |a| a.to_i > 1 }
+        assert_equal 1, c.size
+        assert_equal ['1'],      c.add_indices
+        assert_equal ['2', '3'], c.remove_indices
+      end
+
+    end
+  end
+end