fluent-plugin-droonga 0.0.2

data/test/test_handler.rb

@@ -0,0 +1,53 @@
+# 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 "droonga/handler"
+
+class HandlerTest < Test::Unit::TestCase
+  class HandlableTest < self
+    class SearchHandler < Droonga::Handler
+      command :search
+      def search(request)
+        :search_response
+      end
+    end
+
+    class StatusHandler < Droonga::Handler
+      command :status
+      def status(request)
+        :status_response
+      end
+    end
+
+    class Worker
+      def context
+        nil
+      end
+    end
+
+    def setup
+      context = Worker.new
+      @search_handler = SearchHandler.new(context)
+    end
+
+    def test_true
+      assert_true(@search_handler.handlable?(:search))
+    end
+
+    def test_false
+      assert_false(@search_handler.handlable?(:status))
+    end
+  end
+end

data/test/test_job_queue_schema.rb

@@ -0,0 +1,45 @@
+# 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 "helper"
+
+require "droonga/job_queue_schema"
+
+class JobQueueSchemaTest < Test::Unit::TestCase
+  def setup
+    @database_path = @temporary_directory + "droonga/db"
+    @queue_name = "DroongaQueue"
+  end
+
+  def test_ensure_created
+    schema = Droonga::JobQueueSchema.new(@database_path.to_s, @queue_name)
+
+    assert_not_predicate(@database_path, :exist?)
+    schema.ensure_created
+    assert_predicate(@database_path, :exist?)
+
+    context = Groonga::Context.new
+    dumped_commands = nil
+    context.open_database(@database_path.to_s) do |database|
+      dumped_commands = Groonga::DatabaseDumper.dump(:context => context,
+                                                     :database => database)
+    end
+    context.close
+    assert_equal(<<-SCHEMA, dumped_commands)
+table_create #{@queue_name} TABLE_NO_KEY
+column_create #{@queue_name} message COLUMN_SCALAR Text
+SCHEMA
+  end
+end

data/test/test_output.rb

@@ -0,0 +1,99 @@
+# 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 "fluent/plugin/out_droonga"
+
+module OutputStub
+  class Worker
+    attr_reader :processed_record
+    def initialize(response)
+      @response = response
+      @processed_record = nil
+    end
+
+    def dispatch(tag, time, record)
+      @processed_record = record
+      @response
+    end
+
+    def shutdown
+    end
+  end
+
+  class Logger
+    attr_reader :tag, :options
+    attr_reader :posted_tag, :posted_message
+    def initialize(tag, options)
+      @tag = tag
+      @options = options
+    end
+
+    def post(tag, message)
+      @posted_tag = tag
+      @posted_message = message
+    end
+
+    def close
+    end
+  end
+
+  class Output < Fluent::DroongaOutput
+    attr_reader :worker
+    def initialize(response)
+      @response = response
+      super()
+    end
+
+    def start
+      @worker = Worker.new(@response)
+    end
+
+    def create_logger(tag, options)
+      Logger.new(tag, options)
+    end
+  end
+end
+
+class OutputTest < Test::Unit::TestCase
+  setup
+  def setup_fluent
+    Fluent::Test.setup
+  end
+
+  def test_exec
+    response = {}
+    driver = create_driver("droonga.message", response)
+    request = {"hello" => "world"}
+    time = Time.parse("2012-10-26T08:45:42Z").to_i
+    driver.run do
+      driver.emit(request, time)
+    end
+    assert_equal(request, @output.worker.processed_record)
+  end
+
+  private
+  def create_driver(tag, response)
+    @output = OutputStub::Output.new(response)
+    driver = Fluent::Test::OutputTestDriver.new(@output, tag)
+    driver.configure(configuration)
+    driver
+  end
+
+  def configuration
+    <<-EOC
+n_workers 0
+EOC
+  end
+end

data/test/test_sweeper.rb

@@ -0,0 +1,95 @@
+# -*- 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 "droonga/watcher"
+require "droonga/sweeper"
+
+class SweeperTest < Test::Unit::TestCase
+  include WatchHelper
+
+  def setup
+    setup_database
+    setup_schema
+    @context = Groonga::Context.default
+    @watcher = Droonga::Watcher.new(@context)
+    @sweeper = Droonga::Sweeper.new(@context)
+  end
+
+  def teardown
+    @watcher = nil
+    @sweeper = nil
+    teardown_database
+  end
+
+  private
+  def subscriber_table
+    @context["Subscriber"]
+  end
+
+  def existing_subscribers
+    subscriber_table.select.collect(&:_key)
+  end
+
+  public
+  class SweepSubscribersTest < self
+    NINE_MINUTES_IN_SECONDS   = 9 * 60
+    TEN_MINUTES_IN_SECONDS    = 10 * 60
+    ELEVEN_MINUTES_IN_SECONDS = 11 * 60
+
+    def setup
+      super
+      @now = Time.now
+      setup_expired_subscribers
+    end
+
+    def test_single_term
+      @sweeper.sweep_expired_subscribers(:now => @now)
+      assert_equal(
+        ["subscriber1", "subscriber2"],
+        existing_subscribers
+      )
+    end
+
+    private
+    def setup_expired_subscribers
+      request1 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber1",
+      }
+      @watcher.subscribe(request1)
+      request2 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber2",
+      }
+      @watcher.subscribe(request2)
+      request3 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber3",
+      }
+      @watcher.subscribe(request3)
+      subscriber_table["subscriber1"].last_modified = @now - NINE_MINUTES_IN_SECONDS
+      subscriber_table["subscriber2"].last_modified = @now - TEN_MINUTES_IN_SECONDS
+      subscriber_table["subscriber3"].last_modified = @now - ELEVEN_MINUTES_IN_SECONDS
+    end
+  end
+end

data/test/test_watch_schema.rb

@@ -0,0 +1,57 @@
+# 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 "helper"
+
+require "droonga/watch_schema"
+
+class WatchSchemaTest < Test::Unit::TestCase
+  def setup
+    @database_path = @temporary_directory + "droonga/watch/db"
+    @context = Groonga::Context.default
+    FileUtils.mkdir_p(File.dirname(@database_path))
+    @context.create_database(@database_path.to_s)
+  end
+
+  def test_ensure_created
+    schema = Droonga::WatchSchema.new(@context)
+    schema.ensure_created
+
+    dumped_commands = nil
+    @context.open_database(@database_path.to_s) do |database|
+      dumped_commands = Groonga::DatabaseDumper.dump(:context => @context,
+                                                     :database => database)
+    end
+    assert_equal(<<-SCHEMA, dumped_commands)
+table_create Keyword TABLE_PAT_KEY|KEY_NORMALIZE --key_type ShortText
+
+table_create Query TABLE_HASH_KEY --key_type ShortText
+
+table_create Route TABLE_HASH_KEY --key_type ShortText
+
+table_create Subscriber TABLE_HASH_KEY --key_type ShortText
+column_create Subscriber last_modified COLUMN_SCALAR Time
+
+column_create Query keywords COLUMN_VECTOR Keyword
+
+column_create Subscriber route COLUMN_SCALAR Route
+column_create Subscriber subscriptions COLUMN_VECTOR Query
+
+column_create Keyword queries COLUMN_INDEX Query keywords
+
+column_create Query subscribers COLUMN_INDEX Subscriber subscriptions
+SCHEMA
+  end
+end

data/test/test_watcher.rb

@@ -0,0 +1,336 @@
+# -*- 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 "droonga/watcher"
+
+class WatcherTest < Test::Unit::TestCase
+  include WatchHelper
+
+  def setup
+    setup_database
+    setup_schema
+    setup_watcher
+  end
+
+  def teardown
+    teardown_watcher
+    teardown_database
+  end
+
+  private
+  def setup_watcher
+    @context = Groonga::Context.default
+    @watcher = Droonga::Watcher.new(@context)
+  end
+
+  def teardown_watcher
+    @watcher = nil
+  end
+
+  def subscriber_table
+    @context["Subscriber"]
+  end
+
+  def query_table
+    @context["Query"]
+  end
+
+  def keyword_table
+    @context["Keyword"]
+  end
+
+  def existing_subscribers
+    subscriber_table.select.collect(&:_key)
+  end
+
+  def existing_queries
+    query_table.select.collect(&:_key)
+  end
+
+  def existing_keywords
+    keyword_table.select.collect(&:_key)
+  end
+
+  def existing_records
+    {
+      :subscribers => existing_subscribers,
+      :queries => existing_queries,
+      :keywords => existing_keywords,
+     }
+  end
+
+  def normalize_subscriber(subscriber)
+    return nil if subscriber.nil?
+    {
+      :_key => subscriber._key,
+      :subscriptions => subscriber.subscriptions.collect(&:_key),
+      :route => subscriber.route._key,
+    }
+  end
+
+  def normalize_queries(queries)
+    return nil if queries.nil?
+    queries.collect do |query|
+      normalize_query(query)
+    end
+  end
+
+  def normalize_query(query)
+    return nil if query.nil?
+    {
+      :_key => query._key,
+      :keywords => query.keywords.collect(&:_key),
+    }
+  end
+
+  public
+  class SubscribeTest < self
+    def test_single_term
+      request = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "localhost",
+      }
+      @watcher.subscribe(request)
+
+      assert_equal(
+        {:subscribers => ["localhost"],
+         :queries => ["たいやき".to_json],
+         :keywords => ["たいやき"]},
+        existing_records
+      )
+      assert_equal(
+        {:_key => "localhost",
+         :subscriptions => ["たいやき".to_json],
+         :route => "localhost:23003/output"},
+        normalize_subscriber(subscriber_table.first)
+      )
+      assert_equal(
+        [{:_key => "たいやき".to_json, :keywords => ["たいやき"]}],
+        normalize_queries(subscriber_table.first.subscriptions)
+      )
+    end
+
+=begin
+# this test will be activated when condition with multiple tabs is supproted.
+    def test_multiple_terms
+      request = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき たこやき",
+        :query => "たいやき たこやき".to_json,
+        :subscriber => "localhost",
+      }
+      @watcher.subscribe(request)
+
+      assert_equal(["localhost"], existing_subscribers)
+      assert_equal(
+        {:_key => "localhost",
+         :subscriptions => ["たいやき たこやき".to_json],
+         :route => "localhost:23003/output"},
+        normalize_subscriber(subscriber_table.first)
+      )
+      assert_equal(["たいやき たこやき".to_json], existing_queries)
+      assert_equal(["たいやき", "たこやき"], existing_keywords)
+    end
+=end
+
+    def test_same_condition_multiple_times
+      request = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "localhost",
+      }
+      @watcher.subscribe(request)
+      @watcher.subscribe(request)
+      assert_equal(
+        {:subscribers => ["localhost"],
+         :queries => ["たいやき".to_json],
+         :keywords => ["たいやき"]},
+        existing_records
+      )
+    end
+
+    def test_different_conditions
+      request1 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "localhost",
+      }
+      @watcher.subscribe(request1)
+      request2 = {
+        :route => "localhost:23003/output",
+        :condition => "たこやき",
+        :query => "たこやき".to_json,
+        :subscriber => "localhost",
+      }
+      @watcher.subscribe(request2)
+      assert_equal(
+        {:subscribers => ["localhost"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+      assert_equal(
+        {:_key => "localhost",
+         :subscriptions => ["たいやき".to_json, "たこやき".to_json],
+         :route => "localhost:23003/output"},
+        normalize_subscriber(subscriber_table.first)
+      )
+    end
+
+    def test_multiple_subscribers
+      request = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber1",
+      }
+      @watcher.subscribe(request)
+      request = {
+        :route => "localhost:23003/output",
+        :condition => "たこやき",
+        :query => "たこやき".to_json,
+        :subscriber => "subscriber2",
+      }
+      @watcher.subscribe(request)
+      assert_equal(
+        {:subscribers => ["subscriber1", "subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+      assert_equal([["たいやき".to_json],
+                    ["たこやき".to_json]],
+                   [subscriber_table["subscriber1"].subscriptions.collect(&:_key),
+                    subscriber_table["subscriber2"].subscriptions.collect(&:_key)])
+    end
+  end
+
+  class UnsubscribeTest < self
+    def setup
+      super
+      setup_subscriptions
+    end
+
+    def test_with_query_multiple_times
+      @watcher.unsubscribe(
+        :route => "localhost:23003/output",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber1",
+      )
+      assert_equal(
+        {:subscribers => ["subscriber1", "subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+
+      @watcher.unsubscribe(
+        :route => "localhost:23003/output",
+        :query => "たこやき".to_json,
+        :subscriber => "subscriber1",
+      )
+      assert_equal(
+        {:subscribers => ["subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+    end
+
+    def test_with_query_watched_by_multiple_subscribers
+      @watcher.unsubscribe(
+        :route => "localhost:23003/output",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber1",
+      )
+      assert_equal(
+        {:subscribers => ["subscriber1", "subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+
+      @watcher.unsubscribe(
+        :route => "localhost:23003/output",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber2",
+      )
+      assert_equal(
+        {:subscribers => ["subscriber1", "subscriber2"],
+         :queries => ["たこやき".to_json],
+         :keywords => ["たこやき"]},
+        existing_records
+      )
+    end
+
+    def test_without_query
+      request = {
+        :route => "localhost:23003/output",
+        :subscriber => "subscriber1",
+      }
+      @watcher.unsubscribe(request)
+      assert_equal(
+        {:subscribers => ["subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+    end
+
+    private
+    def setup_subscriptions
+      request1_1 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber1",
+      }
+      @watcher.subscribe(request1_1)
+      request1_2 = {
+        :route => "localhost:23003/output",
+        :condition => "たこやき",
+        :query => "たこやき".to_json,
+        :subscriber => "subscriber1",
+      }
+      @watcher.subscribe(request1_2)
+      request2_1 = {
+        :route => "localhost:23003/output",
+        :condition => "たいやき",
+        :query => "たいやき".to_json,
+        :subscriber => "subscriber2",
+      }
+      @watcher.subscribe(request2_1)
+      request2_2 = {
+        :route => "localhost:23003/output",
+        :condition => "たこやき",
+        :query => "たこやき".to_json,
+        :subscriber => "subscriber2",
+      }
+      @watcher.subscribe(request2_2)
+      assert_equal(
+        {:subscribers => ["subscriber1", "subscriber2"],
+         :queries => ["たいやき".to_json, "たこやき".to_json],
+         :keywords => ["たいやき", "たこやき"]},
+        existing_records
+      )
+    end
+  end
+end