droonga-engine 1.0.1

data/test/unit/catalog/test_slice.rb

@@ -0,0 +1,92 @@
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/catalog/dataset"
+
+class CatalogSliceTest < Test::Unit::TestCase
+  private
+  def create_slice(data)
+    minimum_dataset_data = {
+      "replicas" => {
+      },
+    }
+    dataset = Droonga::Catalog::Dataset.new("DatasetName", minimum_dataset_data)
+    Droonga::Catalog::Slice.new(dataset, data)
+  end
+
+  class WeightTest < self
+    def test_default
+      data = {
+      }
+      slice = create_slice(data)
+      assert_equal(1, slice.weight)
+    end
+
+    def test_specified
+      data = {
+        "weight" => 29,
+      }
+      slice = create_slice(data)
+      assert_equal(29, slice.weight)
+    end
+  end
+
+  class LabelTest < self
+    def test_default
+      data = {
+      }
+      slice = create_slice(data)
+      assert_nil(slice.label)
+    end
+
+    def test_specified
+      data = {
+        "label" => "High",
+      }
+      slice = create_slice(data)
+      assert_equal("High", slice.label)
+    end
+  end
+
+  class BoundaryTest < self
+    def test_default
+      data = {
+      }
+      slice = create_slice(data)
+      assert_nil(slice.boundary)
+    end
+
+    def test_specified
+      data = {
+        "boundary" => "2014-03-21",
+      }
+      slice = create_slice(data)
+      assert_equal("2014-03-21", slice.boundary)
+    end
+  end
+
+  class VolumeTest < self
+    def test_single
+      data = {
+        "volume" => {
+          "address" => "127.0.0.1:10047/volume.000",
+        },
+      }
+      slice = create_slice(data)
+      assert_equal("127.0.0.1:10047/volume.000",
+                   slice.volume.address)
+    end
+  end
+end

data/test/unit/catalog/test_version1.rb

@@ -0,0 +1,361 @@
+# 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/version1"
+
+class CatalogVersion1Test < Test::Unit::TestCase
+  class << self
+    def minimum_data
+      {
+        "effective_date" => "2013-09-01T00:00:00Z",
+        "zones" => [],
+        "farms" => {},
+        "datasets" => {},
+      }
+    end
+  end
+
+  private
+  def minimum_data
+    self.class.minimum_data
+  end
+
+  def create_catalog(data, path)
+    Droonga::Catalog::Version1.new(data, path)
+  end
+
+  class PartitionTest < self
+    def setup
+      data = JSON.parse(File.read(catalog_path))
+      @catalog = create_catalog(data, catalog_path)
+    end
+
+    def test_get_partitions
+      partitions = @catalog.get_partitions("localhost:23003/test")
+      assert_equal({
+                     "localhost:23003/test.000" => {
+                       :database  => "#{base_path}/000/db",
+                       :dataset   => "Test",
+                       :plugins   => ["for_dataset"],
+                       :n_workers => 0
+                     },
+                     "localhost:23003/test.001" => {
+                       :database  => "#{base_path}/001/db",
+                       :dataset   => "Test",
+                       :plugins   => ["for_dataset"],
+                       :n_workers => 0
+                     },
+                     "localhost:23003/test.002" => {
+                       :database  => "#{base_path}/002/db",
+                       :dataset   => "Test",
+                       :plugins   => ["for_dataset"],
+                       :n_workers => 0
+                     },
+                     "localhost:23003/test.003" => {
+                       :database  => "#{base_path}/003/db",
+                       :dataset   => "Test",
+                       :plugins   => ["for_dataset"],
+                       :n_workers => 0
+                     },
+                   },
+                   partitions)
+    end
+
+    def fixture_path(base_path)
+      File.expand_path("../../fixtures/#{base_path}", __FILE__)
+    end
+
+    def catalog_path
+      @catalog_path ||= fixture_path("catalog/version1.json")
+    end
+
+    def base_path
+      File.dirname(catalog_path)
+    end
+
+    class PluginsTest < self
+      def setup
+        @data = minimum_data.merge({
+          "zones" => [farm_name],
+          "farms" => {
+            farm_name => {
+              "device" => ".",
+            },
+          },
+          "datasets" => {
+            "Droonga" => {
+              "workers" => 1,
+              "number_of_partitions" => 1,
+              "number_of_replicas" => 1,
+              "date_range" => "infinity",
+              "partition_key" => "_key",
+              "plugins" => [],
+              "ring" => {
+                "localhost:23041" => {
+                  "weight" =>  50,
+                  "partitions" => {
+                    "2014-02-09" => [
+                      "#{farm_name}.000",
+                    ],
+                  },
+                },
+              },
+            },
+          },
+        })
+      end
+
+      def farm_name
+        "localhost:23041/droonga"
+      end
+
+      def plugins(data)
+        catalog = create_catalog(data, catalog_path)
+        catalog.get_partitions(farm_name).collect do |partition, 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 RingTest < self
+      class TotalWeightTest < self
+        def test_three_zones
+          dataset = {
+            "ring" => {
+              "zone1" => {
+                "weight" => 10,
+              },
+              "zone2" => {
+                "weight" => 20,
+              },
+              "zone3" => {
+                "weight" => 30,
+              },
+            }
+          }
+          assert_equal(10 + 20 + 30,
+                       total_weight(dataset))
+        end
+
+        private
+        def total_weight(dataset)
+          catalog = create_catalog(minimum_data,
+                                   "base-path")
+          catalog.send(:compute_total_weight, dataset)
+        end
+      end
+    end
+  end
+
+  class ValidationTest < self
+    class << self
+      def farm_name
+        "localhost:23041/droonga"
+      end
+
+      def ring_name
+        "localhost:23041"
+      end
+
+      def range_name
+        "2013-09-01"
+      end
+
+      def path
+        "path/to/catalog"
+      end
+
+      def valid_farms
+        {
+          farm_name => {
+            "device" => ".",
+          },
+        }
+      end
+
+      def valid_zones
+        valid_farms.keys
+      end
+
+      def valid_dataset_base
+        {
+          "workers" => 0,
+          "number_of_replicas" => 1,
+          "number_of_partitions" => 1,
+          "partition_key" => "_key",
+          "date_range" => "infinity",
+          "ring" => {},
+        }
+      end
+    end
+
+    data(
+      :missing_root_elements => {
+        :catalog => {},
+        :errors => [
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "effective_date", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "zones", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "farms", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets", path),
+        ],
+      },
+      :invalid_farms => {
+        :catalog => minimum_data.merge(
+          "farms" => {
+            farm_name => {
+            },
+          },
+          "zones" => [farm_name],
+        ),
+        :errors => [
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "farms.#{farm_name}.device", path),
+        ],
+      },
+      :missing_dataset_parameters => {
+        :catalog => minimum_data.merge(
+          "farms" => valid_farms,
+          "zones" => valid_zones,
+          "datasets" => {
+            "Droonga" => {
+            },
+          },
+        ),
+        :errors => [
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.workers", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.number_of_replicas", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.number_of_partitions", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.partition_key", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.date_range", path),
+          Droonga::Catalog::MissingRequiredParameter.new(
+            "datasets.Droonga.ring", path),
+        ],
+      },
+      :invalid_date_parameters => {
+        :catalog => minimum_data.merge(
+          "effective_date" => "invalid",
+        ),
+        :errors => [
+          Droonga::Catalog::InvalidDate.new(
+            "effective_date", "invalid", path),
+        ],
+      },
+      :non_integer_numeric_parameters => {
+        :catalog => minimum_data.merge(
+          "farms" => valid_farms,
+          "zones" => valid_zones,
+          "datasets" => {
+            "Droonga" => valid_dataset_base.merge(
+              "workers" => 0.1,
+              "number_of_replicas" => 0.1,
+              "number_of_partitions" => 0.1,
+              "ring" => {
+                ring_name => {
+                  "weight" => 0.1,
+                  "partitions" => {},
+                },
+              },
+            ),
+          },
+        ),
+        :errors => [
+          Droonga::Catalog::MismatchedParameterType.new(
+            "datasets.Droonga.workers", Integer, Float, path),
+          Droonga::Catalog::MismatchedParameterType.new(
+            "datasets.Droonga.number_of_replicas", Integer, Float, path),
+          Droonga::Catalog::MismatchedParameterType.new(
+            "datasets.Droonga.number_of_partitions", Integer, Float, path),
+        ],
+      },
+      :negative_numeric_parameters => {
+        :catalog => minimum_data.merge(
+          "farms" => valid_farms,
+          "zones" => valid_zones,
+          "datasets" => {
+            "Droonga" => valid_dataset_base.merge(
+              "workers" => -1,
+              "number_of_replicas" => -1,
+              "number_of_partitions" => -1,
+              "ring" => {
+                ring_name => {
+                  "weight" => -1,
+                  "partitions" => {},
+                },
+              },
+            ),
+          },
+        ),
+        :errors => [
+          Droonga::Catalog::NegativeNumber.new(
+            "datasets.Droonga.workers", -1, path),
+          Droonga::Catalog::SmallerThanOne.new(
+            "datasets.Droonga.number_of_replicas", -1, path),
+          Droonga::Catalog::SmallerThanOne.new(
+            "datasets.Droonga.number_of_partitions", -1, path),
+          Droonga::Catalog::NegativeNumber.new(
+            "datasets.Droonga.ring.#{ring_name}.weight", -1, path),
+        ],
+      },
+      :broken_relations_unknown_farm => {
+        :catalog => minimum_data.merge(
+          "farms" => valid_farms,
+          "zones" => valid_zones,
+          "datasets" => {
+            "Droonga" => valid_dataset_base.merge(
+              "ring" => {
+                ring_name => {
+                  "weight" => 1,
+                  "partitions" => {
+                    range_name => [
+                      "unknown:0/unknown.000",
+                    ],
+                  },
+                },
+              },
+            ),
+          },
+        ),
+        :errors => [
+          Droonga::Catalog::UnknownFarmForPartition.new(
+            "datasets.Droonga.ring.#{ring_name}.partitions.#{range_name}[0]",
+            "unknown:0/unknown.000", path),
+        ],
+      },
+    )
+    def test_validation(data)
+      assert_raise(Droonga::MultiplexError.new(data[:errors])) do
+        create_catalog(data[:catalog], "path/to/catalog")
+      end
+    end
+  end
+end

data/test/unit/catalog/test_version2.rb

@@ -0,0 +1,124 @@
+# 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 CatalogVersion2Test < 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
+end

data/test/unit/catalog/test_version2_validator.rb

@@ -0,0 +1,66 @@
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/catalog/version2_validator"
+
+class CatalogVersion2ValidatorTest < Test::Unit::TestCase
+  def setup
+    @path = "catalog.json"
+  end
+
+  def validate(data)
+    validator = Droonga::Catalog::Version2Validator.new(data, @path)
+    validator.validate
+  end
+
+  def validation_error(details)
+    Droonga::Catalog::ValidationError.new(@path, details)
+  end
+
+  def detail(value_path, message)
+    Droonga::Catalog::ValidationError::Detail.new(value_path, message)
+  end
+
+  class DatasetsTest < self
+    def test_missing
+      details = [
+        detail("datasets", "required parameter is missing"),
+      ]
+      assert_raise(validation_error(details)) do
+        validate({})
+      end
+    end
+
+    class DatasetTest < self
+      class ReplicasTest < self
+        def test_missing
+          details = [
+            detail("datasets.Droonga.replicas",
+                   "required parameter is missing"),
+          ]
+          assert_raise(validation_error(details)) do
+            data = {
+              "datasets" => {
+                "Droonga" => {
+                }
+              }
+            }
+            validate(data)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/catalog/test_volume_collection.rb

@@ -0,0 +1,50 @@
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/catalog/volume_collection"
+
+class CatalogVolumeCollectionTest < Test::Unit::TestCase
+  private
+  def create_volume_collection(volumes)
+    Droonga::Catalog::VolumeCollection.new(volumes)
+  end
+
+  class SelectTest < self
+    def setup
+      volumes = [
+        "volume1",
+        "volume2",
+        "volume3",
+      ]
+      @collection = create_volume_collection(volumes)
+    end
+
+    def test_top
+      assert_equal(["volume1"], @collection.select(:top))
+    end
+
+    def test_random
+      random_volumes = @collection.select(:random).collect do |volume|
+        volume.gsub(/\Avolume[123]\z/, "any volume")
+      end
+      assert_equal(["any volume"], random_volumes)
+    end
+
+    def test_all
+      assert_equal(["volume1", "volume2", "volume3"],
+                   @collection.select(:all))
+    end
+  end
+end