tire-erez 0.5.4

data/test/models/persistent_article_with_defaults.rb

@@ -0,0 +1,12 @@
+class PersistentArticleWithDefaults
+
+  include Tire::Model::Persistence
+
+  property :title
+  property :published_on
+  property :tags,       :default => []
+  property :hidden,     :default => false
+  property :options,    :default => {:switches => []}
+  property :created_at, :default => lambda { Time.now }
+
+end

data/test/models/persistent_article_with_percolation.rb

@@ -0,0 +1,5 @@
+class PersistentArticleWithPercolation
+  include Tire::Model::Persistence
+  property :title
+  percolate!
+end

data/test/models/persistent_articles_with_custom_index_name.rb

@@ -0,0 +1,10 @@
+# Example class with Elasticsearch persistence and custom index name
+
+class PersistentArticleWithCustomIndexName
+
+  include Tire::Model::Persistence
+
+  property :title
+
+  index_name 'custom-index-name'
+end

data/test/models/supermodel_article.rb

@@ -0,0 +1,17 @@
+# Example ActiveModel class for testing :searchable mode
+
+require 'rubygems'
+require 'redis/persistence'
+
+class SupermodelArticle
+  include Redis::Persistence
+
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  property :title
+
+  mapping do
+    indexes :title,      :type => 'string', :boost => 15, :analyzer => 'czech'
+  end
+end

data/test/models/validated_model.rb

@@ -0,0 +1,11 @@
+# Example ActiveModel with validations
+
+class ValidatedModel
+
+  include Tire::Model::Persistence
+
+  property :name
+
+  validates_presence_of :name
+
+end

data/test/test_helper.rb

@@ -0,0 +1,118 @@
+ENV['DEBUG'] = 'true'
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pathname'
+require 'test/unit'
+
+JRUBY = defined?(JRUBY_VERSION)
+
+if ENV['JSON_LIBRARY']
+  puts "Using '#{ENV['JSON_LIBRARY']}' JSON library"
+  require ENV['JSON_LIBRARY']
+elsif JRUBY
+  require 'json'
+else
+  require 'yajl/json_gem'
+end
+
+if JRUBY
+  require 'jdbc/sqlite3'
+  require 'active_record'
+  require 'active_record/connection_adapters/jdbcsqlite3_adapter'
+else
+  require 'sqlite3'
+end
+
+require 'shoulda'
+require 'turn/autorun' unless ENV["TM_FILEPATH"] || JRUBY
+require 'mocha/setup'
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'tire'
+if ENV['CURB']
+  puts "Using 'curb' as the HTTP library"
+  require 'tire/http/clients/curb'
+  Tire.configure { client Tire::HTTP::Client::Curb }
+end
+
+# Require basic model files
+#
+require File.dirname(__FILE__) + '/models/active_model_article'
+require File.dirname(__FILE__) + '/models/active_model_article_with_callbacks'
+require File.dirname(__FILE__) + '/models/active_model_article_with_custom_document_type'
+require File.dirname(__FILE__) + '/models/active_model_article_with_custom_index_name'
+require File.dirname(__FILE__) + '/models/active_record_models'
+require File.dirname(__FILE__) + '/models/article'
+require File.dirname(__FILE__) + '/models/persistent_article'
+require File.dirname(__FILE__) + '/models/persistent_article_in_index'
+require File.dirname(__FILE__) + '/models/persistent_article_in_namespace'
+require File.dirname(__FILE__) + '/models/persistent_article_with_casting'
+require File.dirname(__FILE__) + '/models/persistent_article_with_defaults'
+require File.dirname(__FILE__) + '/models/persistent_articles_with_custom_index_name'
+require File.dirname(__FILE__) + '/models/validated_model'
+
+class Test::Unit::TestCase
+
+  def assert_block(message=nil)
+    raise Test::Unit::AssertionFailedError.new(message.to_s) if (! yield)
+    return true
+  end if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+  def mock_response(body, code=200, headers={})
+    Tire::HTTP::Response.new(body, code, headers)
+  end
+
+  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; Object.send(:remove_const, :Rails); rescue; end
+
+    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", ''
+
+    Dir[File.dirname(__FILE__) + '/models/**/*.rb'].each { |m| load m }
+  end
+
+  def teardown
+    %w[
+      articles-test
+      active_record_articles
+      active_model_article_with_custom_as_serializations
+      active_record_class_with_tire_methods
+      mongoid_articles
+      mongoid_class_with_tire_methods
+      supermodel_articles
+      dynamic_index
+      model_with_nested_documents
+      model_with_incorrect_mappings ].each do |index|
+        ::RestClient.delete "#{URL}/#{index}" rescue nil
+    end
+  end
+end

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,84 @@
+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 "set pretty option to true by default" do
+        assert_not_nil Configuration.pretty
+        assert Configuration.pretty, "Should be true, but is: #{Configuration.pretty.inspect}"
+      end
+
+      should "set the pretty option to false" do
+        Configuration.pretty(false)
+        assert ! Configuration.pretty, "Should be falsy, but is: #{Configuration.pretty.inspect}"
+      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/count_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Tire
+  class CountTest < Test::Unit::TestCase
+
+    context "Count" do
+      setup { Configuration.reset }
+
+      should "be initialized with single index" do
+        c = Search::Count.new('index')
+        assert_equal ['index'], c.indices
+        assert_match %r|/index/_count|, c.url
+      end
+
+      should "count all documents by the leaving index empty" do
+        c = Search::Count.new
+        assert c.indices.empty?, "#{c.indices.inspect} should be empty"
+        assert_match %r|localhost:9200/_count|, c.url
+      end
+
+      should "limit count with document type" do
+        c = Search::Count.new('index', :type => 'bar')
+        assert_equal ['bar'], c.types
+        assert_match %r|index/bar/_count|, c.url
+      end
+
+      should "pass URL parameters" do
+        c = Search::Count.new('index', :routing => 123)
+        assert  ! c.params.empty?
+        assert_match %r|routing=123|, c.params
+      end
+
+      should "evaluate the query" do
+        Search::Query.any_instance.expects(:instance_eval)
+
+        c = Search::Count.new('index') { string 'foo' }
+        assert_not_nil c.query
+      end
+
+      should "allow access to the JSON and the response" do
+        Configuration.client.expects(:get).returns(mock_response( '{"count":1}', 200 ))
+        c = Search::Count.new('index')
+        c.perform
+        assert_equal 1, c.json['count']
+        assert_equal 200, c.response.code
+      end
+
+      should "return curl snippet for debugging" do
+        c = Search::Count.new('index') { term :title, 'foo' }
+        assert_match %r|curl \-X GET 'http://localhost:9200/index/_count\?pretty' -d |, c.to_curl
+        assert_match %r|"term"\s*:\s*"foo"|, c.to_curl
+      end
+
+      should "log the request when logger is set" do
+        Configuration.logger STDERR
+
+        Configuration.client.expects(:get).returns(mock_response( '{"count":1}', 200 ))
+        Configuration.logger.expects(:log_request).returns(true)
+        Configuration.logger.expects(:log_response).returns(true)
+
+        Search::Count.new('index').value
+      end
+
+    end
+
+  end
+end

data/test/unit/http_client_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+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
+
+      if defined?(Curl)
+        require 'tire/http/clients/curb'
+
+        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
+
+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