fluent-plugin-droonga 0.9.9 → 1.0.0

data/test/unit/catalog/test_schema.rb

@@ -0,0 +1,285 @@
+# 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/schema"
+
+class CatalogSchemaTest < Test::Unit::TestCase
+  private
+  def create_schema(dataset_name, data)
+    Droonga::Catalog::Schema.new(dataset_name, data)
+  end
+
+  class SchemaTest < self
+    def test_schema_not_specified
+      assert_equal([],
+                   create_schema("dataset_name", nil).to_messages)
+    end
+
+    def test_no_table
+      assert_equal([],
+                   create_schema("dataset_name", {}).to_messages)
+    end
+
+    def test_key_index
+      assert_equal([
+                     {
+                       "type" => "table_create",
+                       "dataset" => "dataset_name",
+                       "body" => {
+                         "name"       => "Term",
+                         "key_type"   => "ShortText",
+                         "flags"      => "TABLE_PAT_KEY",
+                         "normalizer" => "NormalizerAuto",
+                       }
+                     },
+                     {
+                       "type" => "table_create",
+                       "dataset" => "dataset_name",
+                       "body" => {
+                         "name"       => "Store",
+                         "key_type"   => "ShortText",
+                         "flags"      => "TABLE_HASH_KEY",
+                       }
+                     },
+                     {
+                       "type" => "column_create",
+                       "dataset" => "dataset_name",
+                       "body" => {
+                         "name"       => "stores__key",
+                         "table"      => "Term",
+                         "type"       => "Store",
+                         "flags"      => "COLUMN_INDEX",
+                         "source"     => "_key"
+                       }
+                     }
+                   ],
+                   create_schema(
+                     "dataset_name",
+                     "Term" => {
+                       "type"       => "PatriciaTrie",
+                       "keyType"    => "ShortText",
+                       "normalizer" => "NormalizerAuto",
+                       "columns" => {
+                         "stores__key" => {
+                           "type"      => "Index",
+                           "valueType" => "Store",
+                           "indexOptions" => {
+                             "sources" => [
+                               "_key"
+                             ]
+                           }
+                         }
+                       }
+                     },
+                     "Store" => {
+                       "keyType" => "ShortText"
+                     }
+                   ).to_messages)
+    end
+
+    class TableTest < self
+      def create_table(name, data)
+        Droonga::Catalog::Schema::Table.new(name, data)
+      end
+
+      def test_name
+        assert_equal("table_name",
+                     create_table("table_name",
+                                  {}).name)
+      end
+
+      def test_type_default
+        assert_equal("Hash",
+                     create_table("table_name",
+                                  {}).type)
+      end
+
+      def test_type
+        assert_equal("Hash",
+                     create_table("table_name",
+                                  {
+                                    "type" => "Hash"
+                                  }).type)
+      end
+
+      def test_flags
+        assert_equal(["TABLE_HASH_KEY"],
+                     create_table("table_name",
+                                  {
+                                    "type" => "Hash"
+                                  }).flags)
+      end
+
+      def test_key_type
+        assert_equal("ShortText",
+                     create_table("table_name",
+                                  {
+                                    "keyType" => "ShortText"
+                                  }).key_type)
+      end
+
+      def test_key_type_groonga
+        assert_equal("Int64",
+                     create_table("table_name",
+                                  {
+                                    "keyType" => "Integer"
+                                  }).key_type_groonga)
+      end
+
+      def test_tokenizer
+        assert_equal("TokenBigram",
+                     create_table("table_name",
+                                  {
+                                    "tokenizer" => "TokenBigram"
+                                  }).tokenizer)
+      end
+
+      def test_normalizer
+        assert_equal("NormalizerAuto",
+                     create_table("table_name",
+                                  {
+                                    "normalizer" => "NormalizerAuto"
+                                  }).normalizer)
+      end
+
+      def test_to_table_create_body
+        assert_equal({
+                       "name"              => "table_name",
+                       "key_type"          => "ShortText",
+                       "flags"             => "TABLE_PAT_KEY",
+                       "normalizer"        => "NormalizerAuto",
+                       "default_tokenizer" => "TokenBigram"
+                     },
+                     create_table("table_name",
+                                  {
+                                    "type"       => "PatriciaTrie",
+                                    "keyType"    => "ShortText",
+                                    "normalizer" => "NormalizerAuto",
+                                    "tokenizer"  => "TokenBigram"
+                                  }).to_table_create_body)
+
+      end
+    end
+
+    class ColumnTest < self
+      def create_column(name, data)
+        Droonga::Catalog::Schema::Column.new("table_name", name, data)
+      end
+
+      def test_name
+        assert_equal("column_name",
+                     create_column("column_name",
+                                   {}).name)
+      end
+
+      def test_type
+        assert_equal("Scalar",
+                     create_column("column_name",
+                                   {
+                                     "type" => "Scalar"
+                                   }).type)
+      end
+
+      def test_type_default
+        assert_equal("Scalar",
+                     create_column("column_name",
+                                   {}).type)
+      end
+
+      def test_flags
+        assert_equal(["COLUMN_SCALAR"],
+                     create_column("column_name",
+                                   {
+                                     "type" => "Scalar"
+                                   }).flags)
+      end
+
+      def test_value_type
+        assert_equal("ShortText",
+                     create_column("column_name",
+                                   {
+                                     "valueType" => "ShortText"
+                                   }).value_type)
+      end
+
+      def test_value_type_groonga
+        assert_equal("Int64",
+                     create_column("column_name",
+                                   {
+                                     "valueType" => "Integer"
+                                   }).value_type_groonga)
+      end
+
+      def test_flags_with_column_index_options
+        assert_equal(["COLUMN_SCALAR", "WITH_SECTION"],
+                     create_column("column_name",
+                                   {
+                                     "type" => "Scalar",
+                                     "indexOptions" => {
+                                       "section" => true
+                                     }
+                                   }).flags)
+      end
+
+      def test_to_column_create_body
+        assert_equal({
+                       "name"  => "column_name",
+                       "flags" => "COLUMN_SCALAR",
+                       "table" => "table_name",
+                       "type"  => "ShortText"
+                     },
+                     create_column("column_name",
+                                  {
+                                    "type"      => "Scalar",
+                                    "valueType" => "ShortText"
+                                  }).to_column_create_body)
+      end
+    end
+
+    class ColumnIndexOptionsTest < self
+      def create_options(data)
+        Droonga::Catalog::Schema::ColumnIndexOptions.new(data)
+      end
+
+      def test_section
+        assert_equal(true,
+                     create_options({
+                                      "section" => true
+                                    }).section)
+      end
+
+      def test_weight
+        assert_equal(true,
+                     create_options({
+                                      "weight" => true
+                                    }).weight)
+      end
+
+      def test_position
+        assert_equal(true,
+                     create_options({
+                                      "position" => true
+                                    }).position)
+      end
+
+      def test_flags
+        assert_equal(["WITH_SECTION"],
+                     create_options({
+                                      "section" => true
+                                    }).flags)
+      end
+    end
+  end
+end

data/test/unit/catalog/test_version1.rb

@@ -15,39 +15,31 @@
 
 require "droonga/catalog/version1"
 
-class CatalogTest < Test::Unit::TestCase
-  private
-  def minimum_data
-    {
-      "datasets" => [],
-    }
+class CatalogTestVersion1 < Test::Unit::TestCase
+  class << self
+    def minimum_data
+      {
+        "effective_date" => "2013-09-01T00:00:00Z",
+        "zones" => [],
+        "farms" => {},
+        "datasets" => {},
+      }
+    end
   end
 
-  def create_catalog(data, base_path)
-    Droonga::Catalog::Version1.new(data, base_path)
+  private
+  def minimum_data
+    self.class.minimum_data
   end
 
-  class OptionTest < self
-    def create_catalog(options)
-      super(minimum_data.merge("options" => options), "base-path")
-    end
-
-    def test_nonexistent
-      catalog = create_catalog({})
-      assert_nil(catalog.option("nonexistent"))
-    end
-
-    def test_existent
-      catalog = create_catalog("plugins" => ["crud", "groonga"])
-      assert_equal(["crud", "groonga"],
-                   catalog.option("plugins"))
-    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, base_path)
+      @catalog = create_catalog(data, catalog_path)
     end
 
     def test_get_partitions
@@ -55,21 +47,25 @@ class CatalogTest < Test::Unit::TestCase
       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
                      },
@@ -91,7 +87,8 @@ class CatalogTest < Test::Unit::TestCase
 
     class PluginsTest < self
       def setup
-        @data = {
+        @data = minimum_data.merge({
+          "zones" => [farm_name],
           "farms" => {
             farm_name => {
               "device" => ".",
@@ -99,7 +96,12 @@ class CatalogTest < Test::Unit::TestCase
           },
           "datasets" => {
             "Droonga" => {
+              "workers" => 1,
               "number_of_partitions" => 1,
+              "number_of_replicas" => 1,
+              "date_range" => "infinity",
+              "partition_key" => "_key",
+              "plugins" => [],
               "ring" => {
                 "localhost:23041" => {
                   "weight" =>  50,
@@ -112,7 +114,7 @@ class CatalogTest < Test::Unit::TestCase
               },
             },
           },
-        }
+        })
       end
 
       def farm_name
@@ -120,7 +122,7 @@ class CatalogTest < Test::Unit::TestCase
       end
 
       def plugins(data)
-        catalog = create_catalog(data, base_path)
+        catalog = create_catalog(data, catalog_path)
         catalog.get_partitions(farm_name).collect do |partition, options|
           options[:plugins]
         end
@@ -158,10 +160,202 @@ class CatalogTest < Test::Unit::TestCase
 
         private
         def total_weight(dataset)
-          catalog = create_catalog({"datasets" => []}, "base-path")
+          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