fluent-plugin-droonga 0.7.0 → 0.8.0

data/test/unit/plugin/handler/groonga/test_column_create.rb

@@ -15,9 +15,10 @@
 
 class ColumnCreateTest < GroongaHandlerTest
   def test_success
-    @plugin.table_create({"name" => "Books"})
-    @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
-    response = @messages.last.first
+    process(:table_create, {"name" => "Books"})
+    process(:column_create,
+            {"table" => "Books", "name" => "title", "type" => "ShortText"})
+    response = @messenger.values.last
     assert_equal(
       [[Droonga::GroongaHandler::Status::SUCCESS, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], true],
       [normalize_header(response.first), response.last]
@@ -25,8 +26,9 @@ class ColumnCreateTest < GroongaHandlerTest
   end
 
   def test_name
-    @plugin.table_create({"name" => "Books"})
-    @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
+    process(:table_create, {"name" => "Books"})
+    process(: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
@@ -34,8 +36,9 @@ column_create Books title COLUMN_SCALAR ShortText
   end
 
   def test_type
-    @plugin.table_create({"name" => "Books"})
-    @plugin.column_create({"table" => "Books", "name" => "main_text", "type" => "LongText"})
+    process(:table_create, {"name" => "Books"})
+    process(: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
@@ -59,8 +62,8 @@ column_create Books main_text COLUMN_SCALAR LongText
           "type"  => "ShortText",
           "flags" => data[:flags],
         }
-        @plugin.table_create({"name" => "Books"})
-        @plugin.column_create(request)
+        process(:table_create, {"name" => "Books"})
+        process(:column_create, request)
         assert_equal(<<-EXPECTED, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title #{data[:flags]} ShortText
@@ -71,8 +74,9 @@ column_create Books title #{data[:flags]} ShortText
     class IndexTest < self
       def setup
         super
-        @plugin.table_create({"name" => "Books"})
-        @plugin.column_create({"table" => "Books", "name" => "title", "type" => "ShortText"})
+        process(:table_create, {"name" => "Books"})
+        process(:column_create,
+                {"table" => "Books", "name" => "title", "type" => "ShortText"})
       end
 
       def test_index_column_type
@@ -86,7 +90,7 @@ column_create Books title #{data[:flags]} ShortText
           "source" => "title",
           "flags"  => data[:flags],
         }
-        @plugin.column_create(request)
+        process(:column_create, request)
         assert_equal(<<-EXPECTED, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
 column_create Books title COLUMN_SCALAR ShortText
@@ -118,7 +122,7 @@ column_create Books entry_title #{data[:flags]} Books title
           "source" => "title",
           "flags"  => flags,
         }
-        @plugin.column_create(request)
+        process(: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/unit/plugin/handler/groonga/test_table_create.rb

@@ -15,8 +15,8 @@
 
 class TableCreateTest < GroongaHandlerTest
   def test_success
-    @plugin.table_create({"name" => "Books"})
-    response = @messages.last.first
+    process(:table_create, {"name" => "Books"})
+    response = @messenger.values.last
     assert_equal(
       [[Droonga::GroongaHandler::Status::SUCCESS, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], true],
       [normalize_header(response.first), response.last]
@@ -24,8 +24,8 @@ class TableCreateTest < GroongaHandlerTest
   end
 
   def test_failure
-    @plugin.table_create({})
-    response = @messages.last.first
+    process(:table_create, {})
+    response = @messenger.values.last
     assert_equal(
       [[Droonga::GroongaHandler::Status::INVALID_ARGUMENT, NORMALIZED_START_TIME, NORMALIZED_ELAPSED_TIME], false],
       [normalize_header(response.first), response.last]
@@ -33,7 +33,7 @@ class TableCreateTest < GroongaHandlerTest
   end
 
   def test_name
-    @plugin.table_create({"name" => "Books"})
+    process(:table_create, {"name" => "Books"})
     assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText
     SCHEMA
@@ -83,7 +83,7 @@ table_create Books TABLE_NO_KEY
         "name" => "Books",
         "flags" => data[:flags],
       }
-      @plugin.table_create(request)
+      process(:table_create, request)
       assert_equal(data[:schema], dump)
     end
   end
@@ -94,7 +94,7 @@ table_create Books TABLE_NO_KEY
         "name"  => "Books",
         "key_type" => "Int32",
       }
-      @plugin.table_create(request)
+      process(:table_create, request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type Int32
       SCHEMA
@@ -107,7 +107,7 @@ table_create Books TABLE_HASH_KEY --key_type Int32
         "name"  => "Books",
         "value_type" => "Int32",
       }
-      @plugin.table_create(request)
+      process(:table_create, request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText --value_type Int32
       SCHEMA
@@ -120,7 +120,7 @@ table_create Books TABLE_HASH_KEY --key_type ShortText --value_type Int32
         "name"  => "Books",
         "default_tokenizer" => "TokenBigram",
       }
-      @plugin.table_create(request)
+      process(:table_create, request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenBigram
       SCHEMA
@@ -133,7 +133,7 @@ table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer Token
         "name"  => "Books",
         "normalizer" => "NormalizerAuto",
       }
-      @plugin.table_create(request)
+      process(:table_create, request)
       assert_equal(<<-SCHEMA, dump)
 table_create Books TABLE_HASH_KEY|KEY_NORMALIZE --key_type ShortText
       SCHEMA

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

@@ -16,6 +16,8 @@
 require "droonga/plugin/handler/add"
 
 class AddHandlerTest < Test::Unit::TestCase
+  SUCCESS_RESPONSE_BODY = true
+
   def setup
     setup_database
     setup_schema
@@ -34,12 +36,18 @@ class AddHandlerTest < Test::Unit::TestCase
   def setup_handler
     @worker = StubWorker.new
     @handler = Droonga::AddHandler.new(@worker)
+    @messenger = Droonga::Test::StubHandlerMessenger.new
   end
 
   def teardown_handler
     @handler = nil
   end
 
+  def process(request)
+    message = Droonga::Test::StubHandlerMessage.new(request)
+    @handler.add(message, @messenger)
+  end
+
   public
   class HasKeyTest < self
     def setup_schema
@@ -48,6 +56,8 @@ class AddHandlerTest < Test::Unit::TestCase
                             :type => :hash,
                             :key_type => :short_text) do |table|
           table.short_text("country")
+          table.int32("age")
+          table.time("birthday")
         end
       end
     end
@@ -58,8 +68,8 @@ class AddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {},
       }
-      mock(@handler).emit([true])
-      @handler.add(request)
+      process(request)
+      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
       table = @worker.context["Users"]
       assert_equal(["mori"], table.collect(&:key))
     end
@@ -67,14 +77,57 @@ class AddHandlerTest < Test::Unit::TestCase
     def test_values
       request = {
         "table"  => "Users",
-        "key"    => "asami",
+        "key"    => "mori",
         "values" => {"country" => "japan"},
       }
-      mock(@handler).emit([true])
-      @handler.add(request)
+      process(request)
+      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
       table = @worker.context["Users"]
       assert_equal(["japan"], table.collect(&:country))
     end
+
+    def test_missing_key_parameter
+      request = {
+        "table"  => "Users",
+        "values" => {"country" => "japan"},
+      }
+      assert_raise(Droonga::AddHandler::MissingPrimaryKeyParameter) do
+        process(request)
+      end
+    end
+
+    def test_invalid_integer_value
+      request = {
+        "table"  => "Users",
+        "key"    => "mori",
+        "values" => {"age" => "secret"},
+      }
+      assert_raise(Droonga::AddHandler::InvalidValue) do
+        process(request)
+      end
+    end
+
+    def test_invalid_time_value
+      request = {
+        "table"  => "Users",
+        "key"    => "mori",
+        "values" => {"birthday" => "today"},
+      }
+      assert_raise(Droonga::AddHandler::InvalidValue) do
+        process(request)
+      end
+    end
+
+    def test_unknown_column
+      request = {
+        "table"  => "Users",
+        "key"    => "mori",
+        "values" => {"unknown" => "unknown"},
+      }
+      assert_raise(Droonga::AddHandler::UnknownColumn) do
+        process(request)
+      end
+    end
   end
 
   class NoKeyTest < self
@@ -92,8 +145,8 @@ class AddHandlerTest < Test::Unit::TestCase
         "table"  => "Books",
         "values" => {},
       }
-      mock(@handler).emit([true])
-      @handler.add(request)
+      process(request)
+      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
       table = @worker.context["Books"]
       assert_equal([nil], table.collect(&:title))
     end
@@ -103,21 +156,31 @@ class AddHandlerTest < Test::Unit::TestCase
         "table"  => "Books",
         "values" => {"title" => "CSS"},
       }
-      mock(@handler).emit([true])
-      @handler.add(request)
+      process(request)
+      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
       table = @worker.context["Books"]
       assert_equal(["CSS"], table.collect(&:title))
     end
   end
 
   class FailureTest < self
+    def test_missing_table_parameter
+      request = {
+        "values" => {},
+      }
+      assert_raise(Droonga::AddHandler::MissingTableParameter) do
+        process(request)
+      end
+    end
+
     def test_nonexistent_table
       request = {
         "table"  => "Nonexistent",
         "values" => {},
       }
-      mock(@handler).emit([false])
-      @handler.add(request)
+      assert_raise(Droonga::AddHandler::UnknownTable) do
+        process(request)
+      end
     end
   end
 end

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

@@ -20,7 +20,7 @@ class GroongaHandlerTest < Test::Unit::TestCase
 
   def setup
     setup_database
-    setup_plugin(Droonga::GroongaHandler)
+    setup_plugin
   end
 
   def teardown
@@ -29,11 +29,25 @@ class GroongaHandlerTest < Test::Unit::TestCase
   end
 
   private
+  def setup_plugin
+    @handler = Droonga::Test::StubHandler.new
+    @plugin = Droonga::GroongaHandler.new(@handler)
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+  end
+
+  def teardown_plugin
+  end
+
   def dump
     database_dumper = Groonga::DatabaseDumper.new(:database => @database)
     database_dumper.dump
   end
 
+  def process(command, request)
+    message = Droonga::Test::StubHandlerMessage.new(request)
+    @plugin.send(command, message, @messenger)
+  end
+
   NORMALIZED_START_TIME = Time.parse("2013-07-11T16:04:28+0900").to_i
   NORMALIZED_ELAPSED_TIME = 1
   def normalize_header(header)

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

@@ -16,10 +16,10 @@
 require "droonga/plugin/handler/search"
 
 class SearchHandlerTest < Test::Unit::TestCase
-  include PluginHelper
-
   def setup
     setup_database
+    setup_data
+    setup_plugin
   end
 
   def teardown
@@ -27,16 +27,27 @@ class SearchHandlerTest < Test::Unit::TestCase
     teardown_database
   end
 
+  def setup_plugin
+    @handler = Droonga::Test::StubHandler.new
+    @plugin = Droonga::SearchHandler.new(@handler)
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+  end
+
+  def teardown_plugin
+    @handler = nil
+    @plugin = nil
+  end
+
   private
-  def search(request)
-    @plugin.search(request)
-    results_to_result_set(@messages)
+  def search(request, headers={})
+    message = Droonga::Test::StubHandlerMessage.new(request, headers)
+    @plugin.search(message, @messenger)
+    results_to_result_set(@messenger.values.first)
   end
 
   def results_to_result_set(results)
     result_set = {}
-    results.each do |result_and_name|
-      result, name = result_and_name
+    results.each do |name, result|
       result_set[name] = normalize_result(result)
     end
     result_set
@@ -61,10 +72,8 @@ class SearchHandlerTest < Test::Unit::TestCase
   end
 
   class GeneralTest < self
-    def setup
-      super
+    def setup_data
       restore(fixture_data("document.grn"))
-      setup_plugin(Droonga::SearchHandler)
     end
 
     class NoParameterTest < self
@@ -133,7 +142,7 @@ class SearchHandlerTest < Test::Unit::TestCase
 
     class SourceTest < self
       def test_non_existent
-        assert_raise(Droonga::Searcher::UndefinedSourceError) do
+        assert_raise(Droonga::Searcher::UnknownSource) do
           search({
                    "queries" => {
                      "non-existent-result" => {
@@ -157,6 +166,17 @@ class SearchHandlerTest < Test::Unit::TestCase
                         },
                       })
       end
+
+      def test_no_source
+        assert_raise(Droonga::Searcher::MissingSourceParameter) do
+          search({
+                   "queries" => {
+                     "no-source-result" => {
+                     },
+                   },
+                 })
+        end
+      end
     end
 
     class OutputTest < self
@@ -509,10 +529,8 @@ class SearchHandlerTest < Test::Unit::TestCase
 
   class ReferenceTest < self
     class Hash
-      def setup
-        super
+      def setup_data
         restore(fixture_data("reference/hash.grn"))
-        setup_plugin(Droonga::SearchHandler)
       end
 
       def test_reference_to_hash
@@ -554,10 +572,8 @@ class SearchHandlerTest < Test::Unit::TestCase
     end
 
     class Array
-      def setup
-        super
+      def setup_data
         restore(fixture_data("reference/array.grn"))
-        setup_plugin(Droonga::SearchHandler)
       end
 
       def test_reference_to_array

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

@@ -23,22 +23,28 @@ class WatchHandlerTest < Test::Unit::TestCase
   def setup
     setup_database
     setup_schema
-    setup_handler
+    setup_plugin
   end
 
   def teardown
-    teardown_handler
+    teardown_plugin
     teardown_database
   end
 
   private
-  def setup_handler
-    @worker = StubWorker.new
-    @handler = Droonga::WatchHandler.new(@worker)
+  def setup_plugin
+    @handler = Droonga::Test::StubHandler.new
+    @plugin = Droonga::WatchHandler.new(@handler)
+    @messenger = Droonga::Test::StubHandlerMessenger.new
   end
 
-  def teardown_handler
-    @handler = nil
+  def teardown_plugin
+    @plugin = nil
+  end
+
+  def process(command, request, headers={})
+    message = Droonga::Test::StubHandlerMessage.new(request, headers)
+    @plugin.send(command, message, @messenger)
   end
 
   public
@@ -49,8 +55,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      mock(@handler).emit([true])
-      @handler.subscribe(request)
+      process(:subscribe, request)
+      assert_equal([[true]], @messenger.values)
 
       assert_equal(
         ["localhost:23003/output"],
@@ -63,9 +69,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      @worker.envelope["from"] = "localhost:23004/output"
-      mock(@handler).emit([true])
-      @handler.subscribe(request)
+      process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal([[true]], @messenger.values)
 
       assert_equal(
         ["localhost:23004/output"],
@@ -79,9 +84,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "subscriber" => "localhost",
         "route" => "localhost:23003/output"
       }
-      @worker.envelope["from"] = "localhost:23004/output"
-      mock(@handler).emit([true])
-      @handler.subscribe(request)
+      process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal([[true]], @messenger.values)
 
       assert_equal(
         ["localhost:23003/output"],
@@ -91,7 +95,7 @@ class WatchHandlerTest < Test::Unit::TestCase
 
     private
     def actual_routes_for_query(query)
-      @worker.context["Subscriber"].select {|record|
+      @handler.context["Subscriber"].select {|record|
         record[:subscriptions] =~ query.to_json
       }.map {|subscriber|
         subscriber.route.key
@@ -111,8 +115,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      mock(@handler).emit([true])
-      @handler.unsubscribe(request)
+      process(:unsubscribe, request)
+      assert_equal([[true]], @messenger.values)
     end
 
     private
@@ -122,8 +126,9 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      stub(@handler).emit([true])
-      @handler.subscribe(request)
+      process(:subscribe, request)
+      assert_equal([[true]], @messenger.values)
+      @messenger.values.clear
     end
   end
 
@@ -139,9 +144,20 @@ class WatchHandlerTest < Test::Unit::TestCase
           "text" => "たいやきおいしいです"
         }
       }
-      @handler.feed(request)
-      assert_equal(request, @worker.body)
-      assert_equal({"to" => ["localhost"]}, @worker.envelope)
+      process(:feed, request)
+      assert_equal([
+                     [
+                       {
+                         "body" => request,
+                         "to" => ["localhost"],
+                       },
+                       {
+                         "to"   => "localhost:23003/output",
+                         "type" => "watch.notification",
+                       },
+                     ],
+                   ],
+                   @messenger.messages)
     end
 
     def test_feed_not_match
@@ -150,8 +166,8 @@ class WatchHandlerTest < Test::Unit::TestCase
           "text" => "たこやきおいしいです"
         }
       }
-      @handler.feed(request)
-      assert_nil(@worker.body)
+      process(:feed, request)
+      assert_equal([], @messenger.messages)
     end
 
     private
@@ -161,8 +177,8 @@ class WatchHandlerTest < Test::Unit::TestCase
         "condition" => "たいやき",
         "subscriber" => "localhost"
       }
-      stub(@handler).emit([true])
-      @handler.subscribe(request)
+      process(:subscribe, request)
+      assert_equal([[true]], @messenger.values)
     end
   end
 end