fluent-plugin-droonga 0.9.9 → 1.0.0

data/test/unit/catalog/test_version2.rb

@@ -0,0 +1,155 @@
+# 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/catalog/version2"
+
+class CatalogTestVersion2 < Test::Unit::TestCase
+  class << self
+    def minimum_data
+      {
+        "effectiveDate" => "2014-02-28T00:00:00Z",
+        "datasets" => {
+        },
+      }
+    end
+  end
+
+  private
+  def minimum_data
+    self.class.minimum_data
+  end
+
+  def create_catalog(data, path)
+    Droonga::Catalog::Version2.new(data, path)
+  end
+
+  class SliceTest < self
+    def setup
+      data = JSON.parse(File.read(catalog_path))
+      @catalog = create_catalog(data, catalog_path)
+    end
+
+    def test_slices
+      slices = @catalog.slices("localhost:23003/test")
+      assert_equal({
+                     "localhost:23003/test.000" => {
+                       :database  => "#{base_path}/000/db",
+                       :dataset   => "Test",
+                       :plugins   => ["plugin1", "plugin2", "plugin3"],
+                       :n_workers => 4,
+                     },
+                     "localhost:23003/test.001" => {
+                       :database  => "#{base_path}/001/db",
+                       :dataset   => "Test",
+                       :plugins   => ["plugin1", "plugin2", "plugin3"],
+                       :n_workers => 4,
+                     },
+                     "localhost:23003/test.002" => {
+                       :database  => "#{base_path}/002/db",
+                       :dataset   => "Test",
+                       :plugins   => ["plugin1", "plugin2", "plugin3"],
+                       :n_workers => 4,
+                     },
+                   },
+                   slices)
+    end
+
+    def fixture_path(base_path)
+      File.expand_path("../../fixtures/#{base_path}", __FILE__)
+    end
+
+    def catalog_path
+      @catalog_path ||= fixture_path("catalog/version2.json")
+    end
+
+    def base_path
+      File.dirname(catalog_path)
+    end
+
+    class PluginsTest < self
+      def setup
+        custom_data = {
+          "datasets" => {
+            "Droonga" => {
+              "nWorkers" => 1,
+              "replicas" => [
+                {
+                  "slices" => [
+                    {
+                      "volume" => {
+                        "address" => "#{farm_name}.000",
+                      },
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+
+        }
+        @data = minimum_data.merge(custom_data)
+      end
+
+      def farm_name
+        "localhost:23041/droonga"
+      end
+
+      def plugins(data)
+        catalog = create_catalog(data, catalog_path)
+        catalog.slices(farm_name).collect do |volum_address, options|
+          options[:plugins]
+        end
+      end
+
+      def test_plugins
+        @data["datasets"]["Droonga"]["plugins"] = ["search", "groonga", "add"]
+        assert_equal([["search", "groonga", "add"]],
+                     plugins(@data))
+
+      end
+    end
+  end
+
+  class DataSetTest < self
+    class ReplicaTest < self
+      class TotalWeightTest < self
+        def test_three_slices
+          replica = {
+            "slices" => [
+              {
+                "weight" => 10,
+              },
+              {
+                "weight" => 20,
+              },
+              {
+                "weight" => 30,
+              },
+            ],
+          }
+          assert_equal(10 + 20 + 30,
+                       total_weight(replica))
+        end
+
+        private
+        def total_weight(replica)
+          catalog = create_catalog(minimum_data,
+                                   "base-path")
+          catalog.send(:compute_total_weight, replica)
+        end
+      end
+    end
+  end
+end

data/test/unit/fixtures/catalog/version2.json

@@ -0,0 +1,62 @@
+{
+  "version": 2,
+  "effectiveDate": "2014-02-28T00:00:00Z",
+  "datasets": {
+    "Test": {
+      "nWorkers": 4,
+      "plugins": [
+        "plugin1",
+        "plugin2",
+        "plugin3"
+      ],
+      "replicas": [
+        {
+          "dimension": "_key",
+          "slicer": "hash",
+          "slices": [
+            {
+              "label": "slice00",
+              "volume": {
+                "address": "localhost:23003/test.000"
+              }
+            },
+            {
+              "label": "slice01",
+              "volume": {
+                "address": "localhost:23003/test.001"
+              }
+            },
+            {
+              "label": "slice02",
+              "volume": {
+                "address": "localhost:23003/test.002"
+              }
+            }
+	  ]
+        },
+        {
+          "slices": [
+            {
+              "label": "slice10",
+              "volume": {
+                "address": "localhost:23004/test.010"
+              }
+            },
+            {
+              "label": "slice11",
+              "volume": {
+                "address": "localhost:23004/test.011"
+              }
+            },
+            {
+              "label": "slice12",
+              "volume": {
+                "address": "localhost:23004/test.012"
+              }
+            }
+	  ]
+        }
+      ]
+    }
+  }
+}

data/test/unit/helper/distributed_search_planner_helper.rb

@@ -13,11 +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/planner/distributed_search_planner"
+require "droonga/plugins/search/distributed_search_planner"
 
 module DistributedSearchPlannerHelper
   def plan(search_request)
-    planner = Droonga::DistributedSearchPlanner.new(search_request)
+    planner = Droonga::Plugins::Search::DistributedSearchPlanner.new(search_request)
     planner.plan
   end
 

data/test/unit/plugins/crud/test_add.rb

@@ -16,9 +16,7 @@
 require "droonga/plugins/crud"
 
 class CRUDAddHandlerTest < Test::Unit::TestCase
-  SUCCESS_RESPONSE_BODY = {
-    "success" => true,
-  }
+  SUCCESS_RESPONSE_BODY = true
 
   def setup
     setup_database
@@ -37,8 +35,10 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
 
   def setup_handler
     @worker = StubWorker.new
-    @handler = Droonga::Plugins::CRUD::Handler.new("name", @worker.context)
     @messenger = Droonga::Test::StubHandlerMessenger.new
+    @handler = Droonga::Plugins::CRUD::Handler.new("name",
+                                                   @worker.context,
+                                                   @messenger)
   end
 
   def teardown_handler
@@ -47,7 +47,7 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
 
   def process(request)
     message = Droonga::Test::StubHandlerMessage.new(request)
-    @handler.handle(message, @messenger)
+    @handler.handle(message)
   end
 
   public
@@ -70,8 +70,8 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {},
       }
-      process(request)
-      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
+      response = process(request)
+      assert_equal(SUCCESS_RESPONSE_BODY, response)
       table = @worker.context["Users"]
       assert_equal(["mori"], table.collect(&:key))
     end
@@ -82,8 +82,8 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
         "key"    => "mori",
         "values" => {"country" => "japan"},
       }
-      process(request)
-      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
+      response = process(request)
+      assert_equal(SUCCESS_RESPONSE_BODY, response)
       table = @worker.context["Users"]
       assert_equal(["japan"], table.collect(&:country))
     end
@@ -147,8 +147,8 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
         "table"  => "Books",
         "values" => {},
       }
-      process(request)
-      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
+      response = process(request)
+      assert_equal(SUCCESS_RESPONSE_BODY, response)
       table = @worker.context["Books"]
       assert_equal([nil], table.collect(&:title))
     end
@@ -158,8 +158,8 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
         "table"  => "Books",
         "values" => {"title" => "CSS"},
       }
-      process(request)
-      assert_equal([SUCCESS_RESPONSE_BODY], @messenger.values)
+      response = process(request)
+      assert_equal(SUCCESS_RESPONSE_BODY, response)
       table = @worker.context["Books"]
       assert_equal(["CSS"], table.collect(&:title))
     end

data/test/unit/plugins/groonga/test_column_create.rb

@@ -16,18 +16,20 @@
 class ColumnCreateTest < GroongaHandlerTest
   def create_handler
     Droonga::Plugins::Groonga::ColumnCreate::Handler.new("droonga",
-                                                         @handler.context)
+                                                         @handler.context,
+                                                         @messages)
   end
 
   def test_success
     Groonga::Schema.define(:context => @context) do |schema|
       schema.create_table("Books", :type => :hash)
     end
-    process(:column_create,
-            {"table" => "Books", "name" => "title", "type" => "ShortText"})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    message = {
+      "table" => "Books",
+      "name"  => "title",
+      "type"  => "ShortText",
+    }
+    response = process(:column_create, message)
     assert_equal(
       [NORMALIZED_HEADER_SUCCESS, true],
       [normalize_header(response.first), response.last]
@@ -35,11 +37,12 @@ class ColumnCreateTest < GroongaHandlerTest
   end
 
   def test_unknown_table
-    process(:column_create,
-            {"table" => "Unknown", "name" => "title", "type" => "ShortText"})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    message = {
+      "table" => "Unknown",
+      "name"  => "title",
+      "type"  => "ShortText",
+    }
+    response = process(:column_create, message)
     assert_equal(
       [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
       [normalize_header(response.first), response.last]

data/test/unit/plugins/groonga/test_table_create.rb

@@ -16,14 +16,12 @@
 class TableCreateTest < GroongaHandlerTest
   def create_handler
     Droonga::Plugins::Groonga::TableCreate::Handler.new("droonga",
-                                                        @handler.context)
+                                                        @handler.context,
+                                                        @messenger)
   end
 
   def test_success
-    process(:table_create, {"name" => "Books"})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    response = process(:table_create, {"name" => "Books"})
     assert_equal(
       [NORMALIZED_HEADER_SUCCESS, true],
       [normalize_header(response.first), response.last]
@@ -31,10 +29,7 @@ class TableCreateTest < GroongaHandlerTest
   end
 
   def test_failure
-    process(:table_create, {})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    response = process(:table_create, {})
     assert_equal(
       [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
       [normalize_header(response.first), response.last]

data/test/unit/plugins/groonga/test_table_remove.rb

@@ -16,7 +16,8 @@
 class TableRemoveTest < GroongaHandlerTest
   def create_handler
     Droonga::Plugins::Groonga::TableRemove::Handler.new("droonga",
-                                                        @handler.context)
+                                                        @handler.context,
+                                                        @messenger)
   end
 
   def setup
@@ -27,10 +28,7 @@ class TableRemoveTest < GroongaHandlerTest
   end
 
   def test_success
-    process(:table_remove, {"name" => "Books"})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    response = process(:table_remove, {"name" => "Books"})
     assert_equal(
       [NORMALIZED_HEADER_SUCCESS, true],
       [normalize_header(response.first), response.last]
@@ -40,10 +38,7 @@ class TableRemoveTest < GroongaHandlerTest
   end
 
   def test_failure
-    process(:table_remove, {})
-    response = @messenger.values.last
-    assert_valid_output(response)
-    response = response["result"]
+    response = process(:table_remove, {})
     assert_equal(
       [NORMALIZED_HEADER_INVALID_ARGUMENT, false],
       [normalize_header(response.first), response.last]

data/test/unit/{plugin/collector/test_search.rb → plugins/search/test_collector.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/search"
+require "droonga/plugins/search"
 
 class SearchCollectorTest < Test::Unit::TestCase
   def setup
     setup_database
-    @plugin = Droonga::SearchCollector.new
-    @outputs = []
-    stub(@plugin).emit do |name, value|
-      @outputs << [name, value]
-    end
   end
 
   def teardown
@@ -34,6 +29,22 @@ class SearchCollectorTest < 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::Search::GatherCollector.new
+    run_collector(collector, message)
+  end
+
+  def reduce(message)
+    collector = Droonga::Plugins::Search::ReduceCollector.new
+    run_collector(collector, message)
+  end
+
   class << self
     def create_record(*columns)
       columns
@@ -307,7 +318,7 @@ class SearchCollectorTest < Test::Unit::TestCase
     def test_gather(data)
       request = {
         "task" => {
-          "values" => nil,
+          "values" => {},
           "step" => {
             "body" => nil,
             "outputs" => nil,
@@ -318,10 +329,10 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => data[:mapping],
         "descendants" => nil,
       }
-      @plugin.process("collector_search_gather", request)
       output_name = data[:mapping]
       output_name = output_name["output"] if output_name.is_a?(Hash)
-      assert_equal([output_name, data[:expected]], @outputs.last)
+      assert_equal({ output_name =>  data[:expected] },
+                   gather(request))
     end
   end
 
@@ -385,10 +396,8 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_search_reduce", request)
-      assert_equal([
-                     output_name,
-                     {
+      assert_equal({
+                     output_name => {
                        "numeric_value" => 3,
                        "numeric_key_records" => [
                          create_record(1),
@@ -407,8 +416,8 @@ class SearchCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                   ],
-                   @outputs.last)
+                   },
+                   reduce(request))
     end
 
     def test_sum_with_limit
@@ -470,10 +479,8 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_search_reduce", request)
-      assert_equal([
-                     output_name,
-                     {
+      assert_equal({
+                     output_name => {
                        "numeric_value" => 3,
                        "numeric_key_records" => [
                          create_record(1),
@@ -488,8 +495,8 @@ class SearchCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                   ],
-                   @outputs.last)
+                   },
+                   reduce(request))
     end
 
     def test_sort
@@ -551,10 +558,8 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_search_reduce", request)
-      assert_equal([
-                     output_name,
-                     {
+      assert_equal({
+                     output_name => {
                        "numeric_key_records" => [
                          create_record(1),
                          create_record(2),
@@ -572,8 +577,8 @@ class SearchCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                   ],
-                   @outputs.last)
+                   },
+                   reduce(request))
     end
 
     def test_sort_with_limit
@@ -635,10 +640,8 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_search_reduce", request)
-      assert_equal([
-                     output_name,
-                     {
+      assert_equal({
+                     output_name => {
                        "numeric_key_records" => [
                          create_record(1),
                          create_record(2),
@@ -652,8 +655,8 @@ class SearchCollectorTest < Test::Unit::TestCase
                          create_record("f"),
                        ],
                      },
-                   ],
-                   @outputs.last)
+                   },
+                   reduce(request))
     end
   end
 
@@ -749,10 +752,8 @@ class SearchCollectorTest < Test::Unit::TestCase
         "name" => input_name,
         "descendants" => nil,
       }
-      @plugin.process("collector_search_reduce", request)
-      assert_equal([
-                     output_name,
-                     {
+      assert_equal({
+                     output_name => {
                        "records" => [
                          [
                            "group3",
@@ -798,8 +799,8 @@ class SearchCollectorTest < Test::Unit::TestCase
                          ],
                        ],
                      },
-                   ],
-                   @outputs.last)
+                   },
+                   reduce(request))
     end
   end
 end