droonga-engine 1.0.1

data/test/unit/plugins/test_groonga.rb

@@ -0,0 +1,70 @@
+# 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/plugins/groonga"
+
+class GroongaHandlerTest < Test::Unit::TestCase
+  include PluginHelper
+
+  def setup
+    setup_database
+    setup_plugin
+  end
+
+  def teardown
+    teardown_plugin
+    teardown_database
+  end
+
+  private
+  def setup_plugin
+    @handler = Droonga::Test::StubHandler.new
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+    @loop = nil
+  end
+
+  def teardown_plugin
+  end
+
+  def dump
+    database_dumper = Groonga::DatabaseDumper.new(:database => @database)
+    database_dumper.dump
+  end
+
+  def process(command, request)
+    message = Droonga::Test::StubHandlerMessage.new(request)
+    handler = create_handler
+    handler.handle(message)
+  end
+
+  NORMALIZED_START_TIME = Time.parse("2013-07-11T16:04:28+0900").to_i
+  NORMALIZED_ELAPSED_TIME = 1
+  def normalize_header(header)
+    start_time = NORMALIZED_START_TIME
+    elapsed_time = NORMALIZED_ELAPSED_TIME
+    [header[0], start_time, elapsed_time]
+  end
+
+  NORMALIZED_HEADER_SUCCESS = [
+    Droonga::Plugins::Groonga::Status::SUCCESS,
+    NORMALIZED_START_TIME,
+    NORMALIZED_ELAPSED_TIME,
+  ]
+  NORMALIZED_HEADER_INVALID_ARGUMENT = [
+    Droonga::Plugins::Groonga::Status::INVALID_ARGUMENT,
+    NORMALIZED_START_TIME,
+    NORMALIZED_ELAPSED_TIME,
+  ]
+end

data/test/unit/plugins/test_watch.rb

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+#
+# 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/plugins/watch"
+
+class WatchHandlerTest < Test::Unit::TestCase
+  include WatchHelper
+
+  SUCCESS_RESULT = true
+
+  def setup
+    setup_database
+    setup_schema
+    setup_plugin
+  end
+
+  def teardown
+    teardown_plugin
+    teardown_database
+  end
+
+  private
+  def setup_plugin
+    @handler = Droonga::Test::StubHandler.new
+    @messenger = Droonga::Test::StubHandlerMessenger.new
+    @loop = nil
+  end
+
+  def teardown_plugin
+    @plugin = nil
+  end
+
+  def process(command, request, headers={})
+    message = Droonga::Test::StubHandlerMessage.new(request, headers)
+    create_plugin.handle(message)
+  end
+
+  public
+  class SubscribeTest < self
+    def create_plugin
+      Droonga::Plugins::Watch::SubscribeHandler.new("droonga",
+                                                    @handler.context,
+                                                    @messenger,
+                                                    @loop)
+    end
+
+    def test_subscribe
+      request = {
+        "route" => "localhost:23003/output",
+        "condition" => "たいやき",
+        "subscriber" => "localhost"
+      }
+      response = process(:subscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
+
+      assert_equal(
+        ["localhost:23003/output"],
+        actual_routes_for_query("たいやき")
+      )
+    end
+
+    def test_subscribe_route_omitted_from_specified
+      request = {
+        "condition" => "たいやき",
+        "subscriber" => "localhost"
+      }
+      response = process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal(SUCCESS_RESULT, response)
+
+      assert_equal(
+        ["localhost:23004/output"],
+        actual_routes_for_query("たいやき")
+      )
+    end
+
+    def test_subscribe_both_route_and_from_specified
+      request = {
+        "condition" => "たいやき",
+        "subscriber" => "localhost",
+        "route" => "localhost:23003/output"
+      }
+      response = process(:subscribe, request, "from" => "localhost:23004/output")
+      assert_equal(SUCCESS_RESULT, response)
+
+      assert_equal(
+        ["localhost:23003/output"],
+        actual_routes_for_query("たいやき")
+      )
+    end
+
+    private
+    def actual_routes_for_query(query)
+      @handler.context["Subscriber"].select {|record|
+        record[:subscriptions] =~ query.to_json
+      }.map {|subscriber|
+        subscriber.route.key
+      }
+    end
+  end
+
+  class UnsubscribeTest < self
+    def setup
+      super
+      setup_subscription
+    end
+
+    def create_plugin
+      Droonga::Plugins::Watch::UnsubscribeHandler.new("droonga",
+                                                      @handler.context,
+                                                      @messenger,
+                                                      @loop)
+    end
+
+    def test_unsubscribe
+      request = {
+        "route" => "localhost:23003/output",
+        "condition" => "たいやき",
+        "subscriber" => "localhost"
+      }
+      response = process(:unsubscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
+    end
+
+    private
+    def setup_subscription
+      request = {
+        "route" => "localhost:23003/output",
+        "condition" => "たいやき",
+        "subscriber" => "localhost"
+      }
+      response = process(:subscribe, request)
+      assert_equal(SUCCESS_RESULT, response)
+    end
+  end
+
+  class FeedTest < self
+    def setup
+      super
+      setup_subscription
+    end
+
+    def create_plugin
+      Droonga::Plugins::Watch::FeedHandler.new("droonga",
+                                               @handler.context,
+                                               @messenger,
+                                               @loop)
+    end
+
+    def test_feed_match
+      request = {
+        "targets" => {
+          "text" => "たいやきおいしいです"
+        }
+      }
+      process(:feed, request)
+      assert_equal([
+                     [
+                       {
+                         "body" => request,
+                         "to" => ["localhost"],
+                       },
+                       {
+                         "to"   => "localhost:23003/output",
+                         "type" => "watch.publish",
+                       },
+                     ],
+                   ],
+                   @messenger.messages)
+    end
+
+    def test_feed_not_match
+      request = {
+        "targets" => {
+          "text" => "たこやきおいしいです"
+        }
+      }
+      assert_nil(process(:feed, request))
+    end
+
+    private
+    def setup_subscription
+      request = {
+        "route" => "localhost:23003/output",
+        "condition" => "たいやき",
+        "subscriber" => "localhost"
+      }
+      message = Droonga::Test::StubHandlerMessage.new(request, {})
+      subscribe_handler =
+        Droonga::Plugins::Watch::SubscribeHandler.new("droonga",
+                                                      @handler.context,
+                                                      @messenger,
+                                                      @loop)
+      response = subscribe_handler.handle(message)
+      assert_equal(SUCCESS_RESULT, response)
+    end
+  end
+end

data/test/unit/run-test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 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 "pathname"
+
+require "rubygems"
+require "bundler"
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require "test-unit"
+require "test/unit/notify"
+require "test/unit/rr"
+
+require "cool.io"
+
+$VERBOSE = true
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test", "unit")
+
+$LOAD_PATH.unshift(lib_dir)
+
+require "droonga/engine"
+require "droonga/plugin_loader"
+
+Droonga::PluginLoader.load_all
+
+$LOAD_PATH.unshift(test_dir)
+
+require "helper"
+
+ARGV.unshift("--max-diff-target-string-size=10000")
+
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/test/unit/test_catalog_generator.rb

@@ -0,0 +1,93 @@
+# 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_generator"
+
+class CatalogGeneratorTest < Test::Unit::TestCase
+  def setup
+    @generator = Droonga::CatalogGenerator.new
+    @normalized_time_value = "2014-02-09T00:00:00Z"
+  end
+
+  def generate
+    normalize_catalog(@generator.generate)
+  end
+
+  def normalize_catalog(catalog)
+    normalize_time(catalog, "effectiveDate")
+    catalog
+  end
+
+  def normalize_time(catalog, key)
+    begin
+      Time.iso8601(catalog[key])
+    rescue ArgumentError
+      # Do nothing for invalid time value
+    else
+      catalog[key] = @normalized_time_value
+    end
+  end
+
+  def test_default
+    catalog = {
+      "version" => 2,
+      "effectiveDate" => @normalized_time_value,
+      "datasets" => {
+      },
+    }
+    assert_equal(catalog, generate)
+  end
+
+  class DatasetTest < self
+    def test_default
+      @generator.add_dataset("Droonga", {})
+      dataset = {
+        "nWorkers" => 4,
+        "plugins" => ["groonga", "search", "crud"],
+        "schema" => {},
+        "replicas" => [
+          {
+            "dimension" => "_key",
+            "slicer" => "hash",
+            "slices" => [
+              {
+                "volume" => {
+                  "address" => "127.0.0.1:10031/droonga.000",
+                },
+                "weight" => 100,
+              },
+            ],
+          },
+        ],
+      }
+      assert_equal(dataset, generate["datasets"]["Droonga"])
+    end
+
+    def test_n_workers
+      @generator.add_dataset("Droonga", :n_workers => 3)
+      assert_equal(3, generate["datasets"]["Droonga"]["nWorkers"])
+    end
+
+    def test_plugins
+      @generator.add_dataset("Droonga", :plugins => ["search"])
+      assert_equal(["search"], generate["datasets"]["Droonga"]["plugins"])
+    end
+
+    def test_fact
+      @generator.add_dataset("Droonga", :fact => "Entries")
+      assert_equal("Entries", generate["datasets"]["Droonga"]["fact"])
+    end
+  end
+end

data/test/unit/test_message_matcher.rb

@@ -0,0 +1,160 @@
+# 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/message_matcher"
+
+class MessageMatcherTest < Test::Unit::TestCase
+  def matcher(pattern)
+    Droonga::MessageMatcher.new(pattern)
+  end
+
+  class ExtractTargetTest < self
+    def extract_target(path, message)
+      matcher([path]).send(:extract_target, message)
+    end
+
+    def test_nonexistent
+      assert_equal(Droonga::MessageMatcher::NONEXISTENT_PATH,
+                   extract_target("nonexistent.path", {}))
+    end
+
+    def test_top_level
+      assert_equal("select",
+                   extract_target("type",
+                                  {
+                                    "type" => "select"
+                                  }))
+    end
+
+    def test_nested
+      assert_equal(10,
+                   extract_target("body.output.limit",
+                                  {
+                                    "body" => {
+                                      "output" => {
+                                        "limit" => 10,
+                                      },
+                                    },
+                                  }))
+    end
+  end
+
+  class MatchTest < self
+    def match?(pattern, message)
+      matcher(pattern).match?(message)
+    end
+
+    class EqualTest < self
+      def test_same_value
+        assert_true(match?(["type", :equal, "select"],
+                           {
+                             "type" => "select"
+                           }))
+      end
+
+      def test_different_value
+        assert_false(match?(["type", :equal, "select"],
+                            {
+                              "type" => "search",
+                            }))
+      end
+    end
+
+    class InTest < self
+      def test_exist
+        assert_true(match?(["type", :in, ["table_create", "table_remove"]],
+                           {
+                             "type" => "table_remove"
+                           }))
+      end
+
+      def test_not_exist
+        assert_false(match?(["type", :in, ["table_create", "table_remove"]],
+                            {
+                              "type" => "column_create",
+                            }))
+      end
+    end
+
+    class IncludeTest < self
+      def test_exist
+        assert_true(match?(["originalTypes", :include, "select"],
+                           {
+                             "originalTypes" => ["search", "select"],
+                           }))
+      end
+
+      def test_not_exist
+        assert_false(match?(["originalTypes", :include, "select"],
+                            {
+                              "originalTypes" => ["load"],
+                            }))
+      end
+
+      def test_no_key
+        assert_false(match?(["originalTypes", :include, "select"],
+                            {}))
+      end
+
+      def test_not_enumerable
+        assert_false(match?(["originalTypes", :include, "select"],
+                            {
+                              "originalTypes" => 29,
+                            }))
+      end
+    end
+
+    class ExistTest < self
+      def test_exist
+        assert_true(match?(["body.result", :exist],
+                           {
+                             "body" => {
+                               "result" => nil,
+                             },
+                           }))
+      end
+
+      def test_not_exist
+        assert_false(match?(["body.result", :exist],
+                            {
+                              "body" => nil,
+                            }))
+      end
+    end
+
+    class StartWithTest < self
+      def test_start_with
+        assert_true(match?(["type", :start_with, "watch."],
+                           {
+                             "type" => "watch.subscribe",
+                           }))
+      end
+
+      def test_not_start_with
+        assert_false(match?(["type", :start_with, "watch."],
+                            {
+                              "type" => "table_create",
+                            }))
+      end
+
+      def test_nil_value
+        assert_false(match?(["type", :start_with, "watch."],
+                            {
+                              "type" => nil,
+                            }))
+      end
+    end
+  end
+end

data/test/unit/test_schema_applier.rb

@@ -0,0 +1,59 @@
+# 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/schema_applier"
+
+class SchemaCreatorTest < Test::Unit::TestCase
+  include Sandbox
+
+  def setup
+    setup_database
+    @context = Groonga::Context.default
+  end
+
+  def teardown
+    teardown_database
+  end
+
+  def apply(schema_data)
+    schema = Droonga::Catalog::Schema.new("dataset", schema_data)
+    applier = Droonga::SchemaApplier.new(@context, schema)
+    applier.apply
+  end
+
+  def dump
+    dumper = Groonga::SchemaDumper.new(:context => @context, :syntax => :command)
+    dumper.dump
+  end
+
+  def test_reference_table
+    schema_data = {
+      "Users" => {
+        "type" => "Hash",
+        "keyType" => "Names",
+      },
+      "Names" => {
+        "type" => "Hash",
+        "keyType" => "ShortText",
+      },
+    }
+    apply(schema_data)
+    assert_equal(<<-DUMP, dump)
+table_create Names TABLE_HASH_KEY --key_type ShortText
+
+table_create Users TABLE_HASH_KEY --key_type Names
+    DUMP
+  end
+end