fluent-plugin-droonga 0.0.2 → 0.7.0

data/test/{helper → unit/helper}/fixture.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

data/test/unit/helper/plugin_helper.rb

@@ -0,0 +1,38 @@
+# 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
+
+module PluginHelper
+  def setup_plugin(plugin_class)
+    @worker = StubWorker.new
+    @plugin = plugin_class.new(@worker)
+
+    @messages = []
+    stub(@plugin).emit do |*message|
+      @messages << message
+    end
+
+    @posted = []
+    stub(@plugin).post do |*message|
+      @posted << message
+    end
+  end
+
+  def teardown_plugin
+    @plugin = nil
+    @worker = nil
+    @messages = nil
+    @posted = nil
+  end
+end

data/test/{helper → unit/helper}/sandbox.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
@@ -51,12 +51,25 @@ module Sandbox
     Groonga::Context.default_options = nil
   end
 
+  def setup_database
+    @database = Groonga::Database.create(:path => @database_path.to_s)
+  end
+
+  def teardown_database
+    @database.close
+    @database = nil
+  end
+
   def restore(dumped_command)
-    context = Groonga::Context.new
-    database = context.create_database(@database_path.to_s)
-    context.restore(dumped_command)
-    database.close
-    context.close
+    if @database
+      Groonga::Context.default.restore(dumped_command)
+    else
+      context = Groonga::Context.new
+      database = context.create_database(@database_path.to_s)
+      context.restore(dumped_command)
+      database.close
+      context.close
+    end
   end
 
   def teardown_sandbox

data/test/{helper → unit/helper}/stub_worker.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

data/test/{helper → unit/helper}/watch_helper.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
@@ -16,20 +16,8 @@
 require "droonga/watch_schema"
 
 module WatchHelper
-  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
     schema = Droonga::WatchSchema.new(Groonga::Context.default)
     schema.ensure_created
   end
-
-  def teardown_database
-    @database.close
-    @database = nil
-    FileUtils.rm_rf(@database_path.dirname.to_s)
-  end
 end

data/test/{plugin → unit/plugin}/adapter/groonga/test_select.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
@@ -29,7 +29,7 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
 
       expected_search_request = {
         "queries" => {
-          "EmptyTable" => {
+          "EmptyTable_result" => {
             "source"   => "EmptyTable",
             "output"   => {
               "elements"   => [
@@ -40,6 +40,8 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
                 "records",
               ],
               "attributes" => ["_id"],
+              "offset" => 0,
+              "limit" => 10,
             },
           },
         },
@@ -62,7 +64,7 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
 
         expected_search_request = {
           "queries" => {
-            "EmptyTable" => {
+            "EmptyTable_result" => {
               "source"   => "EmptyTable",
               "output"   => {
                 "elements"   => [
@@ -73,6 +75,8 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
                   "records",
                 ],
                 "attributes" => expected_attributes,
+                "offset" => 0,
+                "limit" => 10,
               },
             },
           },
@@ -106,7 +110,7 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
 
         expected_search_request = {
           "queries" => {
-            "EmptyTable" => {
+            "EmptyTable_result" => {
               "source"   => "EmptyTable",
               "condition"=> {
                 "query"  => "QueryTest",
@@ -124,6 +128,8 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
                   "records",
                 ],
                 "attributes" => ["_id"],
+                "offset" => 0,
+                "limit" => 10,
               },
             },
           },
@@ -139,6 +145,104 @@ class AdapterGroongaSelectTest < Test::Unit::TestCase
         assert_matchTo(["_key", "content"], "_key || content")
       end
     end
+
+    class OffsetTest < self
+      def assert_offset(expected_offset, offset)
+        select_request = {
+          "table"          => "EmptyTable",
+          "output_columns" => "_id",
+        }
+        select_request["offset"] = offset unless offset.nil?
+
+        expected_search_request = {
+          "queries" => {
+            "EmptyTable_result" => {
+              "source"   => "EmptyTable",
+              "output"   => {
+                "elements"   => [
+                  "startTime",
+                  "elapsedTime",
+                  "count",
+                  "attributes",
+                  "records",
+                ],
+                "attributes" => ["_id"],
+                "offset" => expected_offset,
+                "limit" => 10,
+              },
+            },
+          },
+        }
+        assert_equal(expected_search_request, convert(select_request))
+      end
+
+      def test_zero
+        assert_offset(0, "0")
+      end
+
+      def test_large
+        assert_offset(100, "100")
+      end
+
+      def test_integer
+        assert_offset(100, 100)
+      end
+
+      def test_default
+        assert_offset(0, nil)
+      end
+    end
+
+    class LimitTest < self
+      def assert_limit(expected_limit, limit)
+        select_request = {
+          "table"          => "EmptyTable",
+          "output_columns" => "_id",
+        }
+        select_request["limit"] = limit unless limit.nil?
+
+        expected_search_request = {
+          "queries" => {
+            "EmptyTable_result" => {
+              "source"   => "EmptyTable",
+              "output"   => {
+                "elements"   => [
+                  "startTime",
+                  "elapsedTime",
+                  "count",
+                  "attributes",
+                  "records",
+                ],
+                "attributes" => ["_id"],
+                "offset" => 0,
+                "limit" => expected_limit,
+              },
+            },
+          },
+        }
+        assert_equal(expected_search_request, convert(select_request))
+      end
+
+      def test_zero
+        assert_limit(0, "0")
+      end
+
+      def test_large
+        assert_limit(100, "100")
+      end
+
+      def test_negative
+        assert_limit(-1, "-1")
+      end
+
+      def test_integer
+        assert_limit(100, 100)
+      end
+
+      def test_default
+        assert_limit(10, nil)
+      end
+    end
   end
 
   class ResponseTest < self

data/test/unit/plugin/collector/test_basic.rb

@@ -0,0 +1,558 @@
+# 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/collector/basic"
+
+class BasicCollectorTest < Test::Unit::TestCase
+  include PluginHelper
+
+  def setup
+    setup_database
+    setup_plugin(Droonga::BasicCollector)
+  end
+
+  def teardown
+    teardown_plugin
+    teardown_database
+  end
+
+  private
+  def create_record(*columns)
+    columns
+  end
+
+  class << self
+    def create_record(*columns)
+      columns
+    end
+  end
+
+  class GatherTest < self
+    data(
+      :simple_mapping => {
+        :expected => "result",
+        :source => "result",
+        :mapping => "string_name",
+      },
+      :complex_mapping => {
+        :expected => {
+          "count" => 3,
+          "records" => [
+            create_record(0),
+            create_record(1),
+            create_record(2),
+          ],
+        },
+        :source => {
+          "count" => 3,
+          "records" => [
+            create_record(0),
+            create_record(1),
+            create_record(2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+        },
+      },
+      :offset_and_limit => {
+        :expected => {
+          "count" => 3,
+          "records" => [
+            create_record(1),
+          ],
+        },
+        :source => {
+          "count" => 3,
+          "records" => [
+            create_record(0),
+            create_record(1),
+            create_record(2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "offset" => 1,
+          "limit" => 1,
+        },
+      },
+      :offset_and_unlimited_limit => {
+        :expected => {
+          "count" => 3,
+          "records" => [
+            create_record(1),
+            create_record(2),
+          ],
+        },
+        :source => {
+          "count" => 3,
+          "records" => [
+            create_record(0),
+            create_record(1),
+            create_record(2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "offset" => 1,
+          "limit" => -1,
+        },
+      },
+      :attributes => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2, 1.3, 1.4),
+            create_record(2, 2.1, 2.2, 2.3, 2.4),
+          ],
+        },
+        :source => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2, 1.3, 1.4),
+            create_record(2, 2.1, 2.2, 2.3, 2.4),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "attributes" => ["_key", "chapter", "section", "subsection", "paragraph"],
+          "limit" => -1,
+        },
+      },
+      :attributes_with_sort_attributes => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2),
+            create_record(2, 2.1, 2.2),
+          ],
+        },
+        :source => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2, 1.3, 1.4),
+            create_record(2, 2.1, 2.2, 2.3, 2.4),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "attributes" => ["_key", "chapter", "section"],
+          "limit" => -1,
+        },
+      },
+      :format_simple => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2),
+            create_record(2, 2.1, 2.2),
+          ],
+        },
+        :source => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2),
+            create_record(2, 2.1, 2.2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "format" => "simple",
+          "attributes" => ["_key", "chapter", "section"],
+          "limit" => -1,
+        },
+      },
+      :format_complex => {
+        :expected => {
+          "count" => 2,
+          "records" => [
+            { "_key" => 1, "chapter" => 1.1, "section" => 1.2 },
+            { "_key" => 2, "chapter" => 2.1, "section" => 2.2 },
+          ],
+        },
+        :source => {
+          "count" => 2,
+          "records" => [
+            create_record(1, 1.1, 1.2),
+            create_record(2, 2.1, 2.2),
+          ],
+        },
+        :mapping => {
+          "output" => "search_result",
+          "element" => "records",
+          "format" => "complex",
+          "attributes" => ["_key", "chapter", "section"],
+          "limit" => -1,
+        },
+      },
+    )
+    def test_gather(data)
+      request = {
+        "task" => {
+          "values" => nil,
+          "component" => {
+            "body" => nil,
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => data[:source],
+        "name" => data[:mapping],
+        "descendants" => nil,
+      }
+      @plugin.process("collector_gather", request)
+      output_name = data[:mapping]
+      output_name = output_name["output"] if output_name.is_a?(Hash)
+      assert_equal([data[:expected], output_name], @messages.last)
+    end
+  end
+
+  class ReduceTest < self
+    def test_sum
+      input_name = "input_#{Time.now.to_i}"
+      output_name = "output_#{Time.now.to_i}"
+      request = {
+        "task" => {
+          "values" => {
+            output_name => {
+              "numeric_value" => 1,
+              "numeric_key_records" => [
+                create_record(1),
+                create_record(2),
+                create_record(3),
+              ],
+              "string_key_records" => [
+                create_record("a"),
+                create_record("b"),
+                create_record("c"),
+              ],
+            },
+          },
+          "component" => {
+            "body" => {
+              input_name => {
+                output_name => {
+                  "numeric_value" => {
+                    "type" => "sum",
+                    "limit" => -1,
+                  },
+                  "numeric_key_records" => {
+                    "type" => "sum",
+                    "limit" => -1,
+                  },
+                  "string_key_records" => {
+                    "type" => "sum",
+                    "limit" => -1,
+                  },
+                },
+              },
+            },
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => {
+          "numeric_value" => 2,
+          "numeric_key_records" => [
+            create_record(4),
+            create_record(5),
+            create_record(6),
+          ],
+          "string_key_records" => [
+            create_record("d"),
+            create_record("e"),
+            create_record("f"),
+          ],
+        },
+        "name" => input_name,
+        "descendants" => nil,
+      }
+      @plugin.process("collector_reduce", request)
+      assert_equal([
+                     {
+                       "numeric_value" => 3,
+                       "numeric_key_records" => [
+                         create_record(1),
+                         create_record(2),
+                         create_record(3),
+                         create_record(4),
+                         create_record(5),
+                         create_record(6),
+                       ],
+                       "string_key_records" => [
+                         create_record("a"),
+                         create_record("b"),
+                         create_record("c"),
+                         create_record("d"),
+                         create_record("e"),
+                         create_record("f"),
+                       ],
+                     },
+                     output_name
+                   ],
+                   @messages.last)
+    end
+
+    def test_sum_with_limit
+      input_name = "input_#{Time.now.to_i}"
+      output_name = "output_#{Time.now.to_i}"
+      request = {
+        "task" => {
+          "values" => {
+            output_name => {
+              "numeric_value" => 1,
+              "numeric_key_records" => [
+                create_record(1),
+                create_record(2),
+                create_record(3),
+              ],
+              "string_key_records" => [
+                create_record("a"),
+                create_record("b"),
+                create_record("c"),
+              ],
+            },
+          },
+          "component" => {
+            "body" => {
+              input_name => {
+                output_name => {
+                  "numeric_value" => {
+                    "type" => "sum",
+                    "limit" => 2,
+                  },
+                  "numeric_key_records" => {
+                    "type" => "sum",
+                    "limit" => 2,
+                  },
+                  "string_key_records" => {
+                    "type" => "sum",
+                    "limit" => -1,
+                  },
+                },
+              },
+            },
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => {
+          "numeric_value" => 2,
+          "numeric_key_records" => [
+            create_record(4),
+            create_record(5),
+            create_record(6),
+          ],
+          "string_key_records" => [
+            create_record("d"),
+            create_record("e"),
+            create_record("f"),
+          ],
+        },
+        "name" => input_name,
+        "descendants" => nil,
+      }
+      @plugin.process("collector_reduce", request)
+      assert_equal([
+                     {
+                       "numeric_value" => 3,
+                       "numeric_key_records" => [
+                         create_record(1),
+                         create_record(2),
+                       ],
+                       "string_key_records" => [
+                         create_record("a"),
+                         create_record("b"),
+                         create_record("c"),
+                         create_record("d"),
+                         create_record("e"),
+                         create_record("f"),
+                       ],
+                     },
+                     output_name
+                   ],
+                   @messages.last)
+    end
+
+    def test_sort
+      input_name = "input_#{Time.now.to_i}"
+      output_name = "output_#{Time.now.to_i}"
+      request = {
+        "task" => {
+          "values" => {
+            output_name => {
+              "numeric_key_records" => [
+                create_record(1),
+                create_record(3),
+                create_record(5),
+              ],
+              "string_key_records" => [
+                create_record("a"),
+                create_record("c"),
+                create_record("e"),
+              ],
+            },
+          },
+          "component" => {
+            "body" => {
+              input_name => {
+                output_name => {
+                  "numeric_key_records" => {
+                    "type" => "sort",
+                    "operators" => [
+                      { "column" => 0, "operator" => "<" },
+                    ],
+                    "limit" => -1,
+                  },
+                  "string_key_records" => {
+                    "type" => "sort",
+                    "operators" => [
+                      { "column" => 0, "operator" => "<" },
+                    ],
+                    "limit" => -1,
+                  },
+                },
+              },
+            },
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => {
+          "numeric_key_records" => [
+            create_record(2),
+            create_record(4),
+            create_record(6),
+          ],
+          "string_key_records" => [
+            create_record("b"),
+            create_record("d"),
+            create_record("f"),
+          ],
+        },
+        "name" => input_name,
+        "descendants" => nil,
+      }
+      @plugin.process("collector_reduce", request)
+      assert_equal([
+                     {
+                       "numeric_key_records" => [
+                         create_record(1),
+                         create_record(2),
+                         create_record(3),
+                         create_record(4),
+                         create_record(5),
+                         create_record(6),
+                       ],
+                       "string_key_records" => [
+                         create_record("a"),
+                         create_record("b"),
+                         create_record("c"),
+                         create_record("d"),
+                         create_record("e"),
+                         create_record("f"),
+                       ],
+                     },
+                     output_name
+                   ],
+                   @messages.last)
+    end
+
+    def test_sort_with_limit
+      input_name = "input_#{Time.now.to_i}"
+      output_name = "output_#{Time.now.to_i}"
+      request = {
+        "task" => {
+          "values" => {
+            output_name => {
+              "numeric_key_records" => [
+                create_record(1),
+                create_record(3),
+                create_record(5),
+              ],
+              "string_key_records" => [
+                create_record("a"),
+                create_record("c"),
+                create_record("e"),
+              ],
+            },
+          },
+          "component" => {
+            "body" => {
+              input_name => {
+                output_name => {
+                  "numeric_key_records" => {
+                    "type" => "sort",
+                    "operators" => [
+                      { "column" => 0, "operator" => "<" },
+                    ],
+                    "limit" => 2,
+                  },
+                  "string_key_records" => {
+                    "type" => "sort",
+                    "operators" => [
+                      { "column" => 0, "operator" => "<" },
+                    ],
+                    "limit" => -1,
+                  },
+                },
+              },
+            },
+            "outputs" => nil,
+          },
+        },
+        "id" => nil,
+        "value" => {
+          "numeric_key_records" => [
+            create_record(2),
+            create_record(4),
+            create_record(6),
+          ],
+          "string_key_records" => [
+            create_record("b"),
+            create_record("d"),
+            create_record("f"),
+          ],
+        },
+        "name" => input_name,
+        "descendants" => nil,
+      }
+      @plugin.process("collector_reduce", request)
+      assert_equal([
+                     {
+                       "numeric_key_records" => [
+                         create_record(1),
+                         create_record(2),
+                       ],
+                       "string_key_records" => [
+                         create_record("a"),
+                         create_record("b"),
+                         create_record("c"),
+                         create_record("d"),
+                         create_record("e"),
+                         create_record("f"),
+                       ],
+                     },
+                     output_name
+                   ],
+                   @messages.last)
+    end
+  end
+end