droonga-engine 1.0.1

data/test/command/suite/search/sort/default-offset-limit.test

@@ -0,0 +1,24 @@
+#@include fixture/documents.jsons
+{
+  "type": "search",
+  "dataset": "Droonga",
+  "body": {
+    "queries": {
+      "result": {
+        "source": "Sections",
+        "sortBy": {
+          "keys": ["-_key"]
+        },
+        "output": {
+          "elements": [
+            "count",
+            "attributes",
+            "records"
+          ],
+          "limit": -1,
+          "attributes": ["_key"]
+        }
+      }
+    }
+  }
+}

data/test/command/suite/search/sort/invisible-column.expected

@@ -0,0 +1,24 @@
+{
+  "inReplyTo": "request-id",
+  "statusCode": 200,
+  "type": "search.result",
+  "body": {
+    "result": {
+      "count": 9,
+      "records": [
+        [
+          "Groonga library"
+        ],
+        [
+          "Geo-location (latitude and longitude) search"
+        ],
+        [
+          "Sharable storage and read lock-free"
+        ],
+        [
+          "Inverted index and tokenizer"
+        ]
+      ]
+    }
+  }
+}

data/test/command/suite/search/sort/invisible-column.test

@@ -0,0 +1,26 @@
+#@include fixture/documents.jsons
+{
+  "type": "search",
+  "dataset": "Droonga",
+  "body": {
+    "queries": {
+      "result": {
+        "source": "Sections",
+        "sortBy": {
+          "keys": ["-_key"],
+          "offset": 2,
+          "limit": 4
+        },
+        "output": {
+          "elements": [
+            "count",
+            "attributes",
+            "records"
+          ],
+          "limit": -1,
+          "attributes": ["title"]
+        }
+      }
+    }
+  }
+}

data/test/command/suite/watch/subscribe.expected

@@ -0,0 +1,6 @@
+{
+  "inReplyTo": "request-id",
+  "statusCode": 200,
+  "type": "watch.subscribe.result",
+  "body": true
+}

data/test/command/suite/watch/subscribe.test

@@ -0,0 +1,9 @@
+{
+  "type": "watch.subscribe",
+  "dataset": "Watch",
+  "body": {
+    "condition": "condition",
+    "subscriber": "subscriber",
+    "route": "127.0.0.1:23003/output"
+  }
+}

data/test/command/suite/watch/unsubscribe.expected

@@ -0,0 +1,6 @@
+{
+  "inReplyTo": "request-id",
+  "statusCode": 200,
+  "type": "watch.unsubscribe.result",
+  "body": true
+}

data/test/command/suite/watch/unsubscribe.test

@@ -0,0 +1,9 @@
+{
+  "type": "watch.unsubscribe",
+  "dataset": "Watch",
+  "body": {
+    "condition": "condition",
+    "subscriber": "subscriber",
+    "route": "127.0.0.1:23003/output"
+  }
+}

data/test/performance/run-test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+#
+# 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 "rbconfig"
+require "fileutils"
+
+def run(*command_line)
+  command_line = command_line.collect do |argument|
+    argument.to_s
+  end
+  return if system(*command_line)
+  puts("failed to run: #{command_line.join(' ')}")
+  exit(false)
+end
+
+base_dir = File.dirname(__FILE__)
+lib_dir = File.expand_path(File.join(base_dir, "..", "..", "lib"))
+
+drnbench_options = []
+drnbench_options.concat(["--start-n-subscribers", 10])
+drnbench_options.concat(["--n-publishings", 10])
+drnbench_options.concat(["--n-steps", 9])
+drnbench_options.concat(["--timeout", 5])
+drnbench_options.concat(["--subscribe-request-file",
+                         File.join(base_dir, "watch", "subscribe.json")])
+drnbench_options.concat(["--feed-file",
+                         File.join(base_dir, "watch", "feed.json")])
+
+protocol_adapter_dir = File.join(base_dir, "..", "..", "..", "express-droonga")
+if File.exist?(protocol_adapter_dir)
+  drnbench_options.concat(["--protocol-adapter-application-dir", protocol_adapter_dir])
+  drnbench_options.concat(["--protocol-adapter-port", 13000])
+end
+
+drnbench_options.concat(["--engine-config-path",
+                         File.join(base_dir, "watch")])
+drnbench_options.concat(["--fluentd-options", "-I#{lib_dir}"])
+drnbench_options.concat(ARGV)
+
+drnbench_publish_subscribe = Gem.bin_path("drnbench",
+                                          "drnbench-publish-subscribe")
+run(drnbench_publish_subscribe, *drnbench_options)

data/test/performance/watch/catalog.json

@@ -0,0 +1,33 @@
+{
+  "versoin": 1,
+  "effective_date": "2013-09-01T00:00:00Z",
+  "zones": ["localhost:23003/droonga"],
+  "farms": {
+    "localhost:23003/droonga": {
+      "device": ".",
+      "capacity": 10
+    }
+  },
+  "datasets": {
+    "Watch": {
+      "workers": 2,
+      "plugins": ["search", "groonga", "add", "watch"],
+      "number_of_replicas": 1,
+      "number_of_partitions": 1,
+      "partition_key": "_key",
+      "date_range": "infinity",
+      "ring": {
+        "localhost:23041": {
+          "weight": 50,
+          "partitions": {
+            "2013-09-01": [
+              "localhost:23003/droonga.watch"
+            ]
+          }
+        }
+      }
+    }
+  },
+  "options": {
+  }
+}

data/test/performance/watch/feed.json

@@ -0,0 +1,9 @@
+{
+  "type":    "watch.feed",
+  "dataset": "Watch",
+  "body":    {
+    "targets": {
+      "body": "a content including the keyword"
+    }
+  }
+}

data/test/performance/watch/fluentd.conf

@@ -0,0 +1,11 @@
+<source>
+  type forward
+  port 23003
+</source>
+<match droonga.message>
+  name localhost:23003/droonga
+  type droonga
+</match>
+<match output.message>
+  type stdout
+</match>

data/test/performance/watch/subscribe.json

@@ -0,0 +1,3 @@
+{
+  "path": "/droonga-streaming/watch?condition=keyword"
+}

data/test/unit/catalog/test_collection_volume.rb

@@ -0,0 +1,103 @@
+# 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 CatalogSingleVolumeTest < Test::Unit::TestCase
+  def create_collection_volume(data)
+    minimum_dataset_data = {
+      "replicas" => {
+      },
+    }
+    dataset = Droonga::Catalog::Dataset.new("DatasetName", minimum_dataset_data)
+    Droonga::Catalog::CollectionVolume.new(dataset, data)
+  end
+
+  class DimensionTest < self
+    def test_default
+      data = {
+        "slices" => [],
+      }
+      volume = create_collection_volume(data)
+      assert_equal("_key", volume.dimension)
+    end
+
+    def test_specified
+      data = {
+        "dimension" => "group",
+        "slices" => [],
+      }
+      volume = create_collection_volume(data)
+      assert_equal("group", volume.dimension)
+    end
+  end
+
+  class SlicerTest < self
+    def test_default
+      data = {
+        "slices" => [],
+      }
+      volume = create_collection_volume(data)
+      assert_equal("hash", volume.slicer)
+    end
+
+    def test_specified
+      data = {
+        "slicer" => "ordinal",
+      }
+      volume = create_collection_volume(data)
+      assert_equal("ordinal", volume.slicer)
+    end
+  end
+
+  class SlicesTest < self
+    def test_empty
+      data = {
+        "slices" => [],
+      }
+      volume = create_collection_volume(data)
+      assert_equal([], volume.slices)
+    end
+  end
+
+  class RatioOrderSlicerTest < self
+    class TotalWeightTest < self
+      def test_three_slices
+        data = {
+          "slicer" => "hash",
+          "slices" => [
+            {
+              "weight" => 10,
+            },
+            {
+              "weight" => 20,
+            },
+            {
+              "weight" => 30,
+            },
+          ],
+        }
+        assert_equal(10 + 20 + 30,
+                     total_weight(data))
+      end
+
+      private
+      def total_weight(data)
+        volume = create_collection_volume(data)
+        volume.send(:compute_total_weight)
+      end
+    end
+  end
+end

data/test/unit/catalog/test_dataset.rb

@@ -0,0 +1,104 @@
+# 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 CatalogDatasetTest < Test::Unit::TestCase
+  private
+  def create_dataset(data)
+    Droonga::Catalog::Dataset.new("DatasetName", data)
+  end
+
+  class NameTest < self
+    def test_reader
+      dataset = Droonga::Catalog::Dataset.new("DatasetName", {})
+      assert_equal("DatasetName", dataset.name)
+    end
+  end
+
+  class NWorkersTest < self
+    def test_default
+      data = {
+      }
+      dataset = create_dataset(data)
+      assert_equal(0, dataset.n_workers)
+    end
+
+    def test_specified
+      data = {
+        "nWorkers" => 2
+      }
+      dataset = create_dataset(data)
+      assert_equal(2, dataset.n_workers)
+    end
+  end
+
+  class SchemaTest < self
+    def test_empty
+      data = {
+        "schema" => {
+        }
+      }
+      dataset = create_dataset(data)
+      assert_equal(Droonga::Catalog::Schema.new("dataset_name", {}),
+                   dataset.schema)
+    end
+  end
+
+  class PluginsTest < self
+    def test_default
+      data = {
+      }
+      dataset = create_dataset(data)
+      assert_equal([], dataset.plugins)
+    end
+
+    def test_multiple
+      data = {
+        "plugins" => ["groonga", "crud"],
+      }
+      dataset = create_dataset(data)
+      assert_equal(["groonga", "crud"], dataset.plugins)
+    end
+  end
+
+  class FactTest < self
+    def test_default
+      data = {
+      }
+      dataset = create_dataset(data)
+      assert_nil(dataset.fact)
+    end
+
+    def test_specified
+      data = {
+        "fact" => "Users",
+      }
+      dataset = create_dataset(data)
+      assert_equal("Users", dataset.fact)
+    end
+  end
+
+  class ReplicasTest < self
+    def test_empty
+      data = {
+        "replicas" => [],
+      }
+      dataset = create_dataset(data)
+      assert_equal(Droonga::Catalog::VolumeCollection.new([]),
+                   dataset.replicas)
+    end
+  end
+end

data/test/unit/catalog/test_schema.rb

@@ -0,0 +1,226 @@
+# 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
+  class SchemaTest < self
+    def create_schema(dataset_name, data)
+      Droonga::Catalog::Schema.new(dataset_name, data)
+    end
+  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
+
+      class TypeTest < self
+        def type(data)
+          create_table("table_name", data).type
+        end
+
+        def test_default
+          assert_equal("Hash", type({}))
+        end
+
+        def test_array
+          create_table("Array", type("Array"))
+        end
+      end
+
+      class TypeSymbolTest < self
+        def type_symbol(type)
+          data = {
+            "type" => type,
+          }
+          create_table("table_name", data).type_symbol
+        end
+
+        def test_array
+          assert_equal(:array, type_symbol("Array"))
+        end
+
+        def test_hash
+          assert_equal(:hash, type_symbol("Hash"))
+        end
+
+        def test_patricia_trie
+          assert_equal(:patricia_trie, type_symbol("PatriciaTrie"))
+        end
+
+        def test_double_array_trie
+          assert_equal(:double_array_trie, type_symbol("DoubleArrayTrie"))
+        end
+      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
+    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
+
+      class TypeTest < self
+        def type(data)
+          create_column("column_name", data).type
+        end
+
+        def test_scalar
+          assert_equal("Scalar", type("type" => "Scalar"))
+        end
+
+        def test_default
+          assert_equal("Scalar", type({}))
+        end
+      end
+
+      class TypeSymbolTest < self
+        def type_symbol(type)
+          data = {
+            "type" => type,
+          }
+          create_column("column_name", data).type_symbol
+        end
+
+        def test_scalar
+          assert_equal(:scalar, type_symbol("Scalar"))
+        end
+
+        def test_vector
+          assert_equal(:vector, type_symbol("Vector"))
+        end
+
+        def test_index
+          assert_equal(:index, type_symbol("Index"))
+        end
+      end
+
+      class ValueType < self
+        def value_type(data)
+          create_column("column_name", data).value_type
+        end
+
+        def test_data_type
+          assert_equal("ShortText", value_type("valueType" => "ShortText"))
+        end
+
+        def test_reference_type
+          assert_equal("Users", value_type("valueType" => "Users"))
+        end
+
+        def test_default
+          assert_nil(value_type({}))
+        end
+      end
+
+      class ValueTypeGroonga < self
+        def value_type_groonga(type)
+          data = {
+            "valueType" => type,
+          }
+          create_column("column_name", data).value_type_groonga
+        end
+
+        def test_integer
+          assert_equal("Int64", value_type_groonga("Integer"))
+        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
+    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
+    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