droonga-engine 1.0.9 → 1.1.0

data/test/command/suite/system/statistics/object/count/schema.expected

@@ -0,0 +1,11 @@
+{
+  "inReplyTo": "request-id",
+  "statusCode": 200,
+  "type": "system.statistics.object.count.result",
+  "body": {
+    "tables":  2,
+    "columns": 0,
+    "records": 0,
+    "total":   2
+  }
+}

data/test/command/suite/system/statistics/object/count/schema.test

@@ -0,0 +1,13 @@
+#@require-catalog-version 2
+{
+  "type": "system.statistics.object.count",
+  "dataset": "Default",
+  "body": {
+    "output": [
+      "tables",
+      "columns",
+      "records",
+      "total"
+    ]
+  }
+}

data/test/command/suite/system/status.expected

@@ -5,8 +5,9 @@
   "body": {
     "nodes": {
       "127.0.0.1:23003/droonga": {
-        "live": true
+        "status": "active"
       }
-    }
+    },
+    "reporter": "127.0.0.1:0/droonga @ 127.0.0.1:23003/droonga"
   }
 }

data/test/unit/catalog/test_dataset.rb

@@ -97,7 +97,10 @@ class CatalogDatasetTest < Test::Unit::TestCase
         "replicas" => [],
       }
       dataset = create_dataset(data)
-      assert_equal(Droonga::Catalog::VolumeCollection.new([]),
+      raw_dataset = {
+        "replicas" => [],
+      }
+      assert_equal(Droonga::Catalog::ReplicasVolume.new(dataset, raw_dataset),
                    dataset.replicas)
     end
   end

data/test/unit/{test_catalog_generator.rb → catalog/test_generator.rb}

@@ -13,11 +13,11 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require "droonga/catalog_generator"
+require "droonga/catalog/generator"
 
 class CatalogGeneratorTest < Test::Unit::TestCase
   def setup
-    @generator = Droonga::CatalogGenerator.new
+    @generator = Droonga::Catalog::Generator.new
     @normalized_time_value = "2014-02-09T00:00:00Z"
   end
 

data/test/unit/catalog/test_replicas_volume.rb

@@ -0,0 +1,79 @@
+# Copyright (C) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/catalog/volume"
+require "droonga/catalog/replicas_volume"
+
+class CatalogReplicasTest < Test::Unit::TestCase
+  private
+  def create_replicas(raw_volume)
+    Droonga::Catalog::ReplicasVolume.new(nil, raw_volume)
+  end
+
+  class SelectTest < self
+    def setup
+      volume = {
+        "replicas" => [
+          { "address" => "volume1:10047/droonga.000" },
+          { "address" => "volume2:10047/droonga.000" },
+          { "address" => "volume3:10047/droonga.000" },
+        ],
+      }
+      @replicas = create_replicas(volume)
+    end
+
+    def test_top
+      hosts = @replicas.select(:top).collect do |volume|
+        volume.address.host
+      end
+      assert_equal(["volume1"],
+                   hosts)
+    end
+
+    def test_random
+      random_volumes = @replicas.select(:random).collect do |volume|
+        volume.address.host.gsub(/\Avolume[123]\z/, "any volume")
+      end
+      assert_equal(["any volume"], random_volumes)
+    end
+
+    def test_all
+      hosts = @replicas.select(:all).collect do |volume|
+        volume.address.host
+      end
+      assert_equal(["volume1", "volume2", "volume3"],
+                   hosts)
+    end
+  end
+
+  class NodesTest < self
+    def setup
+      volume = {
+        "replicas" => [
+          { "address" => "volume1:10047/droonga.000" },
+          { "address" => "volume1:10047/droonga.001" },
+          { "address" => "volume2:10047/droonga.002" },
+          { "address" => "volume2:10047/droonga.003" },
+        ],
+      }
+      @replicas = create_replicas(volume)
+    end
+
+    def test_all_nodes
+      assert_equal(["volume1:10047/droonga", "volume2:10047/droonga"],
+                   @replicas.all_nodes)
+    end
+  end
+end

data/test/unit/catalog/test_single_volume.rb

@@ -24,11 +24,11 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
       @volume = Droonga::Catalog::SingleVolume.new(data)
     end
 
-    def address(host, port, tag, name)
+    def address(host, port, tag, local_name)
       Droonga::Address.new(:host => host,
                            :port => port,
                            :tag  => tag,
-                           :name => name)
+                           :local_name => local_name)
     end
 
     def test_address

data/test/unit/catalog/test_slice.rb

@@ -88,8 +88,10 @@ class CatalogSliceTest < Test::Unit::TestCase
       assert_equal("127.0.0.1:10047/volume.000",
                    slice.volume.address.to_s)
     end
+  end
 
-    def test_all_nodes
+  class AllNodesTest < self
+    def test_single
       data = {
         "volume" => {
           "address" => "127.0.0.1:10047/volume.000",
@@ -99,5 +101,35 @@ class CatalogSliceTest < Test::Unit::TestCase
       assert_equal(["127.0.0.1:10047/volume"],
                    slice.all_nodes)
     end
+
+    def test_replicas
+      data = {
+        "volume" => {
+          "replicas" => [
+            { "address" => "127.0.0.1:10047/volume.000" },
+          ],
+        },
+      }
+      slice = create_slice(data)
+      assert_equal(["127.0.0.1:10047/volume"],
+                   slice.all_nodes)
+    end
+
+    def test_slices
+      data = {
+        "volume" => {
+          "slices" => [
+            {
+              "volume" => {
+                "address" => "127.0.0.1:10047/volume.000",
+              },
+            },
+          ],
+        },
+      }
+      slice = create_slice(data)
+      assert_equal(["127.0.0.1:10047/volume"],
+                   slice.all_nodes)
+    end
   end
 end

data/test/unit/catalog/{test_collection_volume.rb → test_slices_volume.rb}

@@ -14,15 +14,16 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "droonga/catalog/dataset"
+require "droonga/catalog/slices_volume"
 
 class CatalogSingleVolumeTest < Test::Unit::TestCase
-  def create_collection_volume(data)
+  def create_slices(data)
     minimum_dataset_data = {
       "replicas" => {
       },
     }
     dataset = Droonga::Catalog::Dataset.new("DatasetName", minimum_dataset_data)
-    Droonga::Catalog::CollectionVolume.new(dataset, data)
+    Droonga::Catalog::SlicesVolume.new(dataset, data)
   end
 
   class DimensionTest < self
@@ -30,7 +31,7 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
       data = {
         "slices" => [],
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
       assert_equal("_key", volume.dimension)
     end
 
@@ -39,7 +40,7 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
         "dimension" => "group",
         "slices" => [],
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
       assert_equal("group", volume.dimension)
     end
   end
@@ -49,7 +50,7 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
       data = {
         "slices" => [],
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
       assert_equal("hash", volume.slicer)
     end
 
@@ -57,7 +58,7 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
       data = {
         "slicer" => "ordinal",
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
       assert_equal("ordinal", volume.slicer)
     end
   end
@@ -67,7 +68,7 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
       data = {
         "slices" => [],
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
       assert_equal([], volume.slices)
     end
   end
@@ -95,14 +96,14 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
 
       private
       def total_weight(data)
-        volume = create_collection_volume(data)
+        volume = create_slices(data)
         volume.send(:compute_total_weight)
       end
     end
   end
 
-  class NodesTest < self
-    def test_all_nodes
+  class AllNodesTest < self
+    def test_slices
       data = {
         "slices" => [
           { "volume" => { "address" => "127.0.0.1:23003/droonga.000" } },
@@ -111,7 +112,67 @@ class CatalogSingleVolumeTest < Test::Unit::TestCase
           { "volume" => { "address" => "127.0.0.1:23004/droonga.101" } },
         ],
       }
-      volume = create_collection_volume(data)
+      volume = create_slices(data)
+      assert_equal(["127.0.0.1:23003/droonga", "127.0.0.1:23004/droonga"],
+                   volume.all_nodes)
+    end
+
+    def test_replicas_in_slice
+      data = {
+        "slices" => [
+          {
+            "volume" => {
+              "replicas" => [
+                { "address" => "127.0.0.1:23003/droonga.000" },
+                { "address" => "127.0.0.1:23003/droonga.001" },
+              ],
+            },
+          },
+          {
+            "volume" => {
+              "replicas" => [
+                { "address" => "127.0.0.1:23004/droonga.100" },
+                { "address" => "127.0.0.1:23004/droonga.101" },
+              ],
+            },
+          },
+        ],
+      }
+      volume = create_slices(data)
+      assert_equal(["127.0.0.1:23003/droonga", "127.0.0.1:23004/droonga"],
+                   volume.all_nodes)
+    end
+
+    def test_slices_in_replicas_in_slice
+      data = {
+        "slices" => [
+          {
+            "volume" => {
+              "replicas" => [
+                {
+                  "slices" => [
+                    { "volume" => { "address" => "127.0.0.1:23003/droonga.000" } },
+                    { "volume" => { "address" => "127.0.0.1:23003/droonga.001" } },
+                  ],
+                },
+              ],
+            },
+          },
+          {
+            "volume" => {
+              "replicas" => [
+                {
+                  "slices" => [
+                    { "volume" => { "address" => "127.0.0.1:23004/droonga.100" } },
+                    { "volume" => { "address" => "127.0.0.1:23004/droonga.101" } },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      }
+      volume = create_slices(data)
       assert_equal(["127.0.0.1:23003/droonga", "127.0.0.1:23004/droonga"],
                    volume.all_nodes)
     end

data/test/unit/catalog/test_version2.rb

@@ -47,18 +47,21 @@ class CatalogVersion2Test < Test::Unit::TestCase
                      "localhost:23003/test.000" => {
                        :database  => "#{base_path}/databases/000/db",
                        :dataset   => "Test",
+                       :label     => "localhost:23003/test.000",
                        :plugins   => ["plugin1", "plugin2", "plugin3"],
                        :n_workers => 4,
                      },
                      "localhost:23003/test.001" => {
                        :database  => "#{base_path}/databases/001/db",
                        :dataset   => "Test",
+                       :label     => "localhost:23003/test.001",
                        :plugins   => ["plugin1", "plugin2", "plugin3"],
                        :n_workers => 4,
                      },
                      "localhost:23003/test.002" => {
                        :database  => "#{base_path}/databases/002/db",
                        :dataset   => "Test",
+                       :label     => "localhost:23003/test.002",
                        :plugins   => ["plugin1", "plugin2", "plugin3"],
                        :n_workers => 4,
                      },

data/test/unit/helper/distributed_search_planner_helper.rb

@@ -22,8 +22,8 @@ module DistributedSearchPlannerHelper
     stub(stub_dataset).name do
       Droonga::Catalog::Dataset::DEFAULT_NAME
     end
-    stub(stub_dataset).single_slice? do
-      false
+    stub(stub_dataset).sliced? do
+      true
     end
     planner = Droonga::Plugins::Search::DistributedSearchPlanner.new(stub_dataset, search_request)
     planner.plan

data/test/unit/plugins/catalog/test_fetch.rb

@@ -34,10 +34,10 @@ class CatalogFetchHandlerTest < Test::Unit::TestCase
     @worker = StubWorker.new
     @messenger = Droonga::Test::StubHandlerMessenger.new
     @loop = nil
-    @handler = Droonga::Plugins::Catalog::FetchHandler.new("name",
-                                                           @worker.context,
-                                                           @messenger,
-                                                           @loop)
+    @handler = Droonga::Plugins::Catalog::FetchHandler.new(:name      => "name",
+                                                           :context   => @worker.context,
+                                                           :messenger => @messenger,
+                                                           :loop      => @loop)
   end
 
   def teardown_handler

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

@@ -37,10 +37,10 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
     @worker = StubWorker.new
     @messenger = Droonga::Test::StubHandlerMessenger.new
     @loop = nil
-    @handler = Droonga::Plugins::CRUD::Handler.new("name",
-                                                   @worker.context,
-                                                   @messenger,
-                                                   @loop)
+    @handler = Droonga::Plugins::CRUD::Handler.new(:name      => "name",
+                                                   :context   => @worker.context,
+                                                   :messenger => @messenger,
+                                                   :loop      => @loop)
   end
 
   def teardown_handler
@@ -134,6 +134,46 @@ class CRUDAddHandlerTest < Test::Unit::TestCase
     end
   end
 
+  class MismatchedTypeKeyTest < self
+    class Acceptable < self
+      def test_integer_for_string
+        setup_table_with_key_type("ShortText")
+        request = {
+          "table"  => "Users",
+          "key"    => 1,
+          "values" => {},
+        }
+        response = process(request)
+        assert_equal(SUCCESS_RESPONSE_BODY, response)
+        table = @worker.context["Users"]
+        assert_equal(["1"], table.collect(&:key))
+      end
+
+      def test_string_for_integer
+        setup_table_with_key_type("UInt32")
+        request = {
+          "table"  => "Users",
+          "key"    => "1",
+          "values" => {},
+        }
+        response = process(request)
+        assert_equal(SUCCESS_RESPONSE_BODY, response)
+        table = @worker.context["Users"]
+        assert_equal([1], table.collect(&:key))
+      end
+    end
+
+    private
+    def setup_table_with_key_type(key_type)
+      Groonga::Schema.define do |schema|
+        schema.create_table("Users",
+                            :type => :hash,
+                            :key_type => key_type) do |table|
+        end
+      end
+    end
+  end
+
   class NoKeyTest < self
     def setup_schema
       Groonga::Schema.define do |schema|