droonga-engine 1.1.0 → 1.1.1

data/test/unit/test_engine_state.rb

@@ -0,0 +1,151 @@
+# Copyright (C) 2015 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/engine_state"
+
+class EngineStateTest < Test::Unit::TestCase
+  class EngineState < Droonga::EngineState
+    private
+    def create_forwarder
+      nil
+    end
+
+    def create_replier
+      nil
+    end
+  end
+
+  PUBLIC_NODE_NAME   = "node29:2929/droonga"
+  INTERNAL_NODE_NAME = "node29:12929/droonga"
+
+  def setup
+    @state = EngineState.new(:name          => PUBLIC_NODE_NAME,
+                             :internal_name => INTERNAL_NODE_NAME)
+  end
+
+  data(:public => PUBLIC_NODE_NAME,
+       :internal => INTERNAL_NODE_NAME,
+       :public_with_local => "#{PUBLIC_NODE_NAME}.\#1",
+       :internal_with_local => "#{INTERNAL_NODE_NAME}.\#1")
+  def test_local_route(route)
+    assert_true(@state.local_route?(route))
+  end
+
+  data(:foreign => "node30:2929/droonga",
+       :foreign_with_logal => "node30:2929/droonga.\#1")
+  def test_not_local_route(route)
+    assert_false(@state.local_route?(route))
+  end
+
+  data(:public => {
+         :route    => PUBLIC_NODE_NAME,
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :internal => {
+         :route    => INTERNAL_NODE_NAME,
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :public_with_local => {
+         :route    => "#{PUBLIC_NODE_NAME}.\#1",
+         :expected => "#{INTERNAL_NODE_NAME}.\#1",
+       },
+       :internal_with_local => {
+         :route    => "#{INTERNAL_NODE_NAME}.\#1",
+         :expected => "#{INTERNAL_NODE_NAME}.\#1",
+       },
+       :foreign => {
+         :route    => "node30:2929/droonga.\#1",
+         :expected => "node30:2929/droonga.\#1",
+       })
+  def test_internal_route(data)
+    assert_equal(data[:expected],
+                 @state.internal_route(data[:route]))
+  end
+
+  data(:public => {
+         :route    => PUBLIC_NODE_NAME,
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :internal => {
+         :route    => INTERNAL_NODE_NAME,
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :public_with_local => {
+         :route    => "#{PUBLIC_NODE_NAME}.\#1",
+         :expected => "#{PUBLIC_NODE_NAME}.\#1",
+       },
+       :internal_with_local => {
+         :route    => "#{INTERNAL_NODE_NAME}.\#1",
+         :expected => "#{PUBLIC_NODE_NAME}.\#1",
+       },
+       :foreign => {
+         :route    => "node30:2929/droonga.\#1",
+         :expected => "node30:2929/droonga.\#1",
+       })
+  def test_public_route(data)
+    assert_equal(data[:expected],
+                 @state.public_route(data[:route]))
+  end
+
+  data(:public => {
+         :route    => PUBLIC_NODE_NAME,
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :internal => {
+         :route    => INTERNAL_NODE_NAME,
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :public_with_local => {
+         :route    => "#{PUBLIC_NODE_NAME}.\#1",
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :internal_with_local => {
+         :route    => "#{INTERNAL_NODE_NAME}.\#1",
+         :expected => INTERNAL_NODE_NAME,
+       },
+       :foreign => {
+         :route    => "node30:2929/droonga.\#1",
+         :expected => "node30:2929/droonga",
+       })
+  def test_internal_farm_path(data)
+    assert_equal(data[:expected],
+                 @state.internal_farm_path(data[:route]))
+  end
+
+  data(:public => {
+         :route    => PUBLIC_NODE_NAME,
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :internal => {
+         :route    => INTERNAL_NODE_NAME,
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :public_with_local => {
+         :route    => "#{PUBLIC_NODE_NAME}.\#1",
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :internal_with_local => {
+         :route    => "#{INTERNAL_NODE_NAME}.\#1",
+         :expected => PUBLIC_NODE_NAME,
+       },
+       :foreign => {
+         :route    => "node30:2929/droonga.\#1",
+         :expected => "node30:2929/droonga",
+       })
+  def test_public_farm_path(data)
+    assert_equal(data[:expected],
+                 @state.public_farm_path(data[:route]))
+  end
+end

data/test/unit/test_forward_buffer.rb

@@ -0,0 +1,106 @@
+# Copyright (C) 2015 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "time"
+
+require "droonga/forward_buffer"
+
+class ForwardBufferTest < Test::Unit::TestCase
+  class ForwardBuffer < Droonga::ForwardBuffer
+    attr_writer :data_directory, :serf
+  end
+
+  def setup
+    setup_temporary_directory
+
+    @buffer = ForwardBuffer.new("node29:2929/droonga")
+    @buffer.data_directory = @temporary_directory
+    @buffer.serf = StubSerf.new
+
+    @forwarded_messages = []
+    @buffer.on_forward = lambda do |message, destination|
+      @forwarded_messages << {:message => message,
+                              :destination => destination}
+    end
+  end
+
+  def teardown
+    teardown_temporary_directory
+  end
+
+  def test_empty
+    assert_true(@buffer.empty?)
+  end
+
+  def test_not_empty
+    @buffer.add({}, {})
+    assert_false(@buffer.empty?)
+  end
+
+  def test_add
+    @buffer.add({}, {})
+    @buffer.add({}, {})
+    @buffer.add({}, {})
+    assert_equal(3, @buffer.buffered_messages.size)
+  end
+
+  class ForwardTest < self
+    def setup
+      super
+      @buffer.add({"date" => "2015-04-30T00:00:00.000000Z"}, {})
+      @buffer.add({"date" => "2015-04-30T01:00:00.000000Z"}, {})
+      @buffer.add({"date" => "2015-04-30T02:00:00.000000Z"}, {})
+    end
+
+    def test_without_boundary
+      @buffer.start_forward
+      assert_equal({
+                     :empty => true,
+                     :forwarded => [
+                       {:message => {"date" => "2015-04-30T00:00:00.000000Z",
+                                     "xSender"=>"forward-buffer"},
+                        :destination => {}},
+                       {:message => {"date" => "2015-04-30T01:00:00.000000Z",
+                                     "xSender"=>"forward-buffer"},
+                        :destination => {}},
+                       {:message => {"date" => "2015-04-30T02:00:00.000000Z",
+                                     "xSender"=>"forward-buffer"},
+                        :destination => {}},
+                     ],
+                   },
+                   {
+                     :empty => @buffer.empty?,
+                     :forwarded => @forwarded_messages,
+                   })
+    end
+
+    def test_with_boundary
+      @buffer.process_messages_newer_than(Time.parse("2015-04-30T01:00:00.000000Z"))
+      @buffer.start_forward
+      assert_equal({
+                     :empty => true,
+                     :forwarded => [
+                       {:message => {"date" => "2015-04-30T02:00:00.000000Z",
+                                     "xSender"=>"forward-buffer"},
+                        :destination => {}},
+                     ],
+                   },
+                   {
+                     :empty => @buffer.empty?,
+                     :forwarded => @forwarded_messages,
+                   })
+    end
+  end
+end

data/test/unit/test_node_name.rb

@@ -0,0 +1,160 @@
+# Copyright (C) 2014-2015 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/node_name"
+
+class NodeNameTest < Test::Unit::TestCase
+  def node_name(host, port, tag)
+    Droonga::NodeName.new(:host => host,
+                          :port => port,
+                          :tag  => tag)
+  end
+
+  class ValidationTest < self
+    data(:ip_address => "192.168.0.1:2929/droonga",
+         :host_name  => "node29:2929/droonga")
+    def test_valid(input)
+      assert_true(Droonga::NodeName.valid?(input))
+    end
+
+    data(:no_host => ":2929/droonga",
+         :no_port => "192.168.0.1/droonga",
+         :no_tag  => "192.168.0.1:2929",
+         :blank   => "",
+         :nil     => nil)
+    def test_invalid(input)
+      assert_false(Droonga::NodeName.valid?(input))
+    end
+  end
+
+  class DefaultParameterTest < self
+    data(:omitted => {
+           :params => {
+           },
+           :host  => Droonga::NodeName::DEFAULT_HOST,
+           :port  => Droonga::NodeName::DEFAULT_PORT,
+           :tag   => Droonga::NodeName::DEFAULT_TAG,
+         },
+         :nil => {
+           :params => {
+             :host => nil,
+             :port => nil,
+             :tag  => nil,
+           },
+           :host  => Droonga::NodeName::DEFAULT_HOST,
+           :port  => Droonga::NodeName::DEFAULT_PORT,
+           :tag   => Droonga::NodeName::DEFAULT_TAG,
+         },
+         :filled => {
+           :params => {
+             :host => "node29",
+             :port => 2929,
+             :tag  => "test",
+           },
+           :host  => "node29",
+           :port  => 2929,
+           :tag   => "test",
+         })
+    def test_default_parameter(data)
+      assert_equal(node_name(data[:host], data[:port], data[:tag]),
+                   Droonga::NodeName.new(data[:params]))
+    end
+  end
+
+  class ParseTest < self
+    def parse(string)
+      Droonga::NodeName.parse(string)
+    end
+
+    data(:ip_address => {
+           :input => "192.168.0.1:2929/droonga",
+           :host  => "192.168.0.1",
+           :port  => 2929,
+           :tag   => "droonga",
+         },
+         :host_name => {
+           :input => "node29:2929/droonga",
+           :host  => "node29",
+           :port  => 2929,
+           :tag   => "droonga",
+         })
+    def test_valid_string(data)
+      assert_equal(node_name(data[:host], data[:port], data[:tag]),
+                   parse(data[:input]))
+    end
+
+    def test_instance
+      assert_equal(node_name("192.168.0.1", 2929, "droonga"),
+                   parse(node_name("192.168.0.1", 2929, "droonga")))
+    end
+
+    data(:no_host => ":2929/droonga",
+         :no_port => "192.168.0.1/droonga",
+         :no_tag  => "192.168.0.1:2929",
+         :blank   => "",
+         :nil     => nil)
+    def test_invalid(input)
+      assert_raise(ArgumentError) do
+        parse(input)
+      end
+    end
+  end
+
+  class AttributeTest < self
+    def test_attributes
+      node_name = node_name("192.168.0.1", 2929, "droonga")
+      assert_equal({:host => "192.168.0.1",
+                    :port => 2929,
+                    :tag  => "droonga"},
+                   {:host => node_name.host,
+                    :port => node_name.port,
+                    :tag  => node_name.tag})
+    end
+  end
+
+  class ComparisonTest < self
+    def test_node_name_vs_string
+      string    = "192.168.0.1:2929/droonga"
+      node_name = node_name("192.168.0.1", 2929, "droonga")
+      assert_true(node_name == string)
+    end
+
+    #XXX This is a confusable behavior. It seems should be true
+    #    but actually false, so you have to be careful when you
+    #    compare string with NodeName.
+    def test_string_vs_node_name
+      string    = "192.168.0.1:2929/droonga"
+      node_name = node_name("192.168.0.1", 2929, "droonga")
+      assert_false(string == node_name)
+    end
+  end
+
+  class FormatterTest < self
+    def test_node
+      assert_equal("192.168.0.1:2929/droonga",
+                   node_name("192.168.0.1", 2929, "droonga").node)
+    end
+
+    def test_string
+      assert_equal("192.168.0.1:2929/droonga",
+                   node_name("192.168.0.1", 2929, "droonga").to_s)
+    end
+
+    def test_array
+      assert_equal(["192.168.0.1", 2929, "droonga"],
+                   node_name("192.168.0.1", 2929, "droonga").to_a)
+    end
+  end
+end

data/test/unit/test_node_role.rb

@@ -0,0 +1,53 @@
+# Copyright (C) 2015 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "droonga/node_role"
+
+class NodeRoleTest < Test::Unit::TestCase
+  class NormalizeTest < self
+    data(:service_provider => {
+           :input    => "service-provider",
+           :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :absorb_source => {
+           :input    => "absorb-source",
+           :expected => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :absorb_destination => {
+           :input    => "absorb-destination",
+           :expected => Droonga::NodeRole::ABSORB_DESTINATION,
+         },
+         :not_valid_for_a_node => {
+           :input    => "any",
+           :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :mixed_case => {
+           :input    => "Absorb-Source",
+           :expected => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :nil => {
+           :input    => nil,
+           :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :blank => {
+           :input    => "",
+           :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         })
+    def test_normalize(data)
+      assert_equal(data[:expected],
+                   Droonga::NodeRole.normalize(data[:input]))
+    end
+  end
+end