roma 0.8.10 → 0.8.11

data/ruby/server/test/t_mapcountplugin.rb

@@ -15,6 +15,10 @@ class MapCountPluginTest < Test::Unit::TestCase
   def setup
     start_roma
     @rc=Roma::Client::RomaClient.new(["localhost_11211","localhost_11212"], [Roma::Client::Plugin::MapCount])
+    @k = "key1"
+    @sk = "subkey1"
+    @lt = Time.parse(Time.now.strftime(DATE_FORMAT))
+    @ret = {"last_updated_date"=>@lt, @sk=>1}
   end
 
   def teardown
@@ -23,209 +27,258 @@ class MapCountPluginTest < Test::Unit::TestCase
 
   def test_mapcount_get(n = 5)
     n.times do |i|
-      k = "subkey#{i}"
+      @sk = "subkey#{i}"
       expt = i
-      lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-
-      retc = {"last_updated_date"=>lt}
+      
+      retc = {"last_updated_date"=>@lt}
       (i+1).times do |j|
         retc["subkey#{j}"] = 1
       end
-      assert_equal retc, @rc.mapcount_countup('key1', k, 0)
-
-      retg = {"last_updated_date"=>lt}
+      assert_equal retc, @rc.mapcount_countup(@k, @sk, 0)
+      
+      retg = {"last_updated_date"=>@lt}
       retg["subkey#{i}"] = 1
-      assert_equal retg, @rc.mapcount_get('key1', k)
-      assert_equal retc, @rc.mapcount_get('key1')
-    end    
+      assert_equal retg, @rc.mapcount_get(@k, @sk)
+      assert_equal retc, @rc.mapcount_get(@k)
+    end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret = {"last_updated_date"=>lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret, @rc.mapcount_get('key1', 'subkey0,subkey1')
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal ret2, @rc.mapcount_get(@k, 'subkey0,subkey1')
   end
 
-  def test_mapcount_countup_expt
-    k = "subkey1"
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret = {"last_updated_date"=>lt, k=>1}
+  def test_mapcount_countup_array
+    assert_equal @ret, @rc.mapcount_countup(@k, [@sk])
+  end
+
+  def test_mapcount_countup_array_multi
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal 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)
+  end
+
+  def test_mapcount_countup_hash
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal ret2, @rc.mapcount_countup(@k, ["subkey0", "subkey1"])
 
-    assert_nil @rc.mapcount_get('key1', k)
-    assert_equal ret, @rc.mapcount_countup('key1', k, 1)
-    assert_equal ret, @rc.mapcount_get('key1', k)
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>1}
+    @rc.mapcount_countup(@k, {"subkey0" => 3})
+    assert_equal 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)
+  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)
+  end
+
+  def test_mapcount_countup_expt
+    assert_nil @rc.mapcount_get(@k, @sk)
+    assert_equal @ret, @rc.mapcount_countup(@k, @sk, 1)
+    assert_equal @ret, @rc.mapcount_get(@k, @sk)
     sleep 2
-    assert_nil @rc.mapcount_get('key1', k)
+    assert_nil @rc.mapcount_get(@k, @sk)
   end
 
   def test_mapcount_update
-    k = "subkey1"
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_time = {"last_updated_date"=>lt}
-    ret_all = {"last_updated_date"=>lt, k=>1}
-
-    assert_nil @rc.mapcount_update('key1')
-    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
-    assert_equal ret_all, @rc.mapcount_update('key1')
-    assert_equal ret_time, @rc.mapcount_update('key1', 'subkey2')
+    ret_time = {"last_updated_date"=>@lt}
 
-    assert_equal ret_all, @rc.mapcount_update('key1', nil, 1)
+    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)
     sleep 2
-    assert_nil @rc.mapcount_get('key1')
+    assert_nil @rc.mapcount_get(@k)
+  end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
-    assert_equal ret_all, @rc.mapcount_update('key1', k, 1)
+  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)
     sleep 2
-    assert_nil @rc.mapcount_get('key1')
+    assert_nil @rc.mapcount_get(@k)
+  end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_countup('key1', k, 0)
+  def test_mapcount_update_time
+    ret = {"last_updated_date"=>@lt, @sk=>1}
+    assert_equal @ret, @rc.mapcount_countup(@k, @sk, 0)
     sleep 2
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_update('key1')
+    lt2 = Time.parse(Time.now.strftime(DATE_FORMAT))
+    ret2 = {"last_updated_date"=>lt2, @sk=>1}
+    assert_equal ret2, @rc.mapcount_update(@k)
   end
 
   def test_counts
-    conn = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    if conn
-      conn.write "stat read_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 0, r[1].to_i
-      conn.gets
+    conn1 = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
+    conn2 = Roma::Messaging::ConPool.instance.get_connection("localhost_11212")
 
-      @rc.mapcount_get('key')
-      sleep 10
-      conn.write "stat read_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 1, r[1].to_i
-      conn.gets
+    if conn1 && conn2
+      conns = [conn1, conn2]
 
-      conn.write "stat write_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 0, r[1].to_i
-      conn.gets
+      ret = get_stat_sum(conns, "stat read_count\n")
+      assert_equal 0, ret
+
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 0, ret
+
+      @rc.mapcount_get('key')
+      ret = get_stat_sum(conns, "stat read_count\n")
+      assert_equal 1, ret
 
       @rc.mapcount_countup('key', 'subkey', 0)
-      sleep 10
-      conn.write "stat write_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 1, r[1].to_i
-      conn.gets
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 1, ret
 
       @rc.mapcount_update('key')
-      sleep 10
-      conn.write "stat write_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 2, r[1].to_i
-      conn.gets
-
-      conn.close
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 2, ret
+    else
+      flunk(message="Fail to get connection")
     end
+
+    conn1.close
+    conn2.close
   end
 
   def test_mapcount_get_ms(n = 5)
     n.times do |i|
-      k = "subkey#{i}"
+      @sk = "subkey#{i}"
       expt = i
-      lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-
-      retc = {"last_updated_date"=>lt}
+      
+      retc = {"last_updated_date"=>@lt}
       (i+1).times do |j|
         retc["subkey#{j}"] = 1
       end
-      assert_equal retc, @rc.mapcount_countup_ms('key1', k, 0)
-
-      retg = {"last_updated_date"=>lt}
+      assert_equal retc, @rc.mapcount_countup_ms(@k, @sk, 0)
+      
+      retg = {"last_updated_date"=>@lt}
       retg["subkey#{i}"] = 1
-      assert_equal retg, @rc.mapcount_get_ms('key1', k)
-      assert_equal retc, @rc.mapcount_get_ms('key1')
-    end    
+      assert_equal retg, @rc.mapcount_get_ms(@k, @sk)
+      assert_equal retc, @rc.mapcount_get_ms(@k)
+    end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret = {"last_updated_date"=>lt, "subkey0"=>1, "subkey1"=>1}
-    assert_equal ret, @rc.mapcount_get_ms('key1', 'subkey0,subkey1')
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>1}
+    assert_equal ret2, @rc.mapcount_get_ms(@k, 'subkey0,subkey1')
   end
 
-  def test_mapcount_countup_ms_expt
-    k = "subkey1"
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret = {"last_updated_date"=>lt, k=>1}
+  def test_mapcount_countup_ms_array
+    assert_equal @ret, @rc.mapcount_countup_ms(@k, [@sk])
+  end
+
+  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"])
+
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>1, "subkey1"=>2}
+    @rc.mapcount_countup_ms(@k, ["subkey1"])
+    assert_equal 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"])
+
+    ret2 = {"last_updated_date"=>@lt, "subkey0"=>4, "subkey1"=>1}
+    @rc.mapcount_countup_ms(@k, {"subkey0" => 3})
+    assert_equal ret2, @rc.mapcount_get_ms(@k)
 
-    assert_nil @rc.mapcount_get_ms('key1', k)
-    assert_equal ret, @rc.mapcount_countup_ms('key1', k, 1)
-    assert_equal ret, @rc.mapcount_get_ms('key1', 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)
+  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)
+  end
+
+  def test_mapcount_countup_ms_expt
+    assert_nil @rc.mapcount_get_ms(@k, @sk)
+    assert_equal @ret, @rc.mapcount_countup_ms(@k, @sk, 1)
+    assert_equal @ret, @rc.mapcount_get_ms(@k, @sk)
     sleep 2
-    assert_nil @rc.mapcount_get_ms('key1', k)
+    assert_nil @rc.mapcount_get_ms(@k, @sk)
   end
 
   def test_mapcount_update_ms
-    k = "subkey1"
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_time = {"last_updated_date"=>lt}
-    ret_all = {"last_updated_date"=>lt, k=>1}
+    ret_time = {"last_updated_date"=>@lt}
 
-    assert_nil @rc.mapcount_update_ms('key1')
-    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
-    assert_equal ret_all, @rc.mapcount_update_ms('key1')
-    assert_equal ret_time, @rc.mapcount_update_ms('key1', 'subkey2')
-
-    assert_equal ret_all, @rc.mapcount_update_ms('key1', nil, 1)
+    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)
     sleep 2
-    assert_nil @rc.mapcount_get_ms('key1')
+    assert_nil @rc.mapcount_get_ms(@k)
+  end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
-    assert_equal ret_all, @rc.mapcount_update_ms('key1', k, 1)
+  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)
     sleep 2
-    assert_nil @rc.mapcount_get_ms('key1')
+    assert_nil @rc.mapcount_get_ms(@k)
+  end
 
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_countup_ms('key1', k, 0)
+  def test_mapcount_update_ms_time
+    ret = {"last_updated_date"=>@lt, @sk=>1}
+    assert_equal @ret, @rc.mapcount_countup_ms(@k, @sk, 0)
     sleep 2
-    lt = Time.parse(Time.now.gmtime.strftime(DATE_FORMAT))
-    ret_all = {"last_updated_date"=>lt, k=>1}
-    assert_equal ret_all, @rc.mapcount_update_ms('key1')
+    lt2 = Time.parse(Time.now.strftime(DATE_FORMAT))
+    ret2 = {"last_updated_date"=>lt2, @sk=>1}
+    assert_equal ret2, @rc.mapcount_update_ms(@k)
   end
 
   def test_counts_ms
-    conn = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
-    if conn
-      conn.write "stat read_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 0, r[1].to_i
-      conn.gets
+    conn1 = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
+    conn2 = Roma::Messaging::ConPool.instance.get_connection("localhost_11212")
 
-      @rc.mapcount_get_ms('key')
-      sleep 10
-      conn.write "stat read_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 1, r[1].to_i
-      conn.gets
+    if conn1 && conn2
+      conns = [conn1, conn2]
 
-      conn.write "stat write_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 0, r[1].to_i
-      conn.gets
+      ret = get_stat_sum(conns, "stat read_count\n")
+      assert_equal 0, ret
+
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 0, ret
+
+      @rc.mapcount_get_ms('key')
+      ret = get_stat_sum(conns, "stat read_count\n")
+      assert_equal 1, ret
 
       @rc.mapcount_countup_ms('key', 'subkey', 0)
-      sleep 10
-      conn.write "stat write_count\n"
-      r = conn.gets.split(" ")
-      assert_equal 1, r[1].to_i
-      conn.gets
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 1, ret
 
       @rc.mapcount_update_ms('key')
-      sleep 10
-      conn.write "stat write_count\n"
+      ret = get_stat_sum(conns, "stat write_count\n")
+      assert_equal 2, ret
+    else
+      flunk(message="Fail to get connection")
+    end
+
+    conn1.close
+    conn2.close
+  end
+
+  private
+  def get_stat_sum(conns, msg)
+    sum = 0
+    conns.each do |conn|
+      conn.write(msg)
       r = conn.gets.split(" ")
-      assert_equal 2, r[1].to_i
+      sum += r[1].to_i
       conn.gets
-
-      conn.close
     end
+    sum
   end
-end # MapCountPluginTest
+
+end #MapCountPluginTest