fluent-plugin-droonga 1.0.0 → 1.0.1

data/test/unit/catalog/test_schema.rb

@@ -198,14 +198,6 @@ class CatalogSchemaTest < Test::Unit::TestCase
                                    {}).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",
@@ -222,17 +214,6 @@ class CatalogSchemaTest < Test::Unit::TestCase
                                    }).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",
@@ -241,10 +222,69 @@ class CatalogSchemaTest < Test::Unit::TestCase
                        "type"  => "ShortText"
                      },
                      create_column("column_name",
-                                  {
-                                    "type"      => "Scalar",
-                                    "valueType" => "ShortText"
-                                  }).to_column_create_body)
+                                   {
+                                     "type"      => "Scalar",
+                                     "valueType" => "ShortText"
+                                   }).to_column_create_body)
+      end
+
+      class FlagsTest < self
+        def flags(data)
+          create_column("column_name", data).flags
+        end
+
+        def test_type
+          data = {
+            "type" => "Scalar"
+          }
+          assert_equal(["COLUMN_SCALAR"],
+                       flags(data))
+        end
+
+        def test_weight_options
+          data = {
+            "type" => "Vector",
+            "vectorOptions" => {
+              "weight" => true
+            }
+          }
+          assert_equal(["COLUMN_VECTOR", "WITH_WEIGHT"],
+                       flags(data))
+        end
+
+        def test_index_options
+          data = {
+            "type" => "Index",
+            "indexOptions" => {
+              "section" => true
+            }
+          }
+          assert_equal(["COLUMN_INDEX", "WITH_SECTION"],
+                       flags(data))
+        end
+      end
+    end
+
+    class ColumnVectorOptionsTest < self
+      def create_options(data)
+        Droonga::Catalog::Schema::ColumnVectorOptions.new(data)
+      end
+
+      def test_weight
+        data = {
+          "weight" => true
+        }
+        options = create_options(data)
+        assert_equal(true, options.weight)
+      end
+
+      def test_flags
+        data = {
+          "weight" => true
+        }
+        options = create_options(data)
+        assert_equal(["WITH_WEIGHT"],
+                     options.flags)
       end
     end
 

data/test/unit/catalog/test_single_volume.rb

@@ -0,0 +1,31 @@
+# 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/single_volume"
+
+class CatalogSingleVolumeTest < Test::Unit::TestCase
+  def create_single_volume(data)
+    Droonga::Catalog::SingleVolume.new(data)
+  end
+
+  def test_address
+    data = {
+      "address" => "127.0.0.1:10047/volume.000",
+    }
+    volume = create_single_volume(data)
+    assert_equal("127.0.0.1:10047/volume.000",
+                 volume.address)
+  end
+end

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

@@ -15,7 +15,7 @@
 
 require "droonga/catalog/version1"
 
-class CatalogTestVersion1 < Test::Unit::TestCase
+class CatalogVersion1Test < Test::Unit::TestCase
   class << self
     def minimum_data
       {

data/test/unit/catalog/test_version2.rb

@@ -15,7 +15,7 @@
 
 require "droonga/catalog/version2"
 
-class CatalogTestVersion2 < Test::Unit::TestCase
+class CatalogVersion2Test < Test::Unit::TestCase
   class << self
     def minimum_data
       {
@@ -121,35 +121,4 @@ class CatalogTestVersion2 < Test::Unit::TestCase
       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/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

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

@@ -1,4 +1,4 @@
-# Copyright (C) 2013 Droonga Project
+# 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
@@ -82,6 +82,9 @@ column_create Books main_text COLUMN_SCALAR LongText
              "COLUMN_VECTOR" => {
                :flags => "COLUMN_VECTOR",
              },
+             "COLUMN_VECTOR|WITH_WEIGHT" => {
+               :flags => "COLUMN_VECTOR|WITH_WEIGHT",
+             },
            })
       def test_data_store_column_type(data)
         request = {

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

@@ -139,7 +139,7 @@ table_create Books TABLE_HASH_KEY --key_type ShortText --default_tokenizer Token
       }
       process(:table_create, request)
       assert_equal(<<-SCHEMA, dump)
-table_create Books TABLE_HASH_KEY|KEY_NORMALIZE --key_type ShortText
+table_create Books TABLE_HASH_KEY --key_type ShortText --normalizer NormalizerAuto
       SCHEMA
     end
   end

data/test/unit/test_message_matcher.rb

@@ -20,34 +20,34 @@ class MessageMatcherTest < Test::Unit::TestCase
     Droonga::MessageMatcher.new(pattern)
   end
 
-  class ResolvePathTest < self
-    def resolve_path(path, message)
-      matcher(nil).send(:resolve_path, path, message)
+  class ExtractTargetTest < self
+    def extract_target(path, message)
+      matcher([path]).send(:extract_target, message)
     end
 
     def test_nonexistent
       assert_equal(Droonga::MessageMatcher::NONEXISTENT_PATH,
-                   resolve_path("nonexistent.path", {}))
+                   extract_target("nonexistent.path", {}))
     end
 
     def test_top_level
       assert_equal("select",
-                   resolve_path("type",
-                                {
-                                  "type" => "select"
-                                }))
+                   extract_target("type",
+                                  {
+                                    "type" => "select"
+                                  }))
     end
 
     def test_nested
       assert_equal(10,
-                   resolve_path("body.output.limit",
-                                {
-                                  "body" => {
-                                    "output" => {
-                                      "limit" => 10,
+                   extract_target("body.output.limit",
+                                  {
+                                    "body" => {
+                                      "output" => {
+                                        "limit" => 10,
+                                      },
                                     },
-                                  },
-                                }))
+                                  }))
     end
   end