roma 1.2.0 → 1.3.0

data/test/roma-test-utils.rb

@@ -6,6 +6,7 @@ require 'roma/config'
 require 'roma/messaging/con_pool'
 require 'roma/logging/rlogger'
 require 'roma/client/rclient'
+require 'roma/client/version'
 require 'roma/client/client_pool'
 
 Roma::Client::RomaClient.class_eval do
@@ -20,6 +21,8 @@ module RomaTestUtils
   DEFAULT_PORTS = %w(11211 11212)
   DEFAULT_NODES = DEFAULT_PORTS.map { |port| "#{DEFAULT_HOST}_#{port}" }
   DEFAULT_TIMEOUT_SEC = 90
+  REPLICA_PORTS = %w(21211 21212)
+  REPLICA_NODES = REPLICA_PORTS.map { |port| "#{DEFAULT_HOST}_#{port}" }
   SHELL_LOG = 'roma_test_outputs.log'
 
   Roma::Logging::RLogger.create_singleton_instance("#{Roma::Config::LOG_PATH}/roma_test.log",
@@ -42,6 +45,20 @@ module RomaTestUtils
     sleep 1
   end
 
+  def start_roma_replica(conf = DEFAULT_CONFIG, div_bits: 3, replication_in_host: true)
+    FileUtils.rm_rf(Dir.glob("#{Roma::Config::STORAGE_PATH}/#{REPLICA_NODES[0][0..-2]}?*"))
+    FileUtils.rm_rf(Dir.glob("#{Roma::Config::STORAGE_PATH}/#{DEFAULT_IP}_#{REPLICA_PORTS[0][0..-2]}?*"))
+    sleep 0.1
+
+    system("#{ruby_path} #{mkroute_path} #{REPLICA_NODES.join(' ')} -d #{div_bits} --replication_in_host >> #{SHELL_LOG} 2>&1")
+    sleep 0.2
+
+    REPLICA_NODES.each do |node|
+      do_command_romad(node, conf, replication_in_host)
+    end
+    sleep 1
+  end
+
   def join_roma(node, conf = DEFAULT_CONFIG, replication_in_host: true)
     do_command_romad(node, conf, replication_in_host, true)
   end
@@ -119,6 +136,13 @@ module RomaTestUtils
     Roma::Messaging::ConPool.instance.close_all
   end
 
+  def stop_roma_replica
+    balse_message = %w(balse yes)
+    send_message(messages: balse_message, node: REPLICA_NODES[0])
+    Roma::Client::ConPool.instance.close_all
+    Roma::Messaging::ConPool.instance.close_all
+  end
+
   def stop_roma_node(node)
     send_message(messages: 'rbalse', node: node)
     Roma::Client::ConPool.instance.close_all

data/test/run-test.rb

@@ -13,8 +13,17 @@ $LOAD_PATH.unshift("#{client_base_path}/roma-ruby-client/lib")
 
 require 'roma-test-utils'
 
+puts "* ROMA Version : #{Roma::Config::VERSION}"
+puts "* Ruby Client Version : #{Roma::Client::VERSION::STRING}"
+
 Dir["#{base_path}/test/t_*.rb"].each do |test_file|
   require File.basename(test_file, '*.rb')
 end
 
+### optional test
+require_relative './optional_test/t_routing_logic.rb'
+#require_relative './optional_test/t_mkroute_rich.rb'
+#require_relative './optional_test/t_other_database.rb'
+#require_relative './optional_test/t_other_cpdb.rb'
+
 exit(Test::Unit::AutoRunner.run)

data/test/t_command_definition.rb

@@ -135,6 +135,7 @@ class DefCmdTest
 end
 
 class DefineCommandTest < Test::Unit::TestCase
+  self.test_order = :defined
 
   def setup
     @obj = DefCmdTest.new
@@ -287,6 +288,7 @@ class DefCmdTestNoHash < DefCmdTest
 end
 
 class DefineCommandNoHashTest < Test::Unit::TestCase
+  self.test_order = :defined
   def setup
     @obj = DefCmdTestNoHash.new
   end

data/test/t_cpdata.rb

@@ -82,6 +82,7 @@ end
 
 # test of copying vnode
 class CopyDataTest < Test::Unit::TestCase
+  self.test_order = :defined
   include RomaTestUtils
 
   def setup

data/test/t_cpdb.rb

@@ -5,6 +5,7 @@ require 'roma/config'
 require 'pathname'
 
 class CpdbBaseTest < Test::Unit::TestCase
+  self.test_order = :defined
   include RomaTestUtils
 
   def teardown
@@ -20,11 +21,13 @@ class GroongaTest < CpdbBaseTest
   def setup
     start_roma 'cpdbtest/config4cpdb_groonga.rb'
     @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
+    @sock = TCPSocket.new("localhost", 11211)
   end
 
-  def test_cpdb
-    value = `#{bin_dir}/cpdb 11211`.chomp
-    assert_equal("ERROR:cpdb supports just TCStorage system, your storage type is GroongaStorage", value)
+  def test_st_class_grn
+    @sock.write("stat st_class\r\n")
+    assert_equal("storages[roma].storage.st_class GroongaStorage", @sock.gets.chomp)
+    assert_equal('END', @sock.gets.chomp)
   end
 end
 
@@ -33,10 +36,12 @@ class RubyHashTest < CpdbBaseTest
   def setup
     start_roma 'cpdbtest/config4cpdb_rh.rb'
     @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
+    @sock = TCPSocket.new("localhost", 11211)
   end
-  def test_cpdb
-    value = `#{bin_dir}/cpdb 11211`.chomp
-    assert_equal("ERROR:cpdb supports just TCStorage system, your storage type is RubyHashStorage", value)
+  def test_st_class_rh
+      @sock.write("stat st_class\r\n")
+      assert_equal('storages[roma].storage.st_class RubyHashStorage', @sock.gets.chomp)
+      assert_equal('END', @sock.gets.chomp)
   end
 end
 
@@ -45,6 +50,7 @@ class TcTest < CpdbBaseTest
   def setup
     start_roma 'cpdbtest/config4cpdb_tc.rb'
     @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
+    @sock = TCPSocket.new("localhost", 11211)
   end
   def test_cpdb
     # Log Assertion
@@ -55,6 +61,11 @@ class TcTest < CpdbBaseTest
     valueFileList = `ls ./localhost_11211/roma/`.chomp
     assert_match(/9.tc.([\d]+)/, valueFileList)
   end
+  def test_st_class_tc
+      @sock.write("stat st_class\r\n")
+      assert_equal('storages[roma].storage.st_class TCStorage', @sock.gets.chomp)
+      assert_equal('END', @sock.gets.chomp)
+  end
 end
 
 # TcMem Storage Test
@@ -62,34 +73,11 @@ class TcMemTest < CpdbBaseTest
   def setup
     start_roma 'cpdbtest/config4cpdb_tcmem.rb'
     @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
+    @sock = TCPSocket.new("localhost", 11211)
   end
-  def test_cpdb
-    value = `#{bin_dir}/cpdb 11211`.chomp
-    assert_equal("ERROR:cpdb supports just TCStorage system, your storage type is TCMemStorage" , value)
-  end
-end
-
-# Dbm Storage Test
-class DbmTest < CpdbBaseTest
-  def setup
-    start_roma 'cpdbtest/config4cpdb_dbm.rb'
-    @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
-  end
-  def test_cpdb
-    value = `#{bin_dir}/cpdb 11211`.chomp
-    assert_equal("ERROR:cpdb supports just TCStorage system, your storage type is DbmStorage", value)
-  end
-end
-
-# Sqlite3 Storage Test
-class Sqlite3Test < CpdbBaseTest
-  def setup
-    start_roma 'cpdbtest/config4cpdb_sqlite3.rb'
-    @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"])
-  end
-  def test_cpdb
-    value = `#{bin_dir}/cpdb 11211`.chomp
-    assert_equal("ERROR:cpdb supports just TCStorage system, your storage type is SQLite3Storage", value)
+  def test_st_class_tcmem
+      @sock.write("stat st_class\r\n")
+      assert_equal('storages[roma].storage.st_class TCMemStorage', @sock.gets.chomp)
+      assert_equal('END', @sock.gets.chomp)
   end
 end
-

data/test/t_eventmachine.rb

@@ -3,6 +3,7 @@
 require 'eventmachine'
 
 class EventMachineTest < Test::Unit::TestCase
+  self.test_order = :defined
   LOOP_NUM = 5
 
   def test_context_switch

data/test/t_listplugin.rb

@@ -610,10 +610,12 @@ module ListPluginTests
 end # ListPluginTests
 
 class ListPluginTest < Test::Unit::TestCase
+  self.test_order = :defined
   include ListPluginTests
 end
 
 class ListPluginTestForceForward < Test::Unit::TestCase
+  self.test_order = :defined
   include ListPluginTests
 
   def setup

data/test/t_logshift.rb

@@ -4,6 +4,7 @@ require 'socket'
 require 'test/unit'
 
 class  LogShiftTest  < Test::Unit::TestCase
+  self.test_order = :defined
   include RomaTestUtils
 
   def setup
@@ -30,7 +31,6 @@ class  LogShiftTest  < Test::Unit::TestCase
     assert_equal("END", @sock_port_1.gets.chomp)
     assert_equal('{"localhost_11212"=>"STORED", "localhost_11211"=>"STORED"}', @sock_port_1.gets.chomp)
     @sock_port_1.write("stat log_shift_size\r\n")
-    puts "Old value was : #{old_log_shift_size} "
     assert_equal( "stats.log_shift_size 4096" , @sock_port_1.gets.chomp);
     assert_equal("END", @sock_port_1.gets.chomp)
 
@@ -51,7 +51,6 @@ class  LogShiftTest  < Test::Unit::TestCase
     assert_equal("END", @sock_port_1.gets.chomp)
     assert_equal('{"localhost_11212"=>"STORED", "localhost_11211"=>"STORED"}', @sock_port_1.gets.chomp)
     @sock_port_1.write("stat log_shift_age\r\n")
-    puts "Old value was : #{old_log_shift_age} "
     assert_equal( "stats.log_shift_age 7" , @sock_port_1.gets.chomp);
     assert_equal("END", @sock_port_1.gets.chomp)
 
@@ -72,7 +71,6 @@ class  LogShiftTest  < Test::Unit::TestCase
     assert_equal("END", @sock_port_1.gets.chomp)
     assert_equal('{"localhost_11212"=>"STORED", "localhost_11211"=>"STORED"}', @sock_port_1.gets.chomp)
     @sock_port_1.write("stat log_shift_age\r\n")
-    puts "Old value was : #{old_log_shift_age} "
     assert_equal( "stats.log_shift_age min" , @sock_port_1.gets.chomp);
     assert_equal("END", @sock_port_1.gets.chomp)
 
@@ -83,4 +81,4 @@ class  LogShiftTest  < Test::Unit::TestCase
 
   end
 
-end
+end

data/test/t_mapcountplugin.rb

@@ -8,6 +8,7 @@ Roma::Client::RomaClient.class_eval{
 }
 
 class MapCountPluginTest < Test::Unit::TestCase
+  self.test_order = :defined
   include RomaTestUtils
 
   DATE_FORMAT = "%Y-%m-%dT%H:%M:%S +00"
@@ -25,6 +26,16 @@ class MapCountPluginTest < Test::Unit::TestCase
     stop_roma
   end
 
+  def check_roma_value(h, res)
+    h.each{|k, v|
+      if k == 'last_updated_date'
+        assert_equal true, res[k].between?(v, v+1)
+      else
+        assert_equal v, res[k]
+      end
+    }
+  end
+
   def test_mapcount_get(n = 5)
     n.times do |i|
       @sk = "subkey#{i}"
@@ -34,16 +45,16 @@ class MapCountPluginTest < Test::Unit::TestCase
       (i+1).times do |j|
         retc["subkey#{j}"] = 1
       end
-      assert_equal retc, @rc.mapcount_countup(@k, @sk, 0)
+      check_roma_value(retc, @rc.mapcount_countup(@k, @sk, 0))
       
       retg = {"last_updated_date"=>@lt}
       retg["subkey#{i}"] = 1
-      assert_equal retg, @rc.mapcount_get(@k, @sk)
-      assert_equal retc, @rc.mapcount_get(@k)
+      check_roma_value(retg, @rc.mapcount_get(@k, @sk))
+      check_roma_value(retc, @rc.mapcount_get(@k))
     end
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_get(@k, 'subkey0,subkey1')
+    check_roma_value(ret2, @rc.mapcount_get(@k, 'subkey0,subkey1'))
   end
 
   def test_mapcount_countup_array
@@ -52,30 +63,30 @@ class MapCountPluginTest < Test::Unit::TestCase
 
   def test_mapcount_countup_array_multi
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_countup(@k, ["subkey0", "subkey1"])
+    check_roma_value(ret2, @rc.mapcount_countup(@k, ["subkey0", "subkey1"]))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>2}
     @rc.mapcount_countup(@k, ["subkey1"])
-    assert_equal ret2, @rc.mapcount_get(@k)
+    check_roma_value(ret2, @rc.mapcount_get(@k))
   end
 
   def test_mapcount_countup_hash
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_countup(@k, ["subkey0", "subkey1"])
+    check_roma_value(ret2, @rc.mapcount_countup(@k, ["subkey0", "subkey1"]))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>1}
     @rc.mapcount_countup(@k, {"subkey0" => 3})
-    assert_equal ret2, @rc.mapcount_get(@k)
+    check_roma_value(ret2, @rc.mapcount_get(@k))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>11}
     @rc.mapcount_countup(@k, {"subkey1" => 10})
-    assert_equal ret2, @rc.mapcount_get(@k)
+    check_roma_value(ret2, @rc.mapcount_get(@k))
   end
 
   def test_mapcount_countup_degits
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>125, "subkey1"=>30}
     @rc.mapcount_countup(@k, {"subkey0" => 125, "subkey1" => 30})
-    assert_equal ret2, @rc.mapcount_get(@k)
+    check_roma_value(ret2, @rc.mapcount_get(@k))
   end
 
   def test_mapcount_countup_expt
@@ -90,29 +101,29 @@ class MapCountPluginTest < Test::Unit::TestCase
     ret_time = {"last_updated_date"=>@lt}
 
     assert_nil @rc.mapcount_update(@k)
-    assert_equal @ret, @rc.mapcount_countup(@k, @sk, 0)
-    assert_equal @ret, @rc.mapcount_update(@k)
-    assert_equal ret_time, @rc.mapcount_update(@k, 'subkey2')
-    assert_equal @ret, @rc.mapcount_update(@k, nil, 1)
+    check_roma_value(@ret, @rc.mapcount_countup(@k, @sk, 0))
+    check_roma_value(@ret, @rc.mapcount_update(@k))
+    check_roma_value(ret_time, @rc.mapcount_update(@k, 'subkey2'))
+    check_roma_value(@ret, @rc.mapcount_update(@k, nil, 1))
     sleep 2
     assert_nil @rc.mapcount_get(@k)
   end
 
   def test_mapcount_update_subkeys
     ret = {"last_updated_date"=>@lt, @sk=>1}
-    assert_equal @ret, @rc.mapcount_countup(@k, @sk, 0)
-    assert_equal @ret, @rc.mapcount_update(@k, @sk, 1)
+    check_roma_value(@ret, @rc.mapcount_countup(@k, @sk, 0))
+    check_roma_value(@ret, @rc.mapcount_update(@k, @sk, 1))
     sleep 2
     assert_nil @rc.mapcount_get(@k)
   end
 
   def test_mapcount_update_time
     ret = {"last_updated_date"=>@lt, @sk=>1}
-    assert_equal @ret, @rc.mapcount_countup(@k, @sk, 0)
+    check_roma_value(@ret, @rc.mapcount_countup(@k, @sk, 0))
     sleep 2
     lt2 = Time.parse(Time.now.strftime(DATE_FORMAT))
     ret2 = {"last_updated_date"=>lt2, @sk=>1}
-    assert_equal ret2, @rc.mapcount_update(@k)
+    check_roma_value(ret2, @rc.mapcount_update(@k))
   end
 
   def test_counts
@@ -156,16 +167,16 @@ class MapCountPluginTest < Test::Unit::TestCase
       (i+1).times do |j|
         retc["subkey#{j}"] = 1
       end
-      assert_equal retc, @rc.mapcount_countup_ms(@k, @sk, 0)
-      
+      check_roma_value(retc, @rc.mapcount_countup_ms(@k, @sk, 0))
+
       retg = {"last_updated_date"=>@lt}
       retg["subkey#{i}"] = 1
-      assert_equal retg, @rc.mapcount_get_ms(@k, @sk)
-      assert_equal retc, @rc.mapcount_get_ms(@k)
+      check_roma_value(retg, @rc.mapcount_get_ms(@k, @sk))
+      check_roma_value(retc, @rc.mapcount_get_ms(@k))
     end
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_get_ms(@k, 'subkey0,subkey1')
+    check_roma_value(ret2, @rc.mapcount_get_ms(@k, 'subkey0,subkey1'))
   end
 
   def test_mapcount_countup_ms_array
@@ -174,30 +185,30 @@ class MapCountPluginTest < Test::Unit::TestCase
 
   def test_mapcount_countup_ms_array_multi
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_countup_ms(@k, ["subkey0", "subkey1"])
+    check_roma_value(ret2, @rc.mapcount_countup_ms(@k, ["subkey0", "subkey1"]))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>2}
     @rc.mapcount_countup_ms(@k, ["subkey1"])
-    assert_equal ret2, @rc.mapcount_get_ms(@k)
+    check_roma_value(ret2, @rc.mapcount_get_ms(@k))
   end
 
   def test_mapcount_countup_ms_hash
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret2, @rc.mapcount_countup_ms(@k, ["subkey0", "subkey1"])
+    check_roma_value(ret2, @rc.mapcount_countup_ms(@k, ["subkey0", "subkey1"]))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>1}
     @rc.mapcount_countup_ms(@k, {"subkey0" => 3})
-    assert_equal ret2, @rc.mapcount_get_ms(@k)
+    check_roma_value(ret2, @rc.mapcount_get_ms(@k))
 
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>11}
     @rc.mapcount_countup_ms(@k, {"subkey1" => 10})
-    assert_equal ret2, @rc.mapcount_get_ms(@k)
+    check_roma_value(ret2, @rc.mapcount_get_ms(@k))
   end
 
   def test_mapcount_countup_ms_degits
     ret2 = {"last_updated_date"=>@lt, "subkey0"=>125, "subkey1"=>30}
     @rc.mapcount_countup_ms(@k, {"subkey0" => 125, "subkey1" => 30})
-    assert_equal ret2, @rc.mapcount_get_ms(@k)
+    check_roma_value(ret2, @rc.mapcount_get_ms(@k))
   end
 
   def test_mapcount_countup_ms_expt
@@ -212,29 +223,29 @@ class MapCountPluginTest < Test::Unit::TestCase
     ret_time = {"last_updated_date"=>@lt}
 
     assert_nil @rc.mapcount_update_ms(@k)
-    assert_equal @ret, @rc.mapcount_countup_ms(@k, @sk, 0)
-    assert_equal @ret, @rc.mapcount_update_ms(@k)
-    assert_equal ret_time, @rc.mapcount_update_ms(@k, 'subkey2')
-    assert_equal @ret, @rc.mapcount_update_ms(@k, nil, 1)
+    check_roma_value(@ret, @rc.mapcount_countup_ms(@k, @sk, 0))
+    check_roma_value(@ret, @rc.mapcount_update_ms(@k))
+    check_roma_value(ret_time, @rc.mapcount_update_ms(@k, 'subkey2'))
+    check_roma_value(@ret, @rc.mapcount_update_ms(@k, nil, 1))
     sleep 2
     assert_nil @rc.mapcount_get_ms(@k)
   end
 
   def test_mapcount_update_ms_subkeys
     ret = {"last_updated_date"=>@lt, @sk=>1}
-    assert_equal @ret, @rc.mapcount_countup_ms(@k, @sk, 0)
-    assert_equal @ret, @rc.mapcount_update_ms(@k, @sk, 1)
+    check_roma_value(@ret, @rc.mapcount_countup_ms(@k, @sk, 0))
+    check_roma_value(@ret, @rc.mapcount_update_ms(@k, @sk, 1))
     sleep 2
     assert_nil @rc.mapcount_get_ms(@k)
   end
 
   def test_mapcount_update_ms_time
     ret = {"last_updated_date"=>@lt, @sk=>1}
-    assert_equal @ret, @rc.mapcount_countup_ms(@k, @sk, 0)
+    check_roma_value(@ret, @rc.mapcount_countup_ms(@k, @sk, 0))
     sleep 2
     lt2 = Time.parse(Time.now.strftime(DATE_FORMAT))
     ret2 = {"last_updated_date"=>lt2, @sk=>1}
-    assert_equal ret2, @rc.mapcount_update_ms(@k)
+    check_roma_value(ret2, @rc.mapcount_update_ms(@k))
   end
 
   def test_counts_ms