elasticsearch-persistence-queryable 0.1.8

data/lib/rails/instrumentation/railtie.rb

@@ -0,0 +1,31 @@
+module Elasticsearch
+  module Persistence
+    module Instrumentation
+
+      class Railtie < ::Rails::Railtie
+        include ActionView::Helpers::NumberHelper
+        def time_diff(start, finish)
+          begin
+            ((finish.to_time - start.to_time) * 1000).to_s(:rounded, precision: 5, strip_insignificant_zeros: true)
+          rescue
+            number_with_precision((finish.to_time - start.to_time) * 1000, precision: 5, strip_insignificant_zeros: true)
+          end
+        end
+
+        ActiveSupport::Notifications.subscribe 'query.elasticsearch' do |name, start, finish, id, payload|
+          ::Rails.logger.debug(["  #{payload[:name]}".bright, "(#{time_diff(start,finish)}ms)",payload[:query]].join(" ").color(:yellow))
+        end
+
+        ActiveSupport::Notifications.subscribe 'cache.query.elasticsearch' do |name, start, finish, id, payload|
+          ::Rails.logger.debug(["  #{payload[:name]}".bright, "CACHE".color(:mediumpurple).bright ,"(#{time_diff(start,finish)}ms)", payload[:query]].join(" ").color(:yellow))
+        end
+
+        initializer 'elasticsearch_persistence.set_defaults' do
+          config.elasticsearch_cache_store = :redis_store
+          config.elasticsearch_expire_cache_in = 15.minutes
+        end
+
+      end
+    end
+  end
+end

data/lib/rails/instrumentation.rb

@@ -0,0 +1,10 @@
+require 'elasticsearch/rails/instrumentation/railtie'
+
+module Elasticsearch
+  module Persistence
+
+    module Instrumentation
+    end
+  end
+
+end

data/test/integration/model/model_basic_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+require 'elasticsearch/persistence/model'
+
+module Elasticsearch
+  module Persistence
+    class PersistenceModelBasicIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::Person
+        include Elasticsearch::Persistence::Model
+
+        settings index: { number_of_shards: 1 }
+
+        attribute :name, String,
+                  mapping: { fields: {
+                    name: { type: 'string', analyzer: 'snowball' },
+                    raw:  { type: 'string', analyzer: 'keyword' }
+                  } }
+
+        attribute :birthday,   Date
+        attribute :department, String
+        attribute :salary,     Integer
+        attribute :admin,      Boolean, default: false
+
+        validates :name, presence: true
+      end
+
+      context "A basic persistence model" do
+        setup do
+          Person.create_index! force: true
+        end
+
+        should "save the object with custom ID" do
+          person = Person.new id: 1, name: 'Number One'
+          person.save
+
+          document = Person.find(1)
+          assert_not_nil document
+          assert_equal 'Number One', document.name
+        end
+
+        should "create the object with custom ID" do
+          person = Person.create id: 1, name: 'Number One'
+
+          document = Person.find(1)
+          assert_not_nil document
+          assert_equal 'Number One', document.name
+        end
+
+        should "save and find the object" do
+          person = Person.new name: 'John Smith', birthday: Date.parse('1970-01-01')
+          person.save
+
+          assert_not_nil person.id
+          document = Person.find(person.id)
+
+          assert_instance_of Person, document
+          assert_equal 'John Smith', document.name
+          assert_equal 'John Smith', Person.find(person.id).name
+
+          assert_not_nil Elasticsearch::Persistence.client.get index: 'people', type: 'person', id: person.id
+        end
+
+        should "delete the object" do
+          person = Person.create name: 'John Smith', birthday: Date.parse('1970-01-01')
+
+          person.destroy
+          assert person.frozen?
+
+          assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+            Elasticsearch::Persistence.client.get index: 'people', type: 'person', id: person.id
+          end
+        end
+
+        should "update an object attribute" do
+          person = Person.create name: 'John Smith'
+
+          person.update name: 'UPDATED'
+
+          assert_equal 'UPDATED', person.name
+          assert_equal 'UPDATED', Person.find(person.id).name
+        end
+
+        should "increment an object attribute" do
+          person = Person.create name: 'John Smith', salary: 1_000
+
+          person.increment :salary
+
+          assert_equal 1_001, person.salary
+          assert_equal 1_001, Person.find(person.id).salary
+        end
+
+        should "update the object timestamp" do
+          person = Person.create name: 'John Smith'
+          updated_at = person.updated_at
+
+          sleep 1
+          person.touch
+
+          assert person.updated_at > updated_at, [person.updated_at, updated_at].inspect
+
+          found = Person.find(person.id)
+          assert found.updated_at > updated_at, [found.updated_at, updated_at].inspect
+        end
+
+        should "find instances by search" do
+          Person.create name: 'John Smith'
+          Person.create name: 'Mary Smith'
+          Person.gateway.refresh_index!
+
+          people = Person.search query: { match: { name: 'smith' } },
+                                 highlight: { fields: { name: {} } }
+
+          assert_equal 2, people.total
+          assert_equal 2, people.size
+
+          assert people.map_with_hit { |o,h| h._score }.all? { |s| s > 0 }
+
+          assert_not_nil people.first.hit
+          assert_match /smith/i, people.first.hit.highlight['name'].first
+        end
+
+        should "find instances in batches" do
+          50.times { |i| Person.create name: "John #{i+1}" }
+          Person.gateway.refresh_index!
+
+          @batches = 0
+          @results = []
+
+          Person.find_in_batches(_source_include: 'name') do |batch|
+            @batches += 1
+            @results += batch.map(&:name)
+          end
+
+          assert_equal  3, @batches
+          assert_equal 50, @results.size
+          assert_contains @results, 'John 1'
+        end
+
+        should "find each instance" do
+          50.times { |i| Person.create name: "John #{i+1}" }
+          Person.gateway.refresh_index!
+
+          @results = []
+
+          Person.find_each(_source_include: 'name') do |person|
+            @results << person.name
+          end
+
+          assert_equal 50, @results.size
+          assert_contains @results, 'John 1'
+        end
+      end
+
+    end
+  end
+end

data/test/integration/repository/custom_class_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Persistence
+    class RepositoryCustomClassIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::MyNote
+        attr_reader :attributes
+
+        def initialize(attributes={})
+          @attributes = Hashie::Mash.new(attributes)
+        end
+
+        def method_missing(method_name, *arguments, &block)
+          attributes.respond_to?(method_name) ? attributes.__send__(method_name, *arguments, &block) : super
+        end
+
+        def respond_to?(method_name, include_private=false)
+          attributes.respond_to?(method_name) || super
+        end
+
+        def to_hash
+          @attributes
+        end
+      end
+
+      context "A custom repository class" do
+        setup do
+          class ::MyNotesRepository
+            include Elasticsearch::Persistence::Repository
+
+            klass MyNote
+
+            settings number_of_shards: 1 do
+              mapping do
+                indexes :title, analyzer: 'snowball'
+              end
+            end
+
+            create_index!
+
+            def deserialize(document)
+              klass.new document.merge(document['_source'])
+            end
+          end
+
+          @repository = MyNotesRepository.new
+
+          @repository.client.cluster.health wait_for_status: 'yellow'
+        end
+
+        should "save the object under a correct index and type" do
+          @repository.save MyNote.new(id: '1', title: 'Test')
+          result = @repository.find(1)
+
+          assert_instance_of MyNote, result
+          assert_equal 'Test', result.title
+
+          assert_not_nil Elasticsearch::Persistence.client.get index: 'my_notes_repository',
+                                                               type: 'my_note',
+                                                               id: '1'
+        end
+
+        should "delete the object" do
+          note = MyNote.new id: 1, title: 'Test'
+          @repository.save note
+
+          assert_not_nil @repository.find(1)
+
+          @repository.delete(note)
+          assert_raise(Elasticsearch::Persistence::Repository::DocumentNotFound) { @repository.find(1) }
+        end
+
+        should "retrieve the object via a search query" do
+          note = MyNote.new title: 'Testing'
+          @repository.save note, refresh: true
+
+          results = @repository.search query: { match: { title: 'Test' } }
+          assert_equal 'Testing', results.first.title
+        end
+      end
+
+    end
+  end
+end

data/test/integration/repository/customized_class_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Persistence
+    class RepositoryCustomizedClassIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      module ::My
+        class Note
+          attr_reader :attributes
+
+          def initialize(attributes={})
+            @attributes = attributes
+          end
+
+          def to_hash
+            @attributes
+          end
+        end
+      end
+
+      context "A custom repository class" do
+        setup do
+          @repository = Elasticsearch::Persistence::Repository.new do
+            index 'my_notes'
+            type  'my_note'
+            klass My::Note
+
+            settings number_of_shards: 1 do
+              mapping do
+                indexes :title, analyzer: 'snowball'
+              end
+            end
+
+            create_index!
+          end
+
+          @repository.client.cluster.health wait_for_status: 'yellow'
+        end
+
+        should "save the object under a correct index and type" do
+          @repository.save My::Note.new(id: '1', title: 'Test')
+
+          assert_instance_of My::Note, @repository.find(1)
+          assert_not_nil Elasticsearch::Persistence.client.get index: 'my_notes', type: 'my_note', id: '1'
+        end
+
+        should "update the document" do
+          @repository.save Note.new(id: 1, title: 'Test')
+
+          @repository.update 1, doc: { title: 'UPDATED' }
+          assert_equal 'UPDATED', @repository.find(1).attributes['title']
+        end
+
+        should "update the document with a script" do
+          @repository.save Note.new(id: 1, title: 'Test')
+
+          @repository.update 1, script: 'ctx._source.title = "UPDATED"'
+          assert_equal 'UPDATED', @repository.find(1).attributes['title']
+        end
+
+        should "delete the object" do
+          note = My::Note.new id: 1, title: 'Test'
+          @repository.save note
+
+          assert_not_nil @repository.find(1)
+
+          @repository.delete(note)
+          assert_raise(Elasticsearch::Persistence::Repository::DocumentNotFound) { @repository.find(1) }
+        end
+
+        should "create the index with correct mapping" do
+          note = My::Note.new title: 'Testing'
+          @repository.save note, refresh: true
+
+          results = @repository.search query: { match: { title: 'Test' } }
+          assert_equal 'Testing', results.first.attributes['title']
+        end
+      end
+
+    end
+  end
+end

data/test/integration/repository/default_class_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Persistence
+    class RepositoryDefaultClassIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::Note
+        attr_reader :attributes
+
+        def initialize(attributes={})
+          @attributes = attributes
+        end
+
+        def to_hash
+          @attributes
+        end
+      end
+
+      context "The default repository class" do
+        setup do
+          @repository = Elasticsearch::Persistence::Repository.new
+          @repository.client.cluster.health wait_for_status: 'yellow'
+        end
+
+        should "save the object with a custom ID and find it" do
+          @repository.save Note.new(id: '1', title: 'Test')
+
+          assert_equal 'Test', @repository.find(1).attributes['title']
+        end
+
+        should "save the object with an auto-generated ID and find it" do
+          response = @repository.save Note.new(title: 'Test')
+
+          assert_equal 'Test', @repository.find(response['_id']).attributes['title']
+        end
+
+        should "update the document" do
+          @repository.save Note.new(id: 1, title: 'Test')
+
+          @repository.update 1, type: 'note', doc: { title: 'UPDATED' }
+          assert_equal 'UPDATED', @repository.find(1).attributes['title']
+        end
+
+        should "update the document with a script" do
+          @repository.save Note.new(id: 1, title: 'Test')
+
+          @repository.update 1, type: 'note', script: 'ctx._source.title = "UPDATED"'
+          assert_equal 'UPDATED', @repository.find(1).attributes['title']
+        end
+
+        should "save the document with an upsert" do
+          @repository.update 1, type: 'note', script: 'ctx._source.clicks += 1', upsert: { clicks: 1 }
+          assert_equal 1, @repository.find(1).attributes['clicks']
+        end
+
+        should "delete an object" do
+          note = Note.new(id: '1', title: 'Test')
+
+          @repository.save(note)
+          assert_not_nil @repository.find(1)
+          @repository.delete(note)
+          assert_raise(Elasticsearch::Persistence::Repository::DocumentNotFound) { @repository.find(1) }
+        end
+
+        should "find multiple objects" do
+          (1..5).each { |i| @repository.save Note.new(id: i, title: "Test #{i}") }
+
+          assert_equal 5, @repository.find(1, 2, 3, 4, 5).size
+          assert_equal 5, @repository.find([1, 2, 3, 4, 5]).size
+        end
+
+        should "pass options to save and find" do
+          note = Note.new(id: '1', title: 'Test')
+          @repository.save note, routing: 'ABC'
+
+          assert_raise Elasticsearch::Persistence::Repository::DocumentNotFound do
+            @repository.find(1, routing: 'DEF')
+          end
+
+          assert_nothing_raised do
+            note = @repository.find(1, routing: 'ABC')
+            assert_instance_of Note, note
+          end
+        end
+
+        should "find notes with full text search" do
+          @repository.save Note.new(title: 'Test')
+          @repository.save Note.new(title: 'Test Test')
+          @repository.save Note.new(title: 'Crust')
+          @repository.client.indices.refresh index: @repository.index_name
+
+          results = @repository.search 'test'
+          assert_equal 2, results.size
+
+          results = @repository.search query: { match: { title: 'Test' } }
+          assert_equal 2, results.size
+        end
+
+        should "count notes" do
+          @repository.save Note.new(title: 'Test')
+          @repository.client.indices.refresh index: @repository.index_name
+          assert_equal 1, @repository.count
+        end
+
+        should "save and find a plain hash" do
+          @repository.save id: 1, title: 'Hash'
+          result = @repository.find(1)
+          assert_equal 'Hash', result['_source']['title']
+        end
+      end
+
+    end
+  end
+end

data/test/integration/repository/virtus_model_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+require 'virtus'
+
+module Elasticsearch
+  module Persistence
+    class RepositoryWithVirtusIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::Page
+        include Virtus.model
+
+        attribute :id,        String, writer: :private
+        attribute :title,     String
+        attribute :views,     Integer, default: 0
+        attribute :published, Boolean, default: false
+        attribute :slug,      String,  default: lambda { |page, attr| page.title.downcase.gsub(' ', '-') }
+
+        def set_id(id)
+          self.id = id
+        end
+      end
+
+      context "The repository with a Virtus model" do
+        setup do
+          @repository = Elasticsearch::Persistence::Repository.new do
+            index :pages
+            klass Page
+
+            def deserialize(document)
+              page = klass.new document['_source']
+              page.set_id document['_id']
+              page
+            end
+          end
+        end
+
+        should "save and find the object" do
+          page = Page.new title: 'Test Page'
+
+          response = @repository.save page
+          id = response['_id']
+
+          result = @repository.find(id)
+
+          assert_instance_of Page,  result
+          assert_equal 'Test Page', result.title
+          assert_equal 0,           result.views
+
+          assert_not_nil Elasticsearch::Persistence.client.get index: 'pages',
+                                                               type: 'page',
+                                                               id: id
+        end
+
+        should "update the object with a partial document" do
+          response = @repository.save Page.new(title: 'Test')
+          id = response['_id']
+
+          page = @repository.find(id)
+
+          assert_equal 'Test', page.title
+
+          @repository.update page.id, doc: { title: 'UPDATE' }
+
+          page = @repository.find(id)
+          assert_equal 'UPDATE', page.title
+        end
+
+        should "update the object with a Hash" do
+          response = @repository.save Page.new(title: 'Test')
+          id = response['_id']
+
+          page = @repository.find(id)
+
+          assert_equal 'Test', page.title
+
+          @repository.update id: page.id, title: 'UPDATE'
+
+          page = @repository.find(id)
+          assert_equal 'UPDATE', page.title
+        end
+
+        should "update the object with a script" do
+          response = @repository.save Page.new(title: 'Test Page')
+          id = response['_id']
+
+          page = @repository.find(id)
+
+          assert_not_nil page.id
+          assert_equal 0, page.views
+
+          @repository.update page.id, script: 'ctx._source.views += 1'
+
+          page = @repository.find(id)
+          assert_equal 1, page.views
+
+          @repository.update id: page.id, script: 'ctx._source.views += 1'
+
+          page = @repository.find(id)
+          assert_equal 2, page.views
+        end
+
+        should "update the object with a script and params" do
+          response = @repository.save Page.new(title: 'Test Page')
+
+          @repository.update id: response['_id'], script: 'ctx._source.views += count', params: { count: 3 }
+
+          page = @repository.find(response['_id'])
+          assert_equal 3, page.views
+        end
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,53 @@
+RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+exit(0) if RUBY_1_8
+
+require 'simplecov' and SimpleCov.start { add_filter "/test|test_/" } if ENV["COVERAGE"]
+
+# Register `at_exit` handler for integration tests shutdown.
+# MUST be called before requiring `test/unit`.
+at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks } if ENV['SERVER']
+
+if defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
+  require 'test-unit'
+  require 'mocha/test_unit'
+else
+  require 'minitest/autorun'
+  require 'mocha/mini_test'
+end
+
+require 'shoulda-context'
+
+require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || defined?(RUBY_VERSION) && RUBY_VERSION > '2.2'
+
+require 'ansi'
+require 'oj'
+
+require 'elasticsearch/extensions/test/cluster'
+require 'elasticsearch/extensions/test/startup_shutdown'
+
+require 'elasticsearch/persistence'
+
+module Elasticsearch
+  module Test
+    class IntegrationTestCase < ::Test::Unit::TestCase
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+
+      startup  { Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running? }
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
+      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
+
+      def setup
+        tracer = ::Logger.new(STDERR)
+        tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
+        Elasticsearch::Persistence.client = Elasticsearch::Client.new \
+                                              host: "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9250)}",
+                                              tracer: (ENV['QUIET'] ? nil : tracer)
+      end
+
+      def teardown
+        Elasticsearch::Persistence.client.indices.delete index: '_all'
+      end
+    end
+  end
+end

data/test/unit/model_base_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+require 'elasticsearch/persistence/model'
+require 'elasticsearch/persistence/model/rails'
+
+class Elasticsearch::Persistence::ModelBaseTest < Test::Unit::TestCase
+  context "The model" do
+    setup do
+      class DummyBaseModel
+        include Elasticsearch::Persistence::Model
+
+        attribute :name, String
+      end
+    end
+
+    should "respond to id, _id, _index, _type and _version" do
+      model = DummyBaseModel.new
+
+      [:id, :_id, :_index, :_type, :_version].each { |method| assert_respond_to model, method }
+    end
+
+    should "set the ID from attributes during initialization" do
+      m = DummyBaseModel.new id: 1
+      assert_equal 1, m.id
+
+      m = DummyBaseModel.new 'id' => 2
+      assert_equal 2, m.id
+    end
+
+    should "set the ID using setter method" do
+      m = DummyBaseModel.new id: 1
+      assert_equal 1, m.id
+
+      m.id = 2
+      assert_equal 2, m.id
+    end
+
+    should "have ID in attributes" do
+      m = DummyBaseModel.new id: 1, name: 'Test'
+      assert_equal 1, m.attributes[:id]
+    end
+
+    should "have the customized inspect method" do
+      m = DummyBaseModel.new name: 'Test'
+      assert_match /name\: "Test"/, m.inspect
+    end
+  end
+end