droonga-engine 1.1.0 → 1.1.1

data/test/unit/test_address.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014 Droonga Project
+# 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
@@ -28,19 +28,80 @@ class AddressTest < Test::Unit::TestCase
       Droonga::Address.parse(string)
     end
 
-    def test_full
-      assert_equal(address("192.168.0.1", 2929, "droonga", "local_name"),
-                   parse("192.168.0.1:2929/droonga.local_name"))
+    data(:full => {
+           :input      => "node29:2929/droonga.local_name",
+           :host       => "node29",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => "local_name",
+         },
+         :ip_address => {
+           :input      => "192.168.0.1:2929/droonga.local_name",
+           :host       => "192.168.0.1",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => "local_name",
+         },
+         :internal_name => {
+           :input      => "node29:2929/droonga.\#1",
+           :host       => "node29",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => "#1",
+         },
+         :no_local_name => {
+           :input      => "node29:2929/droonga",
+           :host       => "node29",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => nil,
+         })
+    def test_success(data)
+      assert_equal(address(data[:host], data[:port], data[:tag],
+                           data[:local_name]),
+                   parse(data[:input]))
     end
 
-    def test_internal_name
-      assert_equal(address("192.168.0.1", 2929, "droonga", "#1"),
-                   parse("192.168.0.1:2929/droonga.\#1"))
+    data(:no_host => ":2929/droonga",
+         :no_port => "192.168.0.1/droonga",
+         :no_tag  => "192.168.0.1:2929",
+         :blank   => "",
+         :nil     => nil)
+    def test_fail(input)
+      assert_raise(ArgumentError) do
+        parse(input)
+      end
+    end
+  end
+
+  class AttributeTest < self
+    def test_attributes
+      address = address("192.168.0.1", 2929, "droonga", "000")
+      assert_equal({:host       => "192.168.0.1",
+                    :port       => 2929,
+                    :tag        => "droonga",
+                    :local_name => "000"},
+                   {:host       => address.host,
+                    :port       => address.port,
+                    :tag        => address.tag,
+                    :local_name => address.local_name})
+    end
+  end
+
+  class ComparisonTest < self
+    def test_address_vs_string
+      string  = "192.168.0.1:2929/droonga.000"
+      address = address("192.168.0.1", 2929, "droonga", "000")
+      assert_true(address == string)
     end
 
-    def test_no_name
-      assert_equal(address("192.168.0.1", 2929, "droonga", nil),
-                   parse("192.168.0.1:2929/droonga"))
+    #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 Address.
+    def test_string_vs_address
+      string  = "192.168.0.1:2929/droonga.000"
+      address = address("192.168.0.1", 2929, "droonga", "000")
+      assert_false(string == address)
     end
   end
 
@@ -49,5 +110,45 @@ class AddressTest < Test::Unit::TestCase
       assert_equal("192.168.0.1:2929/droonga",
                    address("192.168.0.1", 2929, "droonga", "000").node)
     end
+
+    data(:full => {
+           :expected   => "192.168.0.1:2929/droonga.000",
+           :host       => "192.168.0.1",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => "000",
+         },
+         :no_local_name => {
+           :expected   => "192.168.0.1:2929/droonga",
+           :host       => "192.168.0.1",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => nil,
+         })
+    def test_string(data)
+      assert_equal(data[:expected],
+                   address(data[:host], data[:port], data[:tag],
+                           data[:local_name]).to_s)
+    end
+
+    data(:full => {
+           :expected   => ["192.168.0.1", 2929, "droonga", "000"],
+           :host       => "192.168.0.1",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => "000",
+         },
+         :no_local_name => {
+           :expected   => ["192.168.0.1", 2929, "droonga", nil],
+           :host       => "192.168.0.1",
+           :port       => 2929,
+           :tag        => "droonga",
+           :local_name => nil,
+         })
+    def test_array(data)
+      assert_equal(data[:expected],
+                   address(data[:host], data[:port], data[:tag],
+                           data[:local_name]).to_a)
+    end
   end
 end

data/test/unit/test_cluster.rb

@@ -0,0 +1,232 @@
+# 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/cluster"
+require "droonga/node_role"
+
+class ClusterTest < Test::Unit::TestCase
+  class StubCatalog
+    attr_accessor :all_nodes
+
+    def initialize(all_nodes)
+      @all_nodes = all_nodes || []
+    end
+  end
+
+  class StubEngineNode < Droonga::EngineNode
+    attr_reader :forwarded_messages, :bounced_messages
+
+    def initialize(params)
+      @forwarded_messages = []
+      @bounced_messages = []
+      super
+    end
+
+    def resume
+    end
+
+    def forward(message, destination)
+      @forwarded_messages << {:message     => message,
+                              :destination => destination}
+    end
+
+    def bounce(message)
+      @bounced_messages << message
+    end
+
+    private
+    def sender_role
+      Droonga::NodeRole::SERVICE_PROVIDER
+    end
+
+    def create_buffer
+      []
+    end
+  end
+
+  class Cluster < Droonga::Cluster
+    def reload
+    end
+
+    def start
+      engine_nodes # instantiate it
+    end
+
+    private
+    def create_engine_node(params)
+      StubEngineNode.new(params)
+    end
+  end
+
+  def create_cluster(options={})
+    catalog = StubCatalog.new(options[:all_nodes])
+    Cluster.new(:state   => options[:state],
+                :catalog => catalog)
+  end
+
+  def test_engine_nodes
+    cluster = create_cluster(:all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    assert_equal([
+                   {:class => StubEngineNode,
+                    :name  => "node29:2929/droonga"},
+                   {:class => StubEngineNode,
+                    :name  => "node30:2929/droonga"},
+                 ],
+                 cluster.engine_nodes.collect do |node|
+                   {:class => node.class,
+                    :name  => node.name}
+                 end)
+  end
+
+  def test_engine_node_names
+    cluster = create_cluster(:all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    assert_equal([
+                   "node29:2929/droonga",
+                   "node30:2929/droonga",
+                 ],
+                 cluster.engine_node_names)
+  end
+
+  def test_engine_nodes_status
+    cluster = create_cluster(:state => {
+                               "node29:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                               "node30:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                             },
+                             :all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    assert_equal({
+                   "node29:2929/droonga" => {
+                     "status" => "active",
+                   },
+                   "node30:2929/droonga" => {
+                     "status" => "active",
+                   },
+                 },
+                 cluster.engine_nodes_status)
+  end
+
+  def test_readable_nodes
+    cluster = create_cluster(:state => {
+                               "node29:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                               "node30:2929/droonga" => {
+                                 "live" => false,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                             },
+                             :all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    assert_equal([
+                   "node29:2929/droonga",
+                 ],
+                 cluster.readable_nodes)
+  end
+
+  def test_writable_nodes
+    cluster = create_cluster(:all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    assert_equal([
+                   "node29:2929/droonga",
+                   "node30:2929/droonga",
+                 ],
+                 cluster.writable_nodes)
+  end
+
+  def test_forward
+    cluster = create_cluster(:state => {
+                               "node29:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                               "node30:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                             },
+                             :all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    cluster.start
+    cluster.forward({"id" => 1},
+                    {"to" => "node29:2929/droonga"})
+    assert_equal([
+                   {:name      => "node29:2929/droonga",
+                    :forwarded => [
+                      {:message     => {"id" => 1},
+                       :destination => {"to" => "node29:2929/droonga"}}
+                    ]},
+                   {:name      => "node30:2929/droonga",
+                    :forwarded => []}
+                 ],
+                 cluster.engine_nodes.collect do |node|
+                   {:name      => node.name,
+                    :forwarded => node.forwarded_messages}
+                 end)
+  end
+
+  def test_bounce
+    cluster = create_cluster(:state => {
+                               "node29:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+                               },
+                               "node30:2929/droonga" => {
+                                 "live" => true,
+                                 "role" => Droonga::NodeRole::ABSORB_SOURCE,
+                               },
+                             },
+                             :all_nodes => [
+                               "node29:2929/droonga",
+                               "node30:2929/droonga",
+                             ])
+    cluster.start
+    cluster.bounce({"id" => 1,
+                    "targetRole" => Droonga::NodeRole::ABSORB_SOURCE})
+    assert_equal([
+                   {:name    => "node29:2929/droonga",
+                    :bounced => []},
+                   {:name    => "node30:2929/droonga",
+                    :bounced => [
+                      {"id" => 1,
+                       "targetRole" => Droonga::NodeRole::ABSORB_SOURCE},
+                    ]}
+                 ],
+                 cluster.engine_nodes.collect do |node|
+                   {:name    => node.name,
+                    :bounced => node.bounced_messages}
+                 end)
+  end
+end

data/test/unit/test_differ.rb

@@ -0,0 +1,49 @@
+# 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/differ"
+
+class DifferTest < Test::Unit::TestCase
+  data(:string => {
+         :left     => "a",
+         :right    => "b",
+         :expected => "\"a\" <=> \"b\"",
+       },
+       :numeric => {
+         :left     => 0,
+         :right    => 1,
+         :expected => "0 <=> 1",
+       },
+       :hash => {
+         :left     => {:a => 0, :b => 1},
+         :right    => {:a => 0, :b => 2},
+         :expected => {:b => "1 <=> 2"},
+       },
+       :array => {
+         :left     => [0, 1, 2],
+         :right    => [0, 1, 3],
+         :expected => {2 => "2 <=> 3"},
+       },
+       :nested => {
+         :left     => {:a => 0, :b => {:aa => 0, :bb => 1}},
+         :right    => {:a => 1, :b => {:aa => 0, :bb => 2}},
+         :expected => {:a => "0 <=> 1",
+                       :b => {:bb => "1 <=> 2"}},
+       })
+  def test_diff(data)
+    assert_equal(data[:expected],
+                 Droonga::Differ.diff(data[:left], data[:right]))
+  end
+end

data/test/unit/test_engine_node.rb

@@ -0,0 +1,556 @@
+# 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_node"
+require "droonga/node_role"
+
+class EngineNodeTest < Test::Unit::TestCase
+  def node(params)
+    Droonga::EngineNode.new(params)
+  end
+
+  data(:no_state => {
+         :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         :state    => nil,
+       },
+       :valid => {
+         :expected => Droonga::NodeRole::ABSORB_SOURCE,
+         :state    => {
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+       },
+       :invalid => {
+         :expected => Droonga::NodeRole::SERVICE_PROVIDER,
+         :state    => {
+           "role" => "unknown",
+         },
+       })
+  def test_role(data)
+    assert_equal(data[:expected],
+                 node(:name => "node29:2929/droonga",
+                      :state => data[:state]).role)
+  end
+
+  data(:no_state => nil,
+       :live_info => {
+         "live" => true,
+       })
+  def test_live(state)
+    assert_true(node(:name => "node29:2929/droonga",
+                     :state => state).live?)
+  end
+
+  data(:no_live_info => {
+       },
+       :live_info => {
+         "live" => false,
+       })
+  def test_not_live(state)
+    assert_false(node(:name => "node29:2929/droonga",
+                      :state => state).live?)
+  end
+
+  data(:valid => {
+         :state => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :expected => {
+           "name"   => "node29:2929/droonga",
+           "live"   => true,
+           "role"   => Droonga::NodeRole::SERVICE_PROVIDER,
+           "status" => "active",
+         },
+       })
+  def test_to_json(data)
+    json = node(:name => "node29:2929/droonga",
+                :state => data[:state]).to_json
+    assert_equal(data[:expected], json)
+  end
+
+  class Buffered < Droonga::EngineNode
+    private
+    def create_buffer
+      [0]
+    end
+  end
+
+  class NotBuffered < Droonga::EngineNode
+    private
+    def create_buffer
+      []
+    end
+  end
+
+  class FromServiceProvider < self
+    class BufferedEngineNode < Buffered
+      private
+      def sender_role
+        Droonga::NodeRole::SERVICE_PROVIDER
+      end
+    end
+
+    class NotBufferedEngineNode < NotBuffered
+      private
+      def sender_role
+        Droonga::NodeRole::SERVICE_PROVIDER
+      end
+    end
+
+    class EngineNode < NotBufferedEngineNode
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         })
+    def test_forwardable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).forwardable?)
+    end
+
+    data(:dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_source => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :to_absorb_destination => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         })
+    def test_not_forwardable(state)
+      assert_false(EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => state).forwardable?)
+    end
+
+    data(:same_role_with_no_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_readable(data)
+      assert_true(data[:class].new(:name => "node29:2929/droonga",
+                                   :state => data[:state]).readable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message_in_other_node => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+             "have_unprocessed_messages" => true,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :class => BufferedEngineNode,
+         },
+         :to_absorb_source => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :to_absorb_destination => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_not_readable(data)
+      assert_false(data[:class].new(:name => "node29:2929/droonga",
+                                    :state => data[:state]).readable?)
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_source => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :to_absorb_destination => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         },
+         :to_dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_node_have_unprocessed_message => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           "have_unprocessed_messages" => true,
+         })
+    def test_writable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).writable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+           },
+           :expected => "dead",
+         },
+         :readable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :expected => "active",
+         },
+         :not_readable_but_writable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :expected => "inactive",
+         })
+    def test_status(data)
+      assert_equal(data[:expected],
+                   EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => data[:state]).status)
+    end
+  end
+
+  class FromAbsorbSource < self
+    class BufferedEngineNode < Buffered
+      private
+      def sender_role
+        Droonga::NodeRole::ABSORB_SOURCE
+      end
+    end
+
+    class NotBufferedEngineNode < NotBuffered
+      private
+      def sender_role
+        Droonga::NodeRole::ABSORB_SOURCE
+      end
+    end
+
+    class EngineNode < NotBufferedEngineNode
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         })
+    def test_forwardable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).forwardable?)
+    end
+
+    data(:dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :to_service_provider => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_destination => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         })
+    def test_not_forwardable(state)
+      assert_false(EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => state).forwardable?)
+    end
+
+    data(:same_role_with_no_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message_in_other_node => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+             "have_unprocessed_messages" => true,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_readable(data)
+      assert_true(data[:class].new(:name => "node29:2929/droonga",
+                                   :state => data[:state]).readable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :class => BufferedEngineNode,
+         },
+         :to_service_provider => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :to_absorb_destination => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_not_readable(data)
+      assert_false(data[:class].new(:name => "node29:2929/droonga",
+                                    :state => data[:state]).readable?)
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :to_dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         },
+         :to_node_have_unprocessed_message => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           "have_unprocessed_messages" => true,
+         })
+    def test_writable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).writable?)
+    end
+
+    data(:to_service_provider => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_destination => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         })
+    def test_not_writable(state)
+      assert_false(EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => state).writable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+           },
+           :expected => "dead",
+         },
+         :readable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :expected => "active",
+         },
+         :not_readable_but_writable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :expected => "inactive",
+         })
+    def test_status(data)
+      assert_equal(data[:expected],
+                   EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => data[:state]).status)
+    end
+  end
+
+  class FromAbsorbDestination < self
+    class BufferedEngineNode < Buffered
+      private
+      def sender_role
+        Droonga::NodeRole::ABSORB_DESTINATION
+      end
+    end
+
+    class NotBufferedEngineNode < NotBuffered
+      private
+      def sender_role
+        Droonga::NodeRole::ABSORB_DESTINATION
+      end
+    end
+
+    class EngineNode < NotBufferedEngineNode
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         })
+    def test_forwardable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).forwardable?)
+    end
+
+    data(:dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         },
+         :to_service_provider => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_source => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         })
+    def test_not_forwardable(state)
+      assert_false(EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => state).forwardable?)
+    end
+
+    data(:same_role_with_no_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message_in_other_node => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+             "have_unprocessed_messages" => true,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_readable(data)
+      assert_true(data[:class].new(:name => "node29:2929/droonga",
+                                   :state => data[:state]).readable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :have_unprocessed_message => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :class => BufferedEngineNode,
+         },
+         :to_service_provider => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :class => NotBufferedEngineNode,
+         },
+         :to_absorb_source => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_SOURCE,
+           },
+           :class => NotBufferedEngineNode,
+         })
+    def test_not_readable(data)
+      assert_false(data[:class].new(:name => "node29:2929/droonga",
+                                    :state => data[:state]).readable?)
+    end
+
+    data(:same_role => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         },
+         :to_dead => {
+           "live" => false,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+         },
+         :to_node_have_unprocessed_message => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           "have_unprocessed_messages" => true,
+         })
+    def test_writable(state)
+      assert_true(EngineNode.new(:name => "node29:2929/droonga",
+                                 :state => state).writable?)
+    end
+
+    data(:to_service_provider => {
+           "live" => true,
+           "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+         },
+         :to_absorb_source => {
+           "live" => true,
+           "role" => Droonga::NodeRole::ABSORB_SOURCE,
+         })
+    def test_not_writable(state)
+      assert_false(EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => state).writable?)
+    end
+
+    data(:dead => {
+           :state => {
+             "live" => false,
+           },
+           :expected => "dead",
+         },
+         :readable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::ABSORB_DESTINATION,
+           },
+           :expected => "active",
+         },
+         :not_readable_but_writable => {
+           :state => {
+             "live" => true,
+             "role" => Droonga::NodeRole::SERVICE_PROVIDER,
+           },
+           :expected => "inactive",
+         })
+    def test_status(data)
+      assert_equal(data[:expected],
+                   EngineNode.new(:name => "node29:2929/droonga",
+                                  :state => data[:state]).status)
+    end
+  end
+end