search_flip 2.0.0.beta → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 823b618d9cd15618f5e44b441644f281f1b5598feb11f52db75a538df78761ba
-  data.tar.gz: 3812f77dbcd670d76f9ae641f574035ff847c97b6c151f70f3fa663edf9619a6
+  metadata.gz: 61c625b2c60157b40c9508e6847e9727b1a468e03910afe317f39fd9687310bd
+  data.tar.gz: bdfc1613945464bb559243cf3d98fe9d29308d35ab2c6133db065bd9efa70322
 SHA512:
-  metadata.gz: 2698a48a6c9e880a57776bd9bd39b21fdcbace96c5e1e50d12f81064dd3fb095d35c528c792d4f40951a9debde33dae4620928934e98596b3a32b2e9bb406c80
-  data.tar.gz: c4ba2b7c24f4096c98e3458e6c289c1ea7f9519f3f29ebf87d882f4d7600839c8ee96eb3c07efb76ff1fe3b738b39a0f7d9036a3682d86bc5751c71f26acdcc2
+  metadata.gz: 24dbb5c4294827bd66b24d67a873adfb819eba35d74c393149afe5133f6b59339254e2d3348130035675b0e2ce40cdc223133db0ed52bd2e9ca34d87e9383992
+  data.tar.gz: 8066d64b3695d56fff2f4445602f7d4a86a815a536e825ed7a5287c5738193dfc2e4e8a81d6ea95c03e945cea564a7ff70be43c9fb97e3c30d96c972703ab57f

data/CHANGELOG.md

@@ -3,15 +3,16 @@
 
 ## v2.0.0
 
-* **BREAKING**: Migration steps
-  * Change `SearchFlip.version` to `SearchFlip::Connection#version`
-  * Change `SearchFlip.msearch` to `SearchFlip::Connection#msearch`
-  * Change `SearchFlip.aliases` to `SearchFlip::Connection#update_aliases`
-  * Change `SearchFlip::Criteria#execute(base_url: '...')` to `SearchFlip::Criteria#execute(connection: SearchFlip::Connection.new(base_url: '...'))`
 * Added `SearchFlip::Connection`
-* Added `SearchFlip::Connection#update_aliases`
+* [BREAKING] Changed `SearchFlip::Index.base_url` to `SearchFlip::Index.connection`
+* [BREAKING] Changed `SearchFlip.version` to `SearchFlip::Connection#version`
+* [BREAKING] Changed `SearchFlip.aliases` to `SearchFlip::Connection#update_aliases`
+* [BREAKING] Changed `SearchFlip.msearch` to `SearchFlip::Connection#msearch`
+* [BREAKING] Removed `base_url` param from `SearchFlip::Critiera#execute`
 * Added `SearchFlip::Connection#get_aliases`
+* Added `SearchFlip::Connection#get_indices`
 * Added `SearchFlip::Connection#alias_exists?`
+* Added `SearchFlip::Index#with_settings` and `SearchFlip::Criteria#with_settings`
 
 ## v1.1.0
 

data/README.md

@@ -22,6 +22,10 @@ end
 CommentIndex.range(:created_at, gt: Date.today - 1.week, lt: Date.today).where(state: ["approved", "pending"])
 ```
 
+## Updating from previous SearchFlip versions
+
+Checkout [UPDATING.md](./UPDATING.md) for detailed instructions.
+
 ## Comparison with other gems
 
 There are great ruby gems to work with Elasticsearch like e.g. searchkick and
@@ -250,6 +254,41 @@ CommentIndex.match_all.find_each do |record|
 end
 ```
 
+## Working with Elasticsearch Aliases
+
+You can use and manage Elasticsearch Aliases like the following:
+
+```ruby
+class UserIndex
+  include SearchFlip::Index
+
+  def self.index_name
+    alias_name
+  end
+
+  def self.alias_name
+    "users"
+  end
+end
+```
+
+Then, create an index, import the records and add the alias like:
+
+```ruby
+new_user_index = UserIndex.with_settings(index_name: "users-#{SecureRandom.hex}")
+new_user_index.create_index
+new_user_index.import User.all
+new_user.connection.update_aliases(actions: [
+  add: { index: new_user_index.index_name, alias: new_user_index.alias_name }
+])
+```
+
+If the alias already exists, you of course have to remove it as well first
+within `update_aliases`.
+
+Please note that `with_settings(index_name: '...')` returns an anonymous, i.e.
+temporary, class inherting from UserIndex and overwriting `index_name`.
+
 ## Advanced Usage
 
 SearchFlip supports even more advanced usages, like e.g. post filters, filtered

data/UPDATING.md

@@ -0,0 +1,113 @@
+
+# Updating from previous SearchFlip versions
+
+## Update 1.x to 2.x
+
+* [BREAKING] Changed `SearchFlip::Index.base_url` to `SearchFlip::Index.connection`
+
+1.x:
+
+```ruby
+class MyIndex
+  include SearchFlip::Index
+
+  # ...
+
+  def self.base_url
+    "..."
+  end
+end
+```
+
+2.x:
+
+```ruby
+class MyIndex
+  include SearchFlip::Index
+
+  # ...
+
+  def self connection
+    @connection ||= SearchFlip::Connection.new(base_url: "...")
+  end
+end
+```
+
+* [BREAKING] Changed `SearchFlip.version` to `SearchFlip::Connection#version`
+
+1.x:
+
+```ruby
+SearchFlip.version
+```
+
+2.x:
+
+```ruby
+MyIndex.connection.version
+
+# or
+
+connection = SearchFlip::Connection.new(base_url: "...")
+connection.version
+```
+
+* [BREAKING] Changed `SearchFlip.aliases` to `SearchFlip::Connection#update_aliases`
+
+1.x:
+
+```ruby
+SearchFlip.aliases(actions: [
+  # ...
+])
+```
+
+2.x:
+
+```ruby
+MyIndex.connection.update_aliases(actions: [
+  # ...
+])
+
+# or
+
+connection = SearchFlip::Connection.new(base_url: "...")
+connection.update_aliases(actions: [
+  # ...
+])
+```
+
+* [BREAKING] Changed `SearchFlip.msearch` to `SearchFlip::Connection#msearch`
+
+1.x:
+
+```ruby
+SearchFlip.msearch(queries)
+```
+
+2.x:
+
+```ruby
+MyIndex.connection.msearch(queries)
+
+# or
+
+connection = SearchFlip::Connection.new(base_url: "...")
+connection.msearch(queries)
+```
+
+* [BREAKING] Removed `base_url` param from `SearchFlip::Critiera#execute`
+
+1.x:
+
+```ruby
+MyIndex.where(id: 1).execute(base_url: "...")
+```
+
+2.x:
+
+```ruby
+connection = SearchFlip::Connection.new(base_url: "...")
+MyIndex.where(id: 1).with_settings(connection: connection).execute
+```
+

data/lib/search_flip/connection.rb

@@ -126,6 +126,131 @@ module SearchFlip
         .get("#{base_url}/_cat/indices/#{name}")
         .parse
     end
+
+    # Creates the specified index within ElasticSearch and applies index
+    # settings, if specified. Raises SearchFlip::ResponseError in case any
+    # errors occur.
+    #
+    # @param index_name [String] The index name
+    # @param index_settings [Hash] The index settings
+    # @return [Boolean] Returns true or raises SearchFlip::ResponseError
+
+    def create_index(index_name, index_settings = {})
+      SearchFlip::HTTPClient.put(index_url(index_name), json: index_settings)
+
+      true
+    end
+
+    # Updates the index settings within ElasticSearch according to the index
+    # settings specified. Raises SearchFlip::ResponseError in case any
+    # errors occur.
+    #
+    # @param index_name [String] The index name to update the settings for
+    # @param index_settings [Hash] The index settings
+    # @return [Boolean] Returns true or raises SearchFlip::ResponseError
+
+    def update_index_settings(index_name, index_settings)
+      SearchFlip::HTTPClient.put("#{index_url(index_name)}/_settings", json: index_settings)
+
+      true
+    end
+
+    # Fetches the index settings for the specified index from ElasticSearch.
+    # Sends a GET request to index_url/_settings. Raises
+    # SearchFlip::ResponseError in case any errors occur.
+    #
+    # @param index_name [String] The index name
+    # @return [Hash] The index settings
+
+    def get_index_settings(index_name)
+      SearchFlip::HTTPClient.headers(accept: "application/json").get("#{index_url(index_name)}/_settings").parse
+    end
+
+    # Sends a refresh request to ElasticSearch. Raises
+    # SearchFlip::ResponseError in case any errors occur.
+    #
+    # @param index_names [String, Array] The optional index names to refresh
+    # @return [Boolean] Returns true or raises SearchFlip::ResponseError
+
+    def refresh(index_names = nil)
+      SearchFlip::HTTPClient.post("#{index_names ? index_url(Array(index_names).join(",")) : base_url}/_refresh", json: {})
+
+      true
+    end
+
+    # Updates the type mapping for the specified index and type within
+    # ElasticSearch according to the specified mapping. Raises
+    # SearchFlip::ResponseError in case any errors occur.
+    #
+    # @param index_name [String] The index name
+    # @param type_name [String] The type name
+    # @param mapping [Hash] The mapping
+    # @return [Boolean] Returns true or raises SearchFlip::ResponseError
+
+    def update_mapping(index_name, type_name, mapping)
+      SearchFlip::HTTPClient.put("#{type_url(index_name, type_name)}/_mapping", json: mapping)
+
+      true
+    end
+
+    # Retrieves the mapping for the specified index and type from
+    # ElasticSearch. Raises SearchFlip::ResponseError in case any errors occur.
+    #
+    # @param index_name [String] The index name
+    # @param type_name [String] The type name
+    # @return [Hash] The current type mapping
+
+    def get_mapping(index_name, type_name)
+      SearchFlip::HTTPClient.headers(accept: "application/json").get("#{type_url(index_name, type_name)}/_mapping").parse
+    end
+
+    # Deletes the specified index from ElasticSearch. Raises
+    # SearchFlip::ResponseError in case any errors occur.
+    #
+    # @param index_name [String] The index name
+    # @return [Boolean] Returns true or raises SearchFlip::ResponseError
+
+    def delete_index(index_name)
+      SearchFlip::HTTPClient.delete index_url(index_name)
+
+      true
+    end
+
+    # Returns whether or not the specified index already exists.
+    #
+    # @param index_name [String] The index name
+    # @return [Boolean] Whether or not the index exists
+
+    def index_exists?(index_name)
+      SearchFlip::HTTPClient.headers(accept: "application/json").head(index_url(index_name))
+
+      true
+    rescue SearchFlip::ResponseError => e
+      return false if e.code == 404
+
+      raise e
+    end
+
+    # Returns the full ElasticSearch type URL, ie base URL, index name with
+    # prefix and type name.
+    #
+    # @param index_name [String] The index name
+    # @param type_name [String] The type name
+    # @return [String] The ElasticSearch type URL
+
+    def type_url(index_name, type_name)
+      "#{index_url(index_name)}/#{type_name}"
+    end
+
+    # Returns the ElasticSearch index URL for the specified index name, ie base
+    # URL and index name with prefix.
+    #
+    # @param index_name [String] The index name
+    # @return [String] The ElasticSearch index URL
+
+    def index_url(index_name)
+      "#{base_url}/#{index_name}"
+    end
   end
 end
 

data/lib/search_flip/criteria.rb

@@ -60,7 +60,7 @@ module SearchFlip
         criteria.post_must_values = (criteria.post_must_values || []) + other.post_must_values if other.post_must_values
         criteria.post_must_not_values = (criteria.post_must_not_values || []) + other.post_must_not_values if other.post_must_not_values
         criteria.post_should_values = (criteria.post_should_values || []) + other.post_should_values if other.post_should_values
-        criteria.post_filter_values = (criteria.post_filter_vales || []) + other.post_filter_values if other.post_filter_values
+        criteria.post_filter_values = (criteria.post_filter_values || []) + other.post_filter_values if other.post_filter_values
         criteria.aggregation_values = (criteria.aggregation_values || {}).merge(other.aggregation_values) if other.aggregation_values
         criteria.terminate_after_value = other.terminate_after_value unless other.terminate_after_value.nil?
         criteria.timeout_value = other.timeout_value unless other.timeout_value.nil?
@@ -149,6 +149,22 @@ module SearchFlip
       end
     end
 
+    # Allows to set query specific settings like e.g. connection and index
+    # name. Please note, however, that this should only be used for special
+    # cases and the subsequent query can not be serialized. Checkout
+    # SearchFlip::Index.with_settings for more details.
+    #
+    # @example
+    #   UserIndex.where("...").with_settings(connection: ProxyConnection)
+    #
+    # @return [SearchFlip::Criteria] Simply returns self
+
+    def with_settings(*args)
+      fresh.tap do |criteria|
+        criteria.target = target.with_settings(*args)
+      end
+    end
+
     # Generates the request object from the attributes specified via chaining,
     # like eg offset, limit, query, filters, aggregations, etc and returns a
     # Hash that later gets serialized as JSON.
@@ -662,15 +678,12 @@ module SearchFlip
     # response errors will be rescued if you specify the criteria to be
     # #failsafe, such that an empty response is returned instead.
     #
-    # @param connection An optional alternative connection to used to send the
-    #   request to for e.g. proxying
-    #
     # @example
     #   response = CommentIndex.search("hello world").execute
     #
     # @return [SearchFlip::Response] The response object
 
-    def execute(connection: target.connection)
+    def execute
       @response ||= begin
         http_request = SearchFlip::HTTPClient.headers(accept: "application/json")
 
@@ -678,22 +691,22 @@ module SearchFlip
           if scroll_args && scroll_args[:id]
             if target.connection.version.to_i >= 2
               http_request.post(
-                "#{connection.base_url}/_search/scroll",
+                "#{target.connection.base_url}/_search/scroll",
                 json: { scroll: scroll_args[:timeout], scroll_id: scroll_args[:id] }
               )
             else
               http_request
                 .headers(content_type: "text/plain")
-                .post("#{connection.base_url}/_search/scroll", params: { scroll: scroll_args[:timeout] }, body: scroll_args[:id])
+                .post("#{target.connection.base_url}/_search/scroll", params: { scroll: scroll_args[:timeout] }, body: scroll_args[:id])
             end
           elsif scroll_args
             http_request.post(
-              "#{target.type_url(connection: connection)}/_search",
+              "#{target.type_url}/_search",
               params: { scroll: scroll_args[:timeout] },
               json: request
             )
           else
-            http_request.post("#{target.type_url(connection: connection)}/_search", json: request)
+            http_request.post("#{target.type_url}/_search", json: request)
           end
 
         SearchFlip::Response.new(self, http_response.parse)

data/lib/search_flip/index.rb

@@ -68,6 +68,34 @@ module SearchFlip
         {}
       end
 
+      # Creates an anonymous class inheriting from the current index with a
+      # custom index name and/or connection. This is e.g. useful when working
+      # with aliases or proxies.
+      #
+      # @example Basic usage
+      #   UserIndex.with_settings(index_name: 'new_user_index')
+      #   # => #<Class:0x...>
+      #
+      # @example Working with aliases
+      #   new_index = UserIndex.with_settings(index_name: 'new_user_index')
+      #   new_index.create_index
+      #   new_index.import User.all
+      #   new_index.connection.update_aliases("...")
+      #
+      # @example Working with proxies
+      #   query = UserIndex.with_settings(connection: ProxyConnection).where("...")
+      #
+      # @param index_name [String] A custom index_name
+      # @param connection [SearchFlip::Connection] A custom connection
+      # @return [Class] An anonymous class
+
+      def with_settings(index_name: nil, connection: nil)
+        Class.new(self).tap do |klass|
+          klass.define_singleton_method(:index_name) { index_name } if index_name
+          klass.define_singleton_method(:connection) { connection } if connection
+        end
+      end
+
       # @abstract
       #
       # Override this method to generate a hash representation of a record,
@@ -278,13 +306,7 @@ module SearchFlip
       # @return [Boolean] Whether or not the index exists
 
       def index_exists?
-        SearchFlip::HTTPClient.headers(accept: "application/json").head(index_url)
-
-        true
-      rescue SearchFlip::ResponseError => e
-        return false if e.code == 404
-
-        raise e
+        connection.index_exists?(index_name_with_prefix)
       end
 
       # Fetches the index settings from ElasticSearch. Sends a GET request to
@@ -294,36 +316,38 @@ module SearchFlip
       # @return [Hash] The index settings
 
       def get_index_settings
-        SearchFlip::HTTPClient.headers(accept: "application/json").get("#{index_url}/_settings").parse
+        connection.get_index_settings(index_name_with_prefix)
       end
 
       # Creates the index within ElasticSearch and applies index settings, if
       # specified. Raises SearchFlip::ResponseError in case any errors
       # occur.
+      #
+      # @param include_mapping [Boolean] Whether or not to include the mapping
+      # @return [Boolean] Returns true or false
 
-      def create_index
-        SearchFlip::HTTPClient.put(index_url, json: index_settings)
+      def create_index(include_mapping: false)
+        json = index_settings
+        json = json.merge(mappings: mapping) if include_mapping
 
-        true
+        connection.create_index(index_name_with_prefix, json)
       end
 
       # Updates the index settings within ElasticSearch according to the index
       # settings specified. Raises SearchFlip::ResponseError in case any
       # errors occur.
+      #
+      # @return [Boolean] Returns true or false
 
       def update_index_settings
-        SearchFlip::HTTPClient.put("#{index_url}/_settings", json: index_settings)
-
-        true
+        connection.update_index_settings(index_name_with_prefix, index_settings)
       end
 
       # Deletes the index from ElasticSearch. Raises SearchFlip::ResponseError
       # in case any errors occur.
 
       def delete_index
-        SearchFlip::HTTPClient.delete(index_url)
-
-        true
+        connection.delete_index(index_name_with_prefix)
       end
 
       # Specifies a type mapping. Override to specify a custom mapping.
@@ -351,9 +375,7 @@ module SearchFlip
       # errors occur.
 
       def update_mapping
-        SearchFlip::HTTPClient.put("#{type_url}/_mapping", json: mapping)
-
-        true
+        connection.update_mapping(index_name_with_prefix, type_name, mapping)
       end
 
       # Retrieves the current type mapping from ElasticSearch. Raises
@@ -362,13 +384,15 @@ module SearchFlip
       # @return [Hash] The current type mapping
 
       def get_mapping
-        SearchFlip::HTTPClient.headers(accept: "application/json").get("#{type_url}/_mapping").parse
+        connection.get_mapping(index_name_with_prefix, type_name)
       end
 
       # Retrieves the document specified by id from ElasticSearch. Raises
       # SearchFlip::ResponseError specific exceptions in case any errors
       # occur.
       #
+      # @param id [String, Fixnum] The id to get
+      # @param params [Hash] Optional params for the request
       # @return [Hash] The specified document
 
       def get(id, params = {})
@@ -379,9 +403,7 @@ module SearchFlip
       # SearchFlip::ResponseError in case any errors occur.
 
       def refresh
-        SearchFlip::HTTPClient.post("#{index_url}/_refresh", json: {})
-
-        true
+        connection.refresh(index_name_with_prefix)
       end
 
       # Indexes the given record set, array of records or individual record.
@@ -520,23 +542,19 @@ module SearchFlip
       # Returns the full ElasticSearch type URL, ie base URL, index name with
       # prefix and type name.
       #
-      # @param connection [SearchFlip::Connection] The connection to use
-      #
       # @return [String] The ElasticSearch type URL
 
-      def type_url(connection: self.connection)
-        "#{index_url(connection: connection)}/#{type_name}"
+      def type_url
+        connection.type_url(index_name_with_prefix, type_name)
       end
 
       # Returns the ElasticSearch index URL, ie base URL and index name with
       # prefix.
       #
-      # @param connection [SearchFlip::Connection] The connection to use
-      #
       # @return [String] The ElasticSearch index URL
 
-      def index_url(connection: self.connection)
-        "#{connection.base_url}/#{index_name_with_prefix}"
+      def index_url
+        connection.index_url(index_name_with_prefix)
       end
 
       # Returns the SearchFlip::Connection for the index.

data/lib/search_flip/version.rb

@@ -1,5 +1,5 @@
 
 module SearchFlip
-  VERSION = "2.0.0.beta"
+  VERSION = "2.0.0.beta2"
 end
 

data/test/search_flip/connection_test.rb

@@ -66,5 +66,96 @@ class SearchFlip::ConnectionTest < SearchFlip::TestCase
     assert_equal connection.get_indices.map { |index| index["index"] }.sort, ["comments", "products"]
     assert_equal connection.get_indices("com*").map { |index| index["index"] }.sort, ["comments"]
   end
+
+  def test_create_index
+    connection = SearchFlip::Connection.new
+
+    assert connection.create_index("index_name")
+    assert connection.index_exists?("index_name")
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_create_index_with_index_payload
+    connection = SearchFlip::Connection.new
+
+    connection.create_index("index_name", settings: { number_of_shards: 3 })
+
+    assert_equal connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_shards"], "3"
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_update_index_settings
+    connection = SearchFlip::Connection.new
+
+    connection.create_index("index_name")
+    connection.update_index_settings("index_name", settings: { number_of_replicas: 3 })
+
+    assert_equal "3", connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_replicas"]
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_get_index_settings
+    connection = SearchFlip::Connection.new
+
+    connection.create_index("index_name", settings: { number_of_shards: 3 })
+
+    assert_equal connection.get_index_settings("index_name")["index_name"]["settings"]["index"]["number_of_shards"], "3"
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_update_mapping
+    connection = SearchFlip::Connection.new
+
+    mapping = { "type_name" => { "properties" => { "id" => { "type" => "long" } } } }
+
+    connection.create_index("index_name")
+    connection.update_mapping("index_name", "type_name", mapping)
+
+    assert_equal connection.get_mapping("index_name", "type_name"), "index_name" => { "mappings" => mapping }
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_delete_index
+    connection = SearchFlip::Connection.new
+
+    connection.create_index("index_name")
+    assert connection.index_exists?("index_name")
+
+    connection.delete_index("index_name")
+    refute connection.index_exists?("index_name")
+  ensure
+    connection.delete_index("index_name") if connection.index_exists?("index_name")
+  end
+
+  def test_refresh
+    connection = SearchFlip::Connection.new
+
+    connection.create_index("index1")
+    connection.create_index("index2")
+
+    assert connection.refresh
+    assert connection.refresh("index1")
+    assert connection.refresh(["index1", "index2"])
+  ensure
+    connection.delete_index("index1") if connection.index_exists?("index1")
+    connection.delete_index("index2") if connection.index_exists?("index2")
+  end
+
+  def test_index_url
+    connection = SearchFlip::Connection.new(base_url: "base_url")
+
+    assert_equal "base_url/index_name", connection.index_url("index_name")
+  end
+
+  def test_type_url
+    connection = SearchFlip::Connection.new(base_url: "base_url")
+
+    assert_equal "base_url/index_name/type_name", connection.type_url("index_name", "type_name")
+  end
 end
 

data/test/search_flip/criteria_test.rb

@@ -62,6 +62,13 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     refute_includes query2.records, product3
   end
 
+  def test_with_settings
+    stub_request(:post, "http://127.0.0.1:9200/new_user_index/products/_search")
+      .to_return(status: 200, body: "{}", headers: { content_type: "application/json" })
+
+    ProductIndex.where(id: 1).with_settings(index_name: "new_user_index").execute
+  end
+
   def test_where_with_array
     expected1 = create(:product, title: "expected1")
     expected2 = create(:product, title: "expected2")
@@ -211,15 +218,6 @@ class SearchFlip::CriteriaTest < SearchFlip::TestCase
     assert_includes records, expected2
   end
 
-  def test_execute
-    connection = SearchFlip::Connection.new(base_url: "http://localhost:1234")
-
-    stub_request(:post, "http://localhost:1234/products/products/_search")
-      .to_return(status: 200, body: "{}", headers: { content_type: "application/json" })
-
-    assert_equal ProductIndex.match_all.execute(connection: connection).raw_response, {}
-  end
-
   def test_exists
     product1 = create(:product, title: "title1", description: "description1")
     product2 = create(:product, title: "title2", description: nil)

data/test/search_flip/index_test.rb

@@ -30,97 +30,166 @@ class SearchFlip::IndexTest < SearchFlip::TestCase
     end
   end
 
-  def test_create_index
+  def test_create_index_works
     assert TestIndex.create_index
-    assert TestIndex.index_exists?
-
-    TestIndex.delete_index
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
-    refute TestIndex.index_exists?
+  def test_create_index_delegates_to_connection
+    TestIndex.connection.expects(:create_index).with("test", {})
+    TestIndex.create_index
   end
 
-  def test_create_index_with_index_settings
+  def test_create_index_passes_index_settings_to_connection
     TestIndex.stubs(:index_settings).returns(settings: { number_of_shards: 3 })
-
     assert TestIndex.create_index
-    assert TestIndex.index_exists?
 
-    assert_equal "3", TestIndex.get_index_settings["test"]["settings"]["index"]["number_of_shards"]
+    assert "3", TestIndex.get_index_settings["test"]["settings"]["index"]["number_of_replicas"]
   ensure
     TestIndex.delete_index if TestIndex.index_exists?
   end
 
-  def test_update_index_settings
+  def test_create_index_passes_index_settings_delegates_to_connection
+    TestIndex.stubs(:index_settings).returns(settings: { number_of_shards: 3 })
+
+    TestIndex.connection.expects(:create_index).with("test", settings: { number_of_shards: 3 })
+    TestIndex.create_index
+  end
+
+  def test_create_index_passes_mapping_if_specified
+    TestIndex.stubs(:mapping).returns(test: { properties: { id: { type: "long" } } })
     assert TestIndex.create_index
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
-    TestIndex.stubs(:index_settings).returns(settings: { number_of_replicas: 3 })
+  def test_create_index_passes_mapping_if_specified_delegates_to_connection
+    TestIndex.stubs(:mapping).returns(test: { properties: { id: { type: "long" } } })
 
-    assert TestIndex.update_index_settings
+    TestIndex.connection.expects(:create_index).with("test", mappings: { test: { properties: { id: { type: "long" } } } })
+    TestIndex.create_index(include_mapping: true)
+  end
 
-    assert_equal "3", TestIndex.get_index_settings["test"]["settings"]["index"]["number_of_replicas"]
+  def test_update_index_settings_works
+    TestIndex.create_index
+    TestIndex.stubs(:index_settings).returns(settings: { number_of_replicas: 3 })
+    TestIndex.update_index_settings
   ensure
     TestIndex.delete_index if TestIndex.index_exists?
   end
 
-  def test_get_index_settings
-    # Already tested
+  def test_update_index_settings_delegates_to_connection
+    index_settings = { settings: { number_of_replicas: 3 } }
+
+    TestIndex.stubs(:index_settings).returns(settings: { number_of_replicas: 3 })
+
+    TestIndex.connection.expects(:update_index_settings).with("test", index_settings)
+    TestIndex.update_index_settings
   end
 
-  def test_index_exists?
-    # Already tested
+  def test_get_index_settings_works
+    TestIndex.create_index
+    assert TestIndex.get_index_settings
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
   end
 
-  def test_delete_index
-    # Already tested
+  def test_get_index_settings_delegates_to_connection
+    TestIndex.connection.expects(:get_index_settings).with("test")
+    TestIndex.get_index_settings
   end
 
-  def test_update_mapping
+  def test_index_exists_works
     TestIndex.create_index
-    TestIndex.update_mapping
+    assert TestIndex.index_exists?
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
-    mapping = TestIndex.get_mapping
+  def test_index_exists_delegates_to_connection
+    TestIndex.connection.expects(:index_exists?).with("test")
+    TestIndex.index_exists?
+  end
 
-    assert mapping["test"]["mappings"]["test"]["properties"]["test_field"]
+  def test_delete_index_works
+    TestIndex.create_index
+    assert TestIndex.delete_index
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
+  def test_delete_index_delegates_to_connection
+    TestIndex.connection.expects(:delete_index).with("test")
     TestIndex.delete_index
   end
 
-  def test_get_mapping
-    # Aready tested
+  def test_update_mapping_works
+    TestIndex.stubs(:mapping).returns(test: { properties: { id: { type: "long" } } })
+
+    TestIndex.create_index
+    TestIndex.update_mapping
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
   end
 
-  def test_refresh
-    assert_difference "ProductIndex.total_entries" do
-      ProductIndex.import create(:product)
+  def test_update_mapping_delegates_to_connection
+    mapping = { test: { properties: { id: { type: "long" } } } }
 
-      assert ProductIndex.refresh
-    end
+    TestIndex.stubs(:mapping).returns(mapping)
+
+    TestIndex.connection.expects(:update_mapping).with("test", "test", mapping)
+    TestIndex.update_mapping
   end
 
-  def test_index_url
-    assert_equal "http://127.0.0.1:9200/products", ProductIndex.index_url
+  def test_get_mapping_works
+    TestIndex.create_index
+    TestIndex.update_mapping
 
-    ProductIndex.stubs(:type_name).returns("products2")
+    assert TestIndex.get_mapping
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
-    assert_equal "http://127.0.0.1:9200/products2", ProductIndex.index_url
+  def test_get_mapping_delegates_to_connection
+    TestIndex.connection.expects(:get_mapping).with("test", "test")
+    TestIndex.get_mapping
+  end
 
-    SearchFlip::Config[:index_prefix] = "prefix-"
+  def test_refresh_works
+    TestIndex.create_index
+    TestIndex.refresh
+  ensure
+    TestIndex.delete_index if TestIndex.index_exists?
+  end
 
-    assert_equal "http://127.0.0.1:9200/prefix-products2", ProductIndex.index_url
+  def test_refresh_delegates_to_connection
+    TestIndex.connection.expects(:refresh).with("test")
+    TestIndex.refresh
+  end
 
-    ProductIndex.stubs(:index_name).returns("products3")
+  def test_index_url
+    assert TestIndex.index_url
+  end
 
-    assert_equal "http://127.0.0.1:9200/prefix-products3", ProductIndex.index_url
+  def test_index_url_delegates_to_connection
+    TestIndex.connection.expects(:index_url).with("test")
+    TestIndex.index_url
 
+    SearchFlip::Config[:index_prefix] = "prefix-"
+    TestIndex.connection.expects(:index_url).with("prefix-test")
+    TestIndex.index_url
+  ensure
     SearchFlip::Config[:index_prefix] = nil
   end
 
   def test_type_url
-    assert_equal "http://127.0.0.1:9200/products/products", ProductIndex.type_url
-
-    ProductIndex.stubs(:type_name).returns("products2")
+    assert TestIndex.type_url
+  end
 
-    assert_equal "http://127.0.0.1:9200/products2/products2", ProductIndex.type_url
+  def test_type_url_delegates_to_connection
+    TestIndex.connection.expects(:type_url).with("test", "test")
+    TestIndex.type_url
   end
 
   def test_import_object
@@ -376,7 +445,7 @@ class SearchFlip::IndexTest < SearchFlip::TestCase
   end
 
   def test_connection
-    assert_equal ProductIndex.connection.base_url, "http://127.0.0.1:9200"
+    assert_equal "http://127.0.0.1:9200", ProductIndex.connection.base_url
   end
 end
 

data/test/test_helper.rb

@@ -238,5 +238,6 @@ class SearchFlip::TestCase < MiniTest::Test
   def setup
     ProductIndex.match_all.delete
     Product.delete_all
+    TestIndex.delete_index if TestIndex.index_exists?
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: search_flip
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-20 00:00:00.000000000 Z
+date: 2019-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -193,6 +193,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- UPDATING.md
 - docker-compose.yml
 - lib/search_flip.rb
 - lib/search_flip/aggregatable.rb