fluent-plugin-droonga 0.0.2 → 0.7.0

data/test/{plugin → unit/plugin}/handler/groonga/test_column_create.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 droonga project
+# Copyright (C) 2013 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,14 +15,18 @@
 
 class ColumnCreateTest < GroongaHandlerTest
   def test_success
-    @handler.table_create({"name" => "Books"})
-    @handler.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
-    assert_equal([true], @worker.body)
+    @plugin.table_create({"name" => "Books"})
+    @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
+    response = @messages.last.first
+    assert_equal(
+      [[Droonga::GroongaHandler::Status::SUCCESS, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], true],
+      [normalize_header(response.first), response.last]
+    )
   end
 
   def test_name
-    @handler.table_create({"name" => "Books"})
-    @handler.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
+    @plugin.table_create({"name" => "Books"})
+    @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
     assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title COLUMN_SCALAR ShortText
@@ -30,8 +34,8 @@ column_create Books title COLUMN_SCALAR ShortText
   end
 
   def test_type
-    @handler.table_create({"name" => "Books"})
-    @handler.column_create({"table" => "Books", "name" => "main_text", "type" => "LongText"})
+    @plugin.table_create({"name" => "Books"})
+    @plugin.column_create({"table" => "Books", "name" => "main_text", "type" => "LongText"})
     assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books main_text COLUMN_SCALAR LongText
@@ -55,8 +59,8 @@ column_create Books main_text COLUMN_SCALAR LongText
           "type"  => "ShortText",
           "flags" => data[:flags],
         }
-        @handler.table_create({"name" => "Books"})
-        @handler.column_create(request)
+        @plugin.table_create({"name" => "Books"})
+        @plugin.column_create(request)
         assert_equal(<<-EXPECTED, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title #{data[:flags]} ShortText
@@ -67,8 +71,8 @@ column_create Books title #{data[:flags]} ShortText
     class IndexTest < self
       def setup
         super
-        @handler.table_create({"name" => "Books"})
-        @handler.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
+        @plugin.table_create({"name" => "Books"})
+        @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
       end
 
       def test_index_column_type
@@ -82,7 +86,7 @@ column_create Books title #{data[:flags]} ShortText
           "source" => "title",
           "flags"  => data[:flags],
         }
-        @handler.column_create(request)
+        @plugin.column_create(request)
         assert_equal(<<-EXPECTED, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title COLUMN_SCALAR ShortText
@@ -114,7 +118,7 @@ column_create Books entry_title #{data[:flags]} Books title
           "source" => "title",
           "flags"  => flags,
         }
-        @handler.column_create(request)
+        @plugin.column_create(request)
         assert_equal(<<-EXPECTED, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title COLUMN_SCALAR ShortText

data/test/{plugin → unit/plugin}/handler/groonga/test_table_create.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 droonga project
+# Copyright (C) 2013 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,23 +15,25 @@
 
 class TableCreateTest < GroongaHandlerTest
   def test_success
-    @handler.table_create({"name" => "Books"})
+    @plugin.table_create({"name" => "Books"})
+    response = @messages.last.first
     assert_equal(
       [[Droonga::GroongaHandler::Status::SUCCESS, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], true],
-      [normalize_header(@worker.body.first), @worker.body.last]
+      [normalize_header(response.first), response.last]
     )
   end
 
   def test_failure
-    @handler.table_create({})
+    @plugin.table_create({})
+    response = @messages.last.first
     assert_equal(
       [[Droonga::GroongaHandler::Status::INVALID_ARGUMENT, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], false],
-      [normalize_header(@worker.body.first), @worker.body.last]
+      [normalize_header(response.first), response.last]
     )
   end
 
   def test_name
-    @handler.table_create({"name" => "Books"})
+    @plugin.table_create({"name" => "Books"})
     assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
     SCHEMA
@@ -81,7 +83,7 @@ table_create Books TABLE_NO_KEY
         "name" => "Books",
         "flags" => data[:flags],
       }
-      @handler.table_create(request)
+      @plugin.table_create(request)
       assert_equal(data[:schema], dump)
     end
   end
@@ -92,7 +94,7 @@ table_create Books TABLE_NO_KEY
         "name"  => "Books",
         "key_type" => "Int32",
       }
-      @handler.table_create(request)
+      @plugin.table_create(request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type Int32
       SCHEMA
@@ -105,7 +107,7 @@ table_create Books TABLE_HASH_KEY --key_type Int32
         "name"  => "Books",
         "value_type" => "Int32",
       }
-      @handler.table_create(request)
+      @plugin.table_create(request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText --value_type Int32
       SCHEMA
@@ -118,7 +120,7 @@ table_create Books TABLE_HASH_KEY --key_type ShortText --value_type Int32
         "name"  => "Books",
         "default_tokenizer" => "TokenBigram",
       }
-      @handler.table_create(request)
+      @plugin.table_create(request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenBigram
       SCHEMA
@@ -131,7 +133,7 @@ table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer Token
         "name"  => "Books",
         "normalizer" => "NormalizerAuto",
       }
-      @handler.table_create(request)
+      @plugin.table_create(request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY|KEY_NORMALIZE --key_type ShortText
       SCHEMA

data/test/{plugin/handler/test_handler_add.rb → unit/plugin/handler/test_add.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 droonga project
+# Copyright (C) 2013 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -13,7 +13,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-require "droonga/plugin/handler_add"
+require "droonga/plugin/handler/add"
 
 class AddHandlerTest < Test::Unit::TestCase
   def setup
@@ -28,21 +28,9 @@ class AddHandlerTest < Test::Unit::TestCase
   end
 
   private
-  def setup_database
-    FileUtils.rm_rf(@database_path.dirname.to_s)
-    FileUtils.mkdir_p(@database_path.dirname.to_s)
-    @database = Groonga::Database.create(:path => @database_path.to_s)
-  end
-
   def setup_schema
   end
 
-  def teardown_database
-    @database.close
-    @database = nil
-    FileUtils.rm_rf(@database_path.dirname.to_s)
-  end
-
   def setup_handler
     @worker = StubWorker.new
     @handler = Droonga::AddHandler.new(@worker)

data/test/{plugin/handler/test_handler_groonga.rb → unit/plugin/handler/test_groonga.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 droonga project
+# Copyright (C) 2013 Droonga Project
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -13,41 +13,21 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-require "droonga/plugin/handler_groonga"
+require "droonga/plugin/handler/groonga"
 
 class GroongaHandlerTest < Test::Unit::TestCase
+  include PluginHelper
+
   def setup
     setup_database
-    setup_handler
+    setup_plugin(Droonga::GroongaHandler)
   end
 
   def teardown
-    teardown_handler
+    teardown_plugin
     teardown_database
   end
 
-  private
-  def setup_database
-    FileUtils.rm_rf(@database_path.dirname.to_s)
-    FileUtils.mkdir_p(@database_path.dirname.to_s)
-    @database = Groonga::Database.create(:path => @database_path.to_s)
-  end
-
-  def teardown_database
-    @database.close
-    @database = nil
-    FileUtils.rm_rf(@database_path.dirname.to_s)
-  end
-
-  def setup_handler
-    @worker = StubWorker.new
-    @handler = Droonga::GroongaHandler.new(@worker)
-  end
-
-  def teardown_handler
-    @handler = nil
-  end
-
   private
   def dump
     database_dumper = Groonga::DatabaseDumper.new(:database => @database)

data/test/unit/plugin/handler/test_search.rb

@@ -0,0 +1,601 @@
+# Copyright (C) 2013 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/plugin/handler/search"
+
+class SearchHandlerTest < Test::Unit::TestCase
+  include PluginHelper
+
+  def setup
+    setup_database
+  end
+
+  def teardown
+    teardown_plugin
+    teardown_database
+  end
+
+  private
+  def search(request)
+    @plugin.search(request)
+    results_to_result_set(@messages)
+  end
+
+  def results_to_result_set(results)
+    result_set = {}
+    results.each do |result_and_name|
+      result, name = result_and_name
+      result_set[name] = normalize_result(result)
+    end
+    result_set
+  end
+
+  def normalize_result(result)
+    result["startTime"] = start_time if result["startTime"]
+    result["elapsedTime"] = elapsed_time if result["elapsedTime"]
+    result
+  end
+
+  def start_time
+    "2013-01-31T14:34:47+09:00"
+  end
+
+  def elapsed_time
+    0.01
+  end
+
+  def assert_search(expected, request)
+    assert_equal(expected, search(request))
+  end
+
+  class GeneralTest < self
+    def setup
+      super
+      restore(fixture_data("document.grn"))
+      setup_plugin(Droonga::SearchHandler)
+    end
+
+    class NoParameterTest < self
+      def test_empty
+        assert_search({}, {})
+      end
+    end
+
+    class QueriesTest < self
+      def test_empty
+        assert_search({}, {"queries" => {}})
+      end
+    end
+
+    class HashQueryTest < self
+      def test_string_matchTo
+        request = base_request
+        request["queries"]["sections-result"]["condition"] = {
+          "query" => "Groonga",
+          "matchTo" => "title"
+        }
+        assert_search({
+                        "sections-result" => {
+                          "records" => [
+                            { "title" => "Groonga overview" },
+                          ],
+                        },
+                      },
+                      request)
+      end
+
+      def test_array_matchTo
+        request = base_request
+        request["queries"]["sections-result"]["condition"] = {
+          "query" => "Groonga",
+          "matchTo" => ["title"]
+        }
+        assert_search({
+                        "sections-result" => {
+                          "records" => [
+                            { "title" => "Groonga overview" },
+                          ],
+                        },
+                      },
+                      request)
+      end
+
+      def base_request
+        {
+          "queries" => {
+            "sections-result" => {
+              "source" => "Sections",
+              "output" => {
+                "elements" => [
+                  "records",
+                ],
+                "format" => "complex",
+                "limit" => 1,
+                "attributes" => ["title"],
+              },
+            },
+          },
+        }
+      end
+    end
+
+    class SourceTest < self
+      def test_non_existent
+        assert_raise(Droonga::Searcher::UndefinedSourceError) do
+          search({
+                   "queries" => {
+                     "non-existent-result" => {
+                       "source" => "non-existent",
+                     },
+                   },
+                 })
+        end
+      end
+
+      def test_existent
+        assert_search({
+                        "sections-result" => {},
+                      },
+                      {
+                        "queries" => {
+                          "sections-result" => {
+                            "source" => "Sections",
+                            "output" => {},
+                          },
+                        },
+                      })
+      end
+    end
+
+    class OutputTest < self
+      def test_count
+        assert_search({
+                        "sections-result" => {
+                          "count" => 9,
+                        },
+                      },
+                      {
+                        "queries" => {
+                          "sections-result" => {
+                            "source" => "Sections",
+                            "output" => {
+                              "elements" => [
+                                "count",
+                              ],
+                            },
+                          },
+                        },
+                      })
+      end
+
+      def test_elapsed_time
+        assert_search({
+                        "sections-result" => {
+                          "startTime" => start_time,
+                          "elapsedTime" => elapsed_time,
+                        },
+                      },
+                      {
+                        "queries" => {
+                          "sections-result" => {
+                            "source" => "Sections",
+                            "output" => {
+                              "elements" => [
+                                "startTime",
+                                "elapsedTime",
+                              ],
+                            },
+                          },
+                        },
+                      })
+      end
+
+      class AttributesTest < self
+        def test_source_only
+          expected = {
+            "sections-result" => {
+              "records" => [
+                {
+                  "_key" => "1.1",
+                  "title" => "Groonga overview",
+                },
+                {
+                  "_key" => "1.2",
+                  "title" => "Full text search and Instant update",
+                },
+                {
+                  "_key" => "1.3",
+                  "title" => "Column store and aggregate query",
+                },
+              ],
+            },
+          }
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 3,
+                  "attributes" => ["_key", "title"],
+                },
+              },
+            },
+          }
+          assert_search(expected, request)
+        end
+
+        def test_label
+          expected = {
+            "sections-result" => {
+              "records" => [
+                {
+                  "key" => "1.1",
+                  "title" => "Groonga overview",
+                },
+                {
+                  "key" => "1.2",
+                  "title" => "Full text search and Instant update",
+                },
+                {
+                  "key" => "1.3",
+                  "title" => "Column store and aggregate query",
+                },
+              ],
+            },
+          }
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 3,
+                  "attributes" => [
+                    {
+                      "label" => "key",
+                      "source" => "_key",
+                    },
+                    "title",
+                  ],
+                },
+              },
+            },
+          }
+          assert_search(expected, request)
+        end
+
+        def test_static_value
+          expected = {
+            "sections-result" => {
+              "records" => [
+                {
+                  "single_quote_string" => "string value",
+                  "double_quote_string" => "string value",
+                  "integer" => 29,
+                  "complex_negative_number" => -29.29,
+                },
+                {
+                  "single_quote_string" => "string value",
+                  "double_quote_string" => "string value",
+                  "integer" => 29,
+                  "complex_negative_number" => -29.29,
+                },
+              ],
+            },
+          }
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 2,
+                  "attributes" => [
+                    {
+                      "label" => "single_quote_string",
+                      "source" => "'string value'",
+                    },
+                    {
+                      "label" => "double_quote_string",
+                      "source" => '"string value"',
+                    },
+                    {
+                      "label" => "integer",
+                      "source" => "29",
+                    },
+                    {
+                      "label" => "complex_negative_number",
+                      "source" => "-29.29",
+                    },
+                  ],
+                },
+              },
+            },
+          }
+          assert_search(expected, request)
+        end
+
+        def test_expression
+          expected = {
+            "sections-result" => {
+              "records" => [
+                {
+                  "formatted title" => "<Groonga overview>",
+                  "title" => "Groonga overview",
+                },
+              ],
+            },
+          }
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 1,
+                  "attributes" => [
+                    "title",
+                    {
+                      "label" => "formatted title",
+                      "source" => "'<' + title + '>'",
+                    },
+                  ],
+                },
+              },
+            },
+          }
+          assert_search(expected, request)
+        end
+
+        def test_snippet_html
+          expected = {
+            "sections-result" => {
+              "records" => [
+                {
+                  "title" => "Groonga overview",
+                  "snippet" => [
+                    "<span class=\"keyword\">Groonga</span> overview",
+                  ],
+                },
+              ],
+            },
+          }
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "condition" => {
+                  "query" => "Groonga",
+                  "matchTo" => ["title"],
+                },
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 1,
+                  "attributes" => [
+                    "title",
+                    {
+                      "label" => "snippet",
+                      "source" => "snippet_html(title)",
+                    },
+                  ],
+                },
+              },
+            },
+          }
+          assert_search(expected, request)
+        end
+      end
+
+      class FormatTest < self
+        def test_complex
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "complex",
+                  "limit" => 3,
+                  "attributes" => ["_key", "title"],
+                },
+              },
+            },
+          }
+          assert_search(complex_result, request)
+        end
+
+        def test_simple
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "format" => "simple",
+                  "limit" => 3,
+                  "attributes" => ["_key", "title"],
+                },
+              },
+            },
+          }
+          assert_search(simple_result, request)
+        end
+
+        def test_default
+          request = {
+            "queries" => {
+              "sections-result" => {
+                "source" => "Sections",
+                "output" => {
+                  "elements" => [
+                    "records",
+                  ],
+                  "limit" => 3,
+                  "attributes" => ["_key", "title"],
+                },
+              },
+            },
+          }
+          assert_search(simple_result, request)
+        end
+
+        def complex_result
+          {
+            "sections-result" => {
+              "records" => [
+                {
+                  "_key" => "1.1",
+                  "title" => "Groonga overview",
+                },
+                {
+                  "_key" => "1.2",
+                  "title" => "Full text search and Instant update",
+                },
+                {
+                  "_key" => "1.3",
+                  "title" => "Column store and aggregate query",
+                },
+              ],
+            },
+          }
+        end
+
+        def simple_result
+          {
+            "sections-result" => {
+              "records" => [
+                ["1.1", "Groonga overview"],
+                ["1.2", "Full text search and Instant update"],
+                ["1.3", "Column store and aggregate query"],
+              ],
+            },
+          }
+        end
+      end
+    end
+  end
+
+  class ReferenceTest < self
+    class Hash
+      def setup
+        super
+        restore(fixture_data("reference/hash.grn"))
+        setup_plugin(Droonga::SearchHandler)
+      end
+
+      def test_reference_to_hash
+        expected = {
+          "sections-result" => {
+            "records" => [
+              {
+                "_key" => "1.1",
+                "document" => "Groonga",
+              },
+              {
+                "_key" => "1.2",
+                "document" => "Groonga",
+              },
+              {
+                "_key" => "1.3",
+                "document" => "Groonga",
+              },
+            ],
+          },
+        }
+        request = {
+          "queries" => {
+            "sections-result" => {
+              "source" => "SectionsForHash",
+              "output" => {
+                "elements" => [
+                  "records",
+                ],
+                "format" => "complex",
+                "limit" => 3,
+                "attributes" => ["_key", "document"],
+              },
+            },
+          },
+        }
+        assert_search(expected, request)
+      end
+    end
+
+    class Array
+      def setup
+        super
+        restore(fixture_data("reference/array.grn"))
+        setup_plugin(Droonga::SearchHandler)
+      end
+
+      def test_reference_to_array
+        expected = {
+          "sections-result" => {
+            "records" => [
+              {
+                "_key" => "1.1",
+                "document" => 1,
+              },
+              {
+                "_key" => "1.2",
+                "document" => 1,
+              },
+              {
+                "_key" => "1.3",
+                "document" => 1,
+              },
+            ],
+          },
+        }
+        request = {
+          "queries" => {
+            "sections-result" => {
+              "source" => "SectionsForArray",
+              "output" => {
+                "elements" => [
+                  "records",
+                ],
+                "format" => "complex",
+                "limit" => 3,
+                "attributes" => ["_key", "document"],
+              },
+            },
+          },
+        }
+        assert_search(expected, request)
+      end
+    end
+  end
+end