fluent-plugin-droonga 0.9.9 → 1.0.0

data/test/unit/plugins/{test_search.rb → search/test_handler.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
@@ -29,8 +29,10 @@ class SearchHandlerTest < Test::Unit::TestCase
 
   def setup_plugin
     @handler = Droonga::Test::StubHandler.new
-    @plugin = Droonga::Plugins::Search::Handler.new("droonga", @handler.context)
     @messenger = Droonga::Test::StubHandlerMessenger.new
+    @plugin = Droonga::Plugins::Search::Handler.new("droonga",
+                                                    @handler.context,
+                                                    @messenger)
   end
 
   def teardown_plugin
@@ -41,8 +43,7 @@ class SearchHandlerTest < Test::Unit::TestCase
   private
   def search(request, headers={})
     message = Droonga::Test::StubHandlerMessage.new(request, headers)
-    @plugin.handle(message, @messenger)
-    results_to_result_set(@messenger.values.first)
+    results_to_result_set(@plugin.handle(message))
   end
 
   def results_to_result_set(results)
@@ -51,7 +52,7 @@ class SearchHandlerTest < Test::Unit::TestCase
       result_set[name] = normalize_result(result)
     end
     result_set
-  end
+   end
 
   def normalize_result(result)
     result["startTime"] = start_time if result["startTime"]

data/test/unit/{plugin/planner/test_search.rb → plugins/search/test_planner.rb}

@@ -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/planner/search"
+require "droonga/plugins/search"
 
 class SearchPlannerTest < Test::Unit::TestCase
   def setup
     setup_database
     @planner = Droonga::Test::StubPlanner.new
-    @plugin = Droonga::SearchPlanner.new(@planner)
+    @plugin = Droonga::Plugins::Search::Planner.new
   end
 
   def teardown
@@ -56,7 +56,7 @@ class SearchPlannerTest < Test::Unit::TestCase
       },
     }
 
-    @planner.distribute(@plugin.process("search", envelope))
+    @planner.distribute(@plugin.plan(envelope))
 
     message = []
 

data/test/unit/{plugin/collector → plugins}/test_basic.rb

@@ -13,16 +13,11 @@
 # 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"
+require "droonga/plugins/basic"
 
 class BasicCollectorTest < Test::Unit::TestCase
   def setup
     setup_database
-    @plugin = Droonga::BasicCollector.new
-    @outputs = []
-    stub(@plugin).emit do |name, value|
-      @outputs << [name, value]
-    end
   end
 
   def teardown
@@ -34,6 +29,22 @@ class BasicCollectorTest < Test::Unit::TestCase
     columns
   end
 
+  def run_collector(collector, message)
+    collector_message = Droonga::CollectorMessage.new(message)
+    collector.collect(collector_message)
+    collector_message.values
+  end
+
+  def gather(message)
+    collector = Droonga::Plugins::Basic::GatherCollector.new
+    run_collector(collector, message)
+  end
+
+  def reduce(message)
+    collector = Droonga::Plugins::Basic::ReduceCollector.new
+    run_collector(collector, message)
+  end
+
   class << self
     def create_record(*columns)
       columns
@@ -43,12 +54,12 @@ class BasicCollectorTest < Test::Unit::TestCase
   class IOTest < self
     data(
       :simple_mapping => {
-        :expected => ["output_name", "result"],
+        :expected => { "output_name" => "result" },
         :source => "result",
         :mapping => "output_name",
       },
       :complex_mapping => {
-        :expected => ["output_name", "result"],
+        :expected => { "output_name" => "result" },
         :source => "result",
         :mapping => {
           "output" => "output_name",
@@ -58,7 +69,7 @@ class BasicCollectorTest < Test::Unit::TestCase
     def test_gather(data)
       request = {
         "task" => {
-          "values" => nil,
+          "values" => {},
           "step" => {
             "body" => nil,
             "outputs" => nil,
@@ -69,8 +80,7 @@ class BasicCollectorTest < Test::Unit::TestCase
         "name" => data[:mapping],
         "descendants" => nil,
       }
-      @plugin.process("collector_gather", request)
-      assert_equal(data[:expected], @outputs.last)
+      assert_equal(data[:expected], gather(request))
     end
 
     def test_reduce
@@ -98,16 +108,18 @@ class BasicCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_reduce", request)
-      assert_equal([
-                     output_name,
-                     [0, 1, 2, 3, 4, 5],
-                   ],
-                   @outputs.last)
+      assert_equal({ output_name => [0, 1, 2, 3, 4, 5] },
+                   reduce(request))
     end
   end
 
-  class ReduceTest < self
+  # TODO: Split file
+  class ReducerTest < self
+    def reduce_value(deal, left_value, right_value)
+      reducer = Droonga::Reducer.new(deal)
+      reducer.reduce(left_value, right_value)
+    end
+
     data(
       :int => {
         :expected => 1.5,
@@ -121,9 +133,9 @@ class BasicCollectorTest < Test::Unit::TestCase
       },
     )
     def test_average(data)
-      reduced = @plugin.reduce({ "type" => "average" },
-                               data[:left],
-                               data[:right])
+      reduced = reduce_value({ "type" => "average" },
+                             data[:left],
+                             data[:right])
       assert_equal(data[:expected], reduced)
     end
 
@@ -150,9 +162,9 @@ class BasicCollectorTest < Test::Unit::TestCase
       },
     )
     def test_and(data)
-      reduced = @plugin.reduce({ "type" => "and" },
-                               data[:left],
-                               data[:right])
+      reduced = reduce_value({ "type" => "and" },
+                             data[:left],
+                             data[:right])
       assert_equal(data[:expected], reduced)
     end
 
@@ -179,9 +191,9 @@ class BasicCollectorTest < Test::Unit::TestCase
       },
     )
     def test_or(data)
-      reduced = @plugin.reduce({ "type" => "or" },
-                               data[:left],
-                               data[:right])
+      reduced = reduce_value({ "type" => "or" },
+                             data[:left],
+                             data[:right])
       assert_equal(data[:expected], reduced)
     end
 
@@ -273,10 +285,10 @@ class BasicCollectorTest < Test::Unit::TestCase
       },
     )
     def test_sum(data)
-      reduced = @plugin.reduce({ "type" => "sum",
-                                 "limit" => data[:limit] || -1 },
-                               data[:left],
-                               data[:right])
+      reduced = reduce_value({ "type" => "sum",
+                               "limit" => data[:limit] || -1 },
+                             data[:left],
+                             data[:right])
       assert_equal(data[:expected], reduced)
     end
 
@@ -357,20 +369,26 @@ class BasicCollectorTest < Test::Unit::TestCase
       },
     )
     def test_sort(data)
-      reduced = @plugin.reduce({ 
-                                 "type" => "sort",
-                                 "operators" => [
-                                   { "column" => 0, "operator" => "<" },
-                                 ],
-                                 "limit" => data[:limit] || -1,
-                               },
-                               data[:left],
-                               data[:right])
+      reduced = reduce_value({
+                               "type" => "sort",
+                               "operators" => [
+                                 { "column" => 0, "operator" => "<" },
+                               ],
+                               "limit" => data[:limit] || -1,
+                             },
+                             data[:left],
+                             data[:right])
       assert_equal(data[:expected], reduced)
     end
   end
 
+  # TODO: Split file
   class MergeTest < self
+    def reduce_value(deal, left_value, right_value)
+      reducer = Droonga::Reducer.new(deal)
+      reducer.reduce(left_value, right_value)
+    end
+
     def test_grouped
       expected = [
         [
@@ -476,16 +494,16 @@ class BasicCollectorTest < Test::Unit::TestCase
         ],
       ]
 
-      reduced = @plugin.reduce({ 
-                                 "type" => "sort",
-                                 "operators" => [
-                                   { "column" => 1, "operator" => "<" },
-                                 ],
-                                 "key_column" => 0,
-                                 "limit" => -1,
-                               },
-                               left,
-                               right)
+      reduced = reduce_value({
+                               "type" => "sort",
+                               "operators" => [
+                                 { "column" => 1, "operator" => "<" },
+                               ],
+                               "key_column" => 0,
+                               "limit" => -1,
+                             },
+                             left,
+                             right)
       assert_equal(expected, reduced)
     end
   end

data/test/unit/plugins/test_groonga.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
@@ -45,7 +45,7 @@ class GroongaHandlerTest < Test::Unit::TestCase
   def process(command, request)
     message = Droonga::Test::StubHandlerMessage.new(request)
     handler = create_handler
-    handler.handle(message, @messenger)
+    handler.handle(message)
   end
 
   NORMALIZED_START_TIME = Time.parse("2013-07-11T16:04:28+0900").to_i
@@ -66,17 +66,4 @@ class GroongaHandlerTest < Test::Unit::TestCase
     NORMALIZED_START_TIME,
     NORMALIZED_ELAPSED_TIME,
   ]
-
-  def assert_valid_output(output)
-    expected = {
-      "result" => [],
-    }
-    normalized_output = Marshal.load(Marshal.dump(output))
-    normalized_output.each do |key, value|
-      if value.is_a?(Array)
-        normalized_output[key] = []
-      end
-    end
-    assert_equal(expected, normalized_output)
-  end
 end

data/test/unit/plugins/test_watch.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# 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
@@ -20,7 +20,7 @@ require "droonga/plugins/watch"
 class WatchHandlerTest < Test::Unit::TestCase
   include WatchHelper
 
-  SUCCESS_RESULT = { "success" => true }
+  SUCCESS_RESULT = true
 
   def setup
     setup_database
@@ -45,13 +45,15 @@ class WatchHandlerTest < Test::Unit::TestCase
 
   def process(command, request, headers={})
     message = Droonga::Test::StubHandlerMessage.new(request, headers)
-    create_plugin.handle(message, @messenger)
+    create_plugin.handle(message)
   end
 
   public
   class SubscribeTest < self
     def create_plugin
-      Droonga::Plugins::Watch::SubscribeHandler.new("droonga", @handler.context)
+      Droonga::Plugins::Watch::SubscribeHandler.new("droonga",
+                                                    @handler.context,
+                                                    @messenger)
     end
 
     def test_subscribe
@@ -60,8 +62,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      process(:subscribe, request)
-      assert_equal([SUCCESS_RESULT], @messenger.values)
+      response = process(:subscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
 
       assert_equal(
         ["localhost:23003/output"],
@@ -74,8 +76,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      process(:subscribe, request, "from" => "localhost:23004/output")
-      assert_equal([SUCCESS_RESULT], @messenger.values)
+      response = process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal(SUCCESS_RESULT, response)
 
       assert_equal(
         ["localhost:23004/output"],
@@ -89,8 +91,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "subscriber" => "localhost",
         "route" => "localhost:23003/output"
       }
-      process(:subscribe, request, "from" => "localhost:23004/output")
-      assert_equal([SUCCESS_RESULT], @messenger.values)
+      response = process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal(SUCCESS_RESULT, response)
 
       assert_equal(
         ["localhost:23003/output"],
@@ -116,7 +118,8 @@ class WatchHandlerTest < Test::Unit::TestCase
 
     def create_plugin
       Droonga::Plugins::Watch::UnsubscribeHandler.new("droonga",
-                                                      @handler.context)
+                                                      @handler.context,
+                                                      @messenger)
     end
 
     def test_unsubscribe
@@ -125,8 +128,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      process(:unsubscribe, request)
-      assert_equal([SUCCESS_RESULT], @messenger.values)
+      response = process(:unsubscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
     end
 
     private
@@ -136,9 +139,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      process(:subscribe, request)
-      assert_equal([SUCCESS_RESULT], @messenger.values)
-      @messenger.values.clear
+      response = process(:subscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
     end
   end
 
@@ -150,7 +152,8 @@ class WatchHandlerTest < Test::Unit::TestCase
 
     def create_plugin
       Droonga::Plugins::Watch::FeedHandler.new("droonga",
-                                               @handler.context)
+                                               @handler.context,
+                                               @messenger)
     end
 
     def test_feed_match
@@ -181,8 +184,7 @@ class WatchHandlerTest < Test::Unit::TestCase
           "text" => "たこやきおいしいです"
         }
       }
-      process(:feed, request)
-      assert_equal([], @messenger.messages)
+      assert_nil(process(:feed, request))
     end
 
     private
@@ -195,9 +197,10 @@ class WatchHandlerTest < Test::Unit::TestCase
       message = Droonga::Test::StubHandlerMessage.new(request, {})
       subscribe_handler =
         Droonga::Plugins::Watch::SubscribeHandler.new("droonga",
-                                                      @handler.context)
-      subscribe_handler.handle(message, @messenger)
-      assert_equal([SUCCESS_RESULT], @messenger.values)
+                                                      @handler.context,
+                                                      @messenger)
+      response = subscribe_handler.handle(message)
+      assert_equal(SUCCESS_RESULT, response)
     end
   end
 end

data/test/unit/test_message_matcher.rb

@@ -90,26 +90,26 @@ class MessageMatcherTest < Test::Unit::TestCase
 
     class IncludeTest < self
       def test_exist
-        assert_true(match?(["originalTypes", :include?, "select"],
+        assert_true(match?(["originalTypes", :include, "select"],
                            {
                              "originalTypes" => ["search", "select"],
                            }))
       end
 
       def test_not_exist
-        assert_false(match?(["originalTypes", :include?, "select"],
+        assert_false(match?(["originalTypes", :include, "select"],
                             {
                               "originalTypes" => ["load"],
                             }))
       end
 
       def test_no_key
-        assert_false(match?(["originalTypes", :include?, "select"],
+        assert_false(match?(["originalTypes", :include, "select"],
                             {}))
       end
 
       def test_not_enumerable
-        assert_false(match?(["originalTypes", :include?, "select"],
+        assert_false(match?(["originalTypes", :include, "select"],
                             {
                               "originalTypes" => 29,
                             }))
@@ -118,7 +118,7 @@ class MessageMatcherTest < Test::Unit::TestCase
 
     class ExistTest < self
       def test_exist
-        assert_true(match?(["body.result", :exist?],
+        assert_true(match?(["body.result", :exist],
                            {
                              "body" => {
                                "result" => nil,
@@ -127,11 +127,34 @@ class MessageMatcherTest < Test::Unit::TestCase
       end
 
       def test_not_exist
-        assert_false(match?(["body.result", :exist?],
+        assert_false(match?(["body.result", :exist],
                             {
                               "body" => nil,
                             }))
       end
     end
+
+    class StartWithTest < self
+      def test_start_with
+        assert_true(match?(["type", :start_with, "watch."],
+                           {
+                             "type" => "watch.subscribe",
+                           }))
+      end
+
+      def test_not_start_with
+        assert_false(match?(["type", :start_with, "watch."],
+                            {
+                              "type" => "table_create",
+                            }))
+      end
+
+      def test_nil_value
+        assert_false(match?(["type", :start_with, "watch."],
+                            {
+                              "type" => nil,
+                            }))
+      end
+    end
   end
 end