fluent-plugin-droonga 0.9.0 → 0.9.9

data/test/unit/plugin/{distributor → planner}/test_search.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 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,13 +13,13 @@
 # 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/distributor/search"
+require "droonga/plugin/planner/search"
 
-class SearchDistributorTest < Test::Unit::TestCase
+class SearchPlannerTest < Test::Unit::TestCase
   def setup
     setup_database
-    @distributor = Droonga::Test::StubDistributor.new
-    @plugin = Droonga::SearchDistributor.new(@distributor)
+    @planner = Droonga::Test::StubPlanner.new
+    @plugin = Droonga::SearchPlanner.new(@planner)
   end
 
   def teardown
@@ -52,27 +52,23 @@ class SearchDistributorTest < Test::Unit::TestCase
               "limit" => 20,
             },
           },
-          "query3" => {
-            "source" => "User",
-            "output" => {
-              "format" => "complex",
-              "elements" => ["count", "records"],
-              "attributes" => [],
-              "offset" => 0,
-              "limit" => 30,
-            },
-          },
         },
       },
     }
 
-    @plugin.process("search", envelope)
+    @planner.distribute(@plugin.process("search", envelope))
 
     message = []
 
     message << {
       "type" => "search_reduce",
       "body" => {
+        "errors" => {
+          "errors_reduced" => {
+            "limit" => -1,
+            "type"  => "sum",
+          },
+        },
         "query1" => {
           "query1_reduced" => {
             "count" => {
@@ -85,13 +81,6 @@ class SearchDistributorTest < Test::Unit::TestCase
             },
           },
         },
-      },
-      "inputs" => ["query1"],
-      "outputs" => ["query1_reduced"],
-    }
-    message << {
-      "type" => "search_reduce",
-      "body" => {
         "query2" => {
           "query2_reduced" => {
             "count" => {
@@ -105,41 +94,22 @@ class SearchDistributorTest < Test::Unit::TestCase
           },
         },
       },
-      "inputs" => ["query2"],
-      "outputs" => ["query2_reduced"],
-    }
-    message << {
-      "type" => "search_reduce",
-      "body" => {
-        "query3" => {
-          "query3_reduced" => {
-            "count" => {
-              "type" => "sum",
-            },
-            "records" => {
-              "type" => "sort",
-              "operators" => [],
-              "limit" => 30,
-            },
-          },
-        },
-      },
-      "inputs" => ["query3"],
-      "outputs" => ["query3_reduced"],
+      "inputs" => ["errors", "query1", "query2"],
+      "outputs" => ["errors_reduced", "query1_reduced", "query2_reduced"],
     }
 
     gatherer = {
       "type" => "search_gather",
       "body" => {
+        "errors_reduced" => {
+          "output" => "errors",
+        },
         "query1_reduced" => {
           "output" => "query1",
           "elements" => {
             "records" => {
-              "type" => "sort",
-              "offset" => 0,
               "limit" => 10,
               "format" => "complex",
-              "attributes" => [],
             },
           },
         },
@@ -147,31 +117,16 @@ class SearchDistributorTest < Test::Unit::TestCase
           "output" => "query2",
           "elements" => {
             "records" => {
-              "type" => "sort",
-              "offset" => 0,
               "limit" => 20,
               "format" => "complex",
-              "attributes" => [],
-            },
-          },
-        },
-        "query3_reduced" => {
-          "output" => "query3",
-          "elements" => {
-            "records" => {
-              "type" => "sort",
-              "offset" => 0,
-              "limit" => 30,
-              "format" => "complex",
-              "attributes" => [],
             },
           },
         },
       },
       "inputs" => [
+        "errors_reduced",
         "query1_reduced",
         "query2_reduced",
-        "query3_reduced",
       ],
       "post" => true,
     }
@@ -203,27 +158,17 @@ class SearchDistributorTest < Test::Unit::TestCase
               "limit" => 20,
             },
           },
-          "query3" => {
-            "source" => "User",
-            "output" => {
-              "format" => "simple",
-              "elements" => ["count", "records"],
-              "attributes" => [],
-              "offset" => 0,
-              "limit" => 30,
-            },
-          },
         },
       },
       "outputs" => [
+        "errors",
         "query1",
         "query2",
-        "query3",
       ],
       "replica" => "random",
     }
     message << searcher
 
-    assert_equal([message], @distributor.messages)
+    assert_equal([message], @planner.messages)
   end
 end

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

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 Droonga Project
+# Copyright (C) 2013-2014 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,9 +13,9 @@
 # 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/plugins/crud"
 
-class AddHandlerTest < Test::Unit::TestCase
+class CRUDAddHandlerTest < Test::Unit::TestCase
   SUCCESS_RESPONSE_BODY = {
     "success" => true,
   }
@@ -37,7 +37,7 @@ class AddHandlerTest < Test::Unit::TestCase
 
   def setup_handler
     @worker = StubWorker.new
-    @handler = Droonga::AddHandler.new(@worker)
+    @handler = Droonga::Plugins::CRUD::Handler.new("name", @worker.context)
     @messenger = Droonga::Test::StubHandlerMessenger.new
   end
 
@@ -47,7 +47,7 @@ class AddHandlerTest < Test::Unit::TestCase
 
   def process(request)
     message = Droonga::Test::StubHandlerMessage.new(request)
-    @handler.add(message, @messenger)
+    @handler.handle(message, @messenger)
   end
 
   public
@@ -93,7 +93,7 @@ class AddHandlerTest < Test::Unit::TestCase
         "table"  => "Users",
         "values" => {"country" => "japan"},
       }
-      assert_raise(Droonga::AddHandler::MissingPrimaryKeyParameter) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::MissingPrimaryKeyParameter) do
         process(request)
       end
     end
@@ -104,7 +104,7 @@ class AddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {"age" => "secret"},
       }
-      assert_raise(Droonga::AddHandler::InvalidValue) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::InvalidValue) do
         process(request)
       end
     end
@@ -115,7 +115,7 @@ class AddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {"birthday" => "today"},
       }
-      assert_raise(Droonga::AddHandler::InvalidValue) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::InvalidValue) do
         process(request)
       end
     end
@@ -126,7 +126,7 @@ class AddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {"unknown" => "unknown"},
       }
-      assert_raise(Droonga::AddHandler::UnknownColumn) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::UnknownColumn) do
         process(request)
       end
     end
@@ -170,7 +170,7 @@ class AddHandlerTest < Test::Unit::TestCase
       request = {
         "values" => {},
       }
-      assert_raise(Droonga::AddHandler::MissingTableParameter) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::MissingTableParameter) do
         process(request)
       end
     end
@@ -180,7 +180,7 @@ class AddHandlerTest < Test::Unit::TestCase
         "table"  => "Nonexistent",
         "values" => {},
       }
-      assert_raise(Droonga::AddHandler::UnknownTable) do
+      assert_raise(Droonga::Plugins::CRUD::Handler::UnknownTable) do
         process(request)
       end
     end

data/test/unit/plugins/groonga/select/test_adapter_input.rb

@@ -0,0 +1,213 @@
+# Copyright (C) 2013-2014 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/plugins/groonga/select"
+
+class GroongaSelectAdapterInputTest < Test::Unit::TestCase
+  private
+  def convert(select_request)
+    converter = Droonga::Plugins::Groonga::Select::RequestConverter.new
+    converter.convert(select_request)
+  end
+
+  class OutputColumnsTest < self
+    def assert_attributes(expected_attributes, output_columns)
+      select_request = {
+        "table" => "EmptyTable",
+        "output_columns" => output_columns,
+      }
+
+      expected_search_request = {
+        "queries" => {
+          "EmptyTable_result" => {
+            "source"   => "EmptyTable",
+            "output"   => {
+              "elements"   => [
+                "startTime",
+                "elapsedTime",
+                "count",
+                "attributes",
+                "records",
+              ],
+              "attributes" => expected_attributes,
+              "offset" => 0,
+              "limit" => 10,
+            },
+          },
+        },
+      }
+      assert_equal(expected_search_request, convert(select_request))
+    end
+
+    def test_multiple_columns
+      assert_attributes(["_id", "_key"], "_id,_key")
+    end
+
+    class FunctionTest < self
+      def test_single_argument
+        assert_attributes(["snippet_html(content)"], "snippet_html(content)")
+      end
+
+      def test_with_columns
+        assert_attributes(["_id","_key","snippet_html(content)"], "_id,_key,snippet_html(content)")
+      end
+    end
+  end
+
+  class MatchColumnsTest < self
+    def assert_matchTo(expected_matchTo, match_columns)
+      select_request = {
+        "table"          => "EmptyTable",
+        "match_columns"  => match_columns,
+        "query"          => "QueryTest",
+        "output_columns" => "_id",
+      }
+
+      expected_search_request = {
+        "queries" => {
+          "EmptyTable_result" => {
+            "source"   => "EmptyTable",
+            "condition"=> {
+              "query"  => "QueryTest",
+              "matchTo"=> expected_matchTo,
+              "defaultOperator"=> "&&",
+              "allowPragma"=> false,
+              "allowColumn"=> true,
+            },
+            "output"   => {
+              "elements"   => [
+                "startTime",
+                "elapsedTime",
+                "count",
+                "attributes",
+                "records",
+              ],
+              "attributes" => ["_id"],
+              "offset" => 0,
+              "limit" => 10,
+            },
+          },
+        },
+      }
+      assert_equal(expected_search_request, convert(select_request))
+    end
+
+    def test_single_column
+      assert_matchTo(["_key"], "_key")
+    end
+
+    def test_multiple_columns
+      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