higgs 0.1.0

data/test/test_storage_init_opts.rb

@@ -0,0 +1,89 @@
+#!/usr/local/bin/ruby
+
+require 'higgs/storage'
+require 'test/unit'
+
+module Higgs::Test
+  class StorageInitOptionsTest < Test::Unit::TestCase
+    # for ident(1)
+    CVS_ID = '$Id: test_storage_init_opts.rb 559 2007-09-25 15:20:20Z toki $'
+
+    include Higgs::Storage::InitOptions
+
+    def test_default
+      init_options({})
+      assert_equal(false, @read_only)
+      assert_equal(false, self.read_only)
+      assert_equal(2, @number_of_read_io)
+      assert_equal(2, self.number_of_read_io)
+      assert_instance_of(Higgs::LRUCache, @properties_cache) # auto: require 'higgs/cache'
+      assert_equal(false, @jlog_sync)
+      assert_equal(false, self.jlog_sync)
+      assert_equal(1024 * 256, @jlog_rotate_size)
+      assert_equal(1024 * 256, self.jlog_rotate_size)
+      assert_equal(1, @jlog_rotate_max)
+      assert_equal(1, self.jlog_rotate_max)
+      assert_equal(nil, @jlog_rotate_service_uri)
+      assert_equal(nil, self.jlog_rotate_service_uri)
+      assert_instance_of(Proc, @Logger)
+    end
+
+    def test_read_only_true
+      init_options(:read_only => true)
+      assert_equal(true, @read_only)
+      assert_equal(true, self.read_only)
+    end
+
+    def test_read_only_false
+      init_options(:read_only => false)
+      assert_equal(false, @read_only)
+      assert_equal(false, self.read_only)
+    end
+
+    def test_number_of_read_io
+      init_options(:number_of_read_io => 16)
+      assert_equal(16, @number_of_read_io)
+      assert_equal(16, self.number_of_read_io)
+    end
+
+    def test_properties_cache
+      init_options(:properties_cache => :dummy_cache)
+      assert_equal(:dummy_cache, @properties_cache)
+    end
+
+    def test_jlog_sync_true
+      init_options(:jlog_sync => true)
+      assert_equal(true, @jlog_sync)
+      assert_equal(true, self.jlog_sync)
+    end
+
+    def test_jlog_sync_false
+      init_options(:jlog_sync => false)
+      assert_equal(false, @jlog_sync)
+      assert_equal(false, self.jlog_sync)
+    end
+
+    def test_jlog_rotate_size
+      init_options(:jlog_rotate_size => 1024**2)
+      assert_equal(1024**2, @jlog_rotate_size)
+      assert_equal(1024**2, self.jlog_rotate_size)
+    end
+
+    def test_jlog_rotate_max
+      init_options(:jlog_rotate_max => 100)
+      assert_equal(100, @jlog_rotate_max)
+      assert_equal(100, self.jlog_rotate_max)
+    end
+
+    def test_jlog_rotate_service_uri
+      init_options(:jlog_rotate_service_uri => 'druby://localhost:14142')
+      assert_equal('druby://localhost:14142', @jlog_rotate_service_uri)
+      assert_equal('druby://localhost:14142', self.jlog_rotate_service_uri)
+    end
+
+    def test_logger
+      init_options(:logger => proc{|path| :dummy_logger })
+      assert_equal(:dummy_logger, @Logger.call('foo'))
+    end
+  end
+end

data/test/test_store.rb

@@ -0,0 +1,211 @@
+#!/usr/local/bin/ruby
+
+require 'fileutils'
+require 'higgs/store'
+require 'logger'
+require 'test/unit'
+
+module Higgs::Test
+  class StoreTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_store.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @test_dir = 'store_test'
+      FileUtils.rm_rf(@test_dir) # for debug
+      FileUtils.mkdir_p(@test_dir)
+      @name = File.join(@test_dir, 'foo')
+      @st = Store.new(@name,
+                      :logger => proc{|path|
+                        logger = Logger.new(path, 1)
+                        logger.level = Logger::DEBUG
+                        logger
+                      })
+    end
+
+    def teardown
+      @st.shutdown unless @st.shutdown?
+      FileUtils.rm_rf(@test_dir) unless $DEBUG
+    end
+
+    def test_fetch_and_store
+      @st.transaction{|tx|
+        assert_equal(nil, tx[:foo])
+        assert_equal(nil, tx['bar'])
+        assert_equal(nil, tx[0])
+
+        assert_equal(false, (tx.key? :foo))
+        assert_equal(false, (tx.key? 'bar'))
+        assert_equal(false, (tx.key? 0))
+
+        tx[:foo] = :HALO
+        tx['bar'] = "Hello world.\n"
+        tx[0] = nil
+
+        assert_equal(:HALO,            tx[:foo])
+        assert_equal("Hello world.\n", tx['bar'])
+        assert_equal(nil,              tx[0])
+
+        assert_equal(true, (tx.key? :foo))
+        assert_equal(true, (tx.key? 'bar'))
+        assert_equal(true, (tx.key? 0))
+      }
+
+      @st.transaction{|tx|
+        assert_equal(:HALO,            tx[:foo])
+        assert_equal("Hello world.\n", tx['bar'])
+        assert_equal(nil,              tx[0])
+
+        assert_equal(true, (tx.key? :foo))
+        assert_equal(true, (tx.key? 'bar'))
+        assert_equal(true, (tx.key? 0))
+      }
+    end
+
+    def test_update
+      @st.transaction{|tx|
+        tx[:foo] = []
+      }
+
+      @st.transaction{|tx|
+        tx.update(:foo) {|a|
+          a << 'apple'
+          a << 'banana'
+          a << 'orange'
+        }
+      }
+
+      @st.transaction{|tx|
+        assert_equal(%w[ apple banana orange ], tx[:foo])
+      }
+    end
+
+    def test_update_with_default_value
+      @st.transaction{|tx|
+        assert(! (tx.key? :foo))
+        tx.update(:foo, []) {|a|
+          a << 'apple'
+          a << 'banana'
+          a << 'orange'
+        }
+      }
+
+      @st.transaction{|tx|
+        assert_equal(%w[ apple banana orange ], tx[:foo])
+      }
+    end
+
+    def test_update_IndexError
+      @st.transaction{|tx|
+        assert_raise(IndexError) {
+          tx.update(:foo) {|value|
+            flunk('not to reach.')
+          }
+        }
+      }
+    end
+
+    def test_string_only
+      @st.transaction{|tx|
+        assert_equal(nil, tx.property(:foo, :string_only))
+        tx[:foo] = 0
+      }
+
+      @st.transaction{|tx|
+        assert_equal(false, tx.property(:foo, :string_only))
+        assert_equal(0, tx[:foo])
+        tx.set_property(:foo, :string_only, true)
+        assert_equal(0, tx[:foo])
+      }
+
+      @st.transaction{|tx|
+        assert_equal(true, tx.property(:foo, :string_only))
+        assert_equal(Marshal.dump(0), tx[:foo])
+        tx[:foo] = "Hello world.\n"
+      }
+
+      @st.transaction{|tx|
+        assert_equal(true, tx.property(:foo, :string_only))
+        assert_equal("Hello world.\n", tx[:foo])
+      }
+    end
+
+    def test_string_only_TypeError_cant_convert_into_String
+      @st.transaction{|tx|
+        tx[:foo] = 0
+        tx.set_property(:foo, :string_only, true)
+        assert_raise(TypeError) { tx.commit }
+        tx.rollback
+      }
+    end
+
+    def test_rollback
+      @st.transaction{|tx|
+        tx[:foo] = %w[ apple banana orange ]
+      }
+
+      @st.transaction{|tx|
+        fruits = tx[:foo]
+        assert_equal(%w[ apple banana orange ], fruits)
+        assert_equal('orange', fruits.pop)
+        assert_equal(%w[ apple banana ], fruits)
+        tx[:foo] = fruits
+        tx.rollback
+        assert_equal(%w[ apple banana orange ], tx[:foo])
+      }
+
+      @st.transaction{|tx|
+        assert_equal(%w[ apple banana orange ], tx[:foo])
+      }
+    end
+
+    def test_replica_problem
+      @st.transaction{|tx|
+        tx[:foo] = 'a'
+        tx[:bar] = tx[:foo]
+
+        assert_equal('a', tx[:foo])
+        assert_equal('a', tx[:bar])
+        assert_same(tx[:foo], tx[:bar])
+
+        tx[:foo].succ!
+        assert_equal('b', tx[:foo])
+        assert_equal('b', tx[:bar])
+        assert_same(tx[:foo], tx[:bar])
+      }
+
+      @st.transaction{|tx|
+        assert_equal('b', tx[:foo])
+        assert_equal('b', tx[:bar])
+        assert_not_same(tx[:foo], tx[:bar])
+
+        tx[:foo].succ!
+        assert_equal('c', tx[:foo])
+        assert_equal('b', tx[:bar])
+        assert_not_same(tx[:foo], tx[:bar])
+      }
+    end
+
+    def test_each_key
+      @st.transaction{|tx|
+        tx[:foo] = 'apple'
+        tx[:bar] = ''
+        tx[:baz] = nil
+
+        expected_keys = [ :foo, :bar, :baz ]
+        tx.each_key do |key|
+          assert((expected_keys.include? key), key)
+          expected_keys.delete(key)
+        end
+        assert_equal([], expected_keys)
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: