runo 0.1.0

data/t/test_storage.rb

@@ -0,0 +1,915 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require "#{::File.dirname __FILE__}/t"
+
+class TC_Storage < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_instance
+    sd = Runo::Set::Static::Folder.root.item('t_select', 'main')
+
+    assert_instance_of(
+      Runo::Storage.const_get(Runo['storage']['default']),
+      sd.storage,
+      'Storage.instance should return a File instance when the set is right under the folder'
+    )
+
+    child_set = Runo::Field.instance(
+      :klass  => 'set-dynamic',
+      :parent => sd
+    )
+    assert_instance_of(
+      Runo::Storage::Temp,
+      child_set.storage,
+      'Storage.instance should return a Temp when the set is not a child of the folder'
+    )
+
+    orphan_set = Runo::Field.instance(
+      :klass  => 'set-dynamic'
+    )
+    assert_instance_of(
+      Runo::Storage::Temp,
+      orphan_set.storage,
+      'Storage.instance should return a Temp when the set is a direct child of the folder'
+    )
+  end
+
+  def test_fetch
+    sd = Runo::Set::Static::Folder.root.item('t_select', 'main')
+    sd[:order]  = 'id'
+    sd[:p_size] = 10
+
+    Runo::Storage.constants.collect {|c| Runo::Storage.const_get c }.each {|klass|
+      next unless klass.is_a?(::Class) && klass.available?
+
+      storage = klass.new sd
+      storage.build(
+        '20091114_0001' => {'name' => 'bar',  'comment' => 'I am BAR!'},
+        '20091115_0001' => {'name' => 'qux',  'comment' => 'Qux! Qux!'},
+        '20091114_0002' => {'name' => 'baz',  'comment' => 'BAZ BAZ...'},
+        '20091225_0001' => {'name' => 'quux', 'comment' => 'Quux?'},
+        '20091225_0002' => {'name' => 'corge', 'comment' => 'Corge.'},
+        '20091226_0001' => {'name' => 'bar',  'comment' => 'I am BAR again!'}
+      )
+
+      _test_select(storage)
+      _test_sort(storage)
+      _test_order(storage)
+      _test_page(storage)
+      _test_val(storage)
+      _test_navi(storage)
+      _test_last(storage)
+
+      storage.build(
+        '00000000_frank' => {'name' => 'fz',  'comment' => 'I am FZ!'},
+        '00000000_carl'  => {'name' => 'cz',  'comment' => 'I am CZ!'},
+        '00000000_bobby' => {'name' => 'bz',  'comment' => 'I am BZ!'}
+      )
+      _test_fetch_special_id(storage)
+
+      storage.clear # so far, storage with raw values can not be built at once.
+      storage.store('20100406_0001', "\x01\x02\x03", 'jpg')
+      _test_val_raw(storage)
+
+      storage.clear
+
+      _test_traverse(storage) if storage.is_a? Runo::Storage::File # TODO: other parsistent
+    }
+  end
+
+  def _test_select(storage)
+    assert_equal(
+      [
+        '20091114_0001',
+        '20091114_0002',
+        '20091115_0001',
+        '20091225_0001',
+        '20091225_0002',
+        '20091226_0001',
+      ],
+      storage.select,
+      "#{storage.class}#select should return item ids that match given conds"
+    )
+    assert_equal(
+      ['20091114_0001'],
+      storage.select(:id => '20091114_0001'),
+      "#{storage.class}#select should return item ids that match given conds"
+    )
+    assert_equal(
+      ['20091115_0001'],
+      storage.select(:d => '20091115'),
+      "#{storage.class}#select should return item ids that match given conds"
+    )
+  end
+
+  def _test_sort(storage)
+    assert_equal(
+      [
+        '20091114_0001',
+        '20091114_0002',
+        '20091115_0001',
+        '20091225_0001',
+        '20091225_0002',
+        '20091226_0001',
+      ],
+      storage.select(:order => 'd'),
+      "#{storage.class}#_sort should sort the item ids returned by _select()"
+    )
+    assert_equal(
+      [
+        '20091226_0001',
+        '20091225_0002',
+        '20091225_0001',
+        '20091115_0001',
+        '20091114_0002',
+        '20091114_0001',
+      ],
+      storage.select(:order => '-d'),
+      "#{storage.class}#_sort should sort the item ids returned by _select()"
+    )
+  end
+
+  def _test_order(storage)
+    storage.sd[:order] = 'id'
+    assert_equal(
+      [
+        '20091114_0001',
+        '20091114_0002',
+        '20091115_0001',
+        '20091225_0001',
+        '20091225_0002',
+        '20091226_0001',
+      ],
+      storage.select,
+      "#{storage.class}#_sort should refer to sd[:order]"
+    )
+
+    storage.sd[:order] = '-id'
+    assert_equal(
+      [
+        '20091226_0001',
+        '20091225_0002',
+        '20091225_0001',
+        '20091115_0001',
+        '20091114_0002',
+        '20091114_0001',
+      ],
+      storage.select,
+      "#{storage.class}#_sort should refer to sd[:order]"
+    )
+
+    storage.sd[:order] = '-id'
+    assert_equal(
+      [
+        '20091114_0001',
+        '20091114_0002',
+        '20091115_0001',
+        '20091225_0001',
+        '20091225_0002',
+        '20091226_0001',
+      ],
+      storage.select(:order => 'id'),
+      "#{storage.class}#_sort should override sd[:order] by conds[:order]"
+    )
+
+    storage.sd[:order] = 'id'
+  end
+
+  def _test_page(storage)
+    storage.sd[:p_size] = 4
+    assert_equal(
+      ['20091114_0001', '20091114_0002', '20091115_0001', '20091225_0001'],
+      storage.select(:p => 1),
+      "#{storage.class}#_page should paginate the item ids returned by _select()"
+    )
+    assert_equal(
+      ['20091225_0002', '20091226_0001'],
+      storage.select(:p => 2),
+      "#{storage.class}#_page should paginate the item ids returned by _select()"
+    )
+    assert_equal(
+      [],
+      storage.select(:p => 3),
+      "#{storage.class}#_page should return an empty list if the page does not exist"
+    )
+    storage.sd[:p_size] = 10
+  end
+
+  def _test_val(storage)
+    assert_equal(
+      {'name' => 'baz', 'comment' => 'BAZ BAZ...'},
+      storage.val('20091114_0002'),
+      "#{storage.class}#val should return the item value"
+    )
+    assert_nil(
+      storage.val('non-existent'),
+      "#{storage.class}#val should return nil when there is no item"
+    )
+    assert_nil(
+      storage.val(''),
+      "#{storage.class}#val should return nil when there is no item"
+    )
+  end
+
+  def _test_val_raw(storage)
+    assert_equal(
+      "\x01\x02\x03",
+      storage.val('20100406_0001'),
+      "#{storage.class}#val should return the raw value unless the value is not a hash"
+    )
+  end
+
+  def _test_traverse(storage)
+    assert_equal(
+      [
+        '-foo-main-20091120_0001, yaml',
+        '-foo-bar-main-20091120_0001, yaml',
+        '-foo-sub-20100306_0001, yaml',
+      ],
+      storage.class.traverse('/foo') {|entry| "#{entry[:full_name]}, #{entry[:ext]}" },
+      "#{storage.class}.traverse should traverse over the given dir"
+    )
+  end
+
+  def _test_navi(storage)
+    _test_navi_p(storage)
+    _test_navi_id(storage)
+    _test_navi_d(storage)
+    _test_navi_all(storage)
+
+    storage.sd[:p_size] = 10
+  end
+
+  def _test_navi_p(storage)
+    storage.sd[:p_size] = 2
+    assert_equal(
+      {
+        :prev => {:d => '200912', :p => '1'},
+        :sibs => {:p => ['1', '2']},
+      },
+      storage.navi(:d => '200912', :p => '2'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :prev => {:d => '200911', :p => '2'},
+        :next => {:d => '200912', :p => '2'},
+        :sibs => {:p => ['1', '2']},
+      },
+      storage.navi(:d => '200912', :p => '1'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :prev => {:d => '200911', :p => '1'},
+        :next => {:d => '200912', :p => '1'},
+        :sibs => {:p => ['1', '2']},
+      },
+      storage.navi(:d => '200911', :p => '2'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :next => {:d => '200911', :p => '2'},
+        :sibs => {:p => ['1', '2']},
+      },
+      storage.navi(:d => '200911', :p => '1'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+  end
+
+  def _test_navi_id(storage)
+    storage.sd[:p_size] = 2
+    assert_equal(
+      {
+        :prev => {:id => '20091225_0002'},
+        :sibs => {
+          :id => [
+            '20091114_0001',
+            '20091114_0002',
+            '20091115_0001',
+            '20091225_0001',
+            '20091225_0002',
+            '20091226_0001',
+          ],
+        },
+      },
+      storage.navi(:id => '20091226_0001'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+
+    assert_equal(
+      {
+        :prev => {:d => '200912', :id => '20091225_0002'},
+        :sibs => {:id => ['20091225_0001', '20091225_0002', '20091226_0001']},
+      },
+      storage.navi(:d => '200912', :id => '20091226_0001'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :prev => {:d => '200911', :id => '20091115_0001'},
+        :next => {:d => '200912', :id => '20091225_0002'},
+        :sibs => {:id => ['20091225_0001', '20091225_0002', '20091226_0001']},
+      },
+      storage.navi(:d => '200912', :id => '20091225_0001'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :prev => {:d => '200911', :id => '20091114_0002'},
+        :next => {:d => '200912', :id => '20091225_0001'},
+        :sibs => {:id => ['20091114_0001', '20091114_0002', '20091115_0001']},
+      },
+      storage.navi(:d => '200911', :id => '20091115_0001'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :next => {:d => '200911', :id => '20091114_0002'},
+        :sibs => {:id => ['20091114_0001', '20091114_0002', '20091115_0001']},
+      },
+      storage.navi(:d => '200911', :id => '20091114_0001'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+  end
+
+  def _test_navi_d(storage)
+    storage.sd[:p_size] = nil
+    assert_equal(
+      {
+        :prev => {:d => '200911'},
+        :sibs => {:d => ['200911', '200912']},
+      },
+      storage.navi(:d => '200912'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :next => {:d => '200912'},
+        :sibs => {:d => ['200911', '200912']},
+      },
+      storage.navi(:d => '200911'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+
+    assert_equal(
+      {
+        :prev => {:d => '200911', :order => 'd'},
+        :sibs => {:d => ['200911', '200912']},
+      },
+      storage.navi(:d => '200912', :order => 'd'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+    assert_equal(
+      {
+        :next => {:d => '200912', :order => '-d'},
+        :sibs => {:d => ['200911', '200912']},
+      },
+      storage.navi(:d => '200911', :order => '-d'),
+      "#{storage.class}#navi should return the next conditions for the given conds"
+    )
+  end
+
+  def _test_navi_all(storage)
+    storage.sd[:p_size] = nil
+    assert_equal(
+      {},
+      storage.navi({}),
+      "#{storage.class}#navi without conds should return an empty navi"
+    )
+  end
+
+  def _test_last(storage)
+    assert_equal(
+      '20091226',
+      storage.last(:d, :d => '99999999'),
+      "#{storage.class}#last should cast 'the last' conds"
+    )
+    assert_equal(
+      '200912',
+      storage.last(:d, :d => '999999'),
+      "#{storage.class}#last should cast 'the last' conds"
+    )
+
+    assert_equal(
+      '20091226_0001',
+      storage.last(:id, :id => ['20091114_0001', 'last']),
+      "#{storage.class}#last should cast 'the last' conds"
+    )
+
+    storage.sd[:p_size] = 2
+    assert_equal(
+      '3',
+      storage.last(:p, :p => 'last'),
+      "#{storage.class}#last should cast 'the last' conds"
+    )
+    storage.sd[:p_size] = 10
+  end
+
+  def _test_fetch_special_id(storage)
+    assert_equal(
+      [
+        '00000000_bobby',
+        '00000000_carl',
+        '00000000_frank',
+      ],
+      storage.select,
+      "#{storage.class}#select should be able to select special ids"
+    )
+    assert_equal(
+      ['00000000_carl'],
+      storage.select(:id => '00000000_carl'),
+      "#{storage.class}#select should be able to select special ids"
+    )
+    assert_equal(
+      ['00000000_bobby'],
+      storage.select(:id => 'bobby'),
+      "#{storage.class}#select should expand short ids"
+    )
+
+    assert_equal(
+      [
+        '00000000_frank',
+        '00000000_carl',
+        '00000000_bobby',
+      ],
+      storage.select(:order => '-id'),
+      "#{storage.class}#select should sort special ids"
+    )
+
+    assert_equal(
+      {
+        :next => {:id => '00000000_carl'},
+        :sibs => {:id => ['00000000_bobby', '00000000_carl', '00000000_frank']},
+      },
+      storage.navi(:id => '00000000_bobby'),
+      "#{storage.class}#navi should return the next conditions for special ids"
+    )
+  end
+
+  def test_store
+    sd = Runo::Set::Static::Folder.root.item('t_store', 'main')
+
+    Runo::Storage.constants.collect {|c| Runo::Storage.const_get c }.each {|klass|
+      next unless klass.is_a?(::Class) && klass.available?
+
+      storage = klass.new sd
+      storage.clear
+
+      id = _test_add(storage)
+      _test_update(storage, id)
+      _test_delete(storage, id)
+
+      _test_new_id(storage)
+      _test_rename(storage)
+      _test_clear(storage)
+
+      id = _test_add_raw(storage)
+      _test_update_raw(storage, id)
+      _test_delete_raw(storage, id)
+      _test_clear_raw(storage)
+
+      _test_delete_substr(storage) unless klass == Runo::Storage::Temp
+      _test_load_skel(storage) unless klass == Runo::Storage::Temp
+    }
+  end
+
+  def _test_add(storage)
+    id = nil
+    assert_nothing_raised(
+      "#{storage.class}#store should work nicely"
+    ) {
+      id = storage.store(:new_id, {'foo' => 'bar'})
+    }
+    assert_match(
+      Runo::REX::ID,
+      id,
+      "#{storage.class}#store should return the id of the created item"
+    )
+    assert_equal(
+      {'foo' => 'bar'},
+      storage.val(id),
+      "#{storage.class}#store should store the element with the given id"
+    )
+    id # for other tests
+  end
+
+  def _test_update(storage, id)
+    storage.store(id, {'foo' => 'updated'})
+    assert_equal(
+      {'foo' => 'updated'},
+      storage.val(id),
+      "#{storage.class}#store should store the element with the given id"
+    )
+  end
+
+  def _test_delete(storage, id)
+    assert_nothing_raised(
+      "#{storage.class}#delete should work nicely"
+    ) {
+      id = storage.delete(id)
+    }
+    assert_match(
+      Runo::REX::ID,
+      id,
+      "#{storage.class}#delete should return the id of the deleted item"
+    )
+    assert_nil(
+      storage.val(id),
+      "#{storage.class}#delete should delete the element with the given id"
+    )
+  end
+
+  def _test_new_id(storage)
+    id1 = storage.store(:new_id, {'foo' => 'bar'})
+    assert_match(
+      Runo::REX::ID,
+      id1,
+      "#{storage.class}#new_id should return a valid id for the element"
+    )
+
+    id2 = storage.store(:new_id, {'foo' => 'bar'})
+    assert_match(
+      Runo::REX::ID,
+      id2,
+      "#{storage.class}#new_id should return a valid id for the element"
+    )
+    assert_not_equal(
+      id1,
+      id2,
+      "#{storage.class}#new_id should return a unique id for the element"
+    )
+
+    id3 = storage.store(:new_id, {'foo' => 'bar', '_id' => 'carl'})
+    assert_match(
+      Runo::REX::ID,
+      id3,
+      "#{storage.class}#new_id should return a valid id for the element"
+    )
+    assert_equal(
+      '00000000_carl',
+      id3,
+      "#{storage.class}#new_id should refer to val['_id'] if available"
+    )
+
+    id4 = storage.store(:new_id, {'foo' => 'duplicated!', '_id' => 'carl'})
+    assert_nil(
+      id4,
+      "#{storage.class}#store should not create an item with a duplicate id"
+    )
+
+    id5 = storage.store(
+      :new_id,
+      {'_timestamp' => {'published' => Time.local(1981, 4, 26)}}
+    )
+    assert_match(
+      Runo::REX::ID,
+      id5,
+      "#{storage.class}#new_id should return a valid id for the element"
+    )
+    assert_equal(
+      '19810426_0001',
+      id5,
+      "#{storage.class}#new_id should refer to val['_timestamp'] if available"
+    )
+  end
+
+  def _test_rename(storage)
+    orig_id = storage.store(:new_id, {'_id' => 'test', 'foo' => 'bar'})
+    file_id = storage.store("#{orig_id}-file", 'i am file.', 'bin')
+    new_id  = storage.store(orig_id, {'_id' => 'renamed'})
+
+    assert_not_equal(
+      orig_id,
+      new_id,
+      "#{storage.class}#store should rename the element given a different _id"
+    )
+    assert_equal(
+      {'_id' => 'renamed'},
+      storage.val(new_id),
+      "#{storage.class}#store should rename the element given a different _id"
+    )
+    assert_equal(
+      'i am file.',
+      storage.val("#{new_id}-file"),
+      "#{storage.class}#store should rename the descendant elements"
+    )
+    assert_nil(
+      storage.val(orig_id),
+      "#{storage.class}#store should rename the element given a different _id"
+    )
+    assert_nil(
+      storage.val(file_id),
+      "#{storage.class}#store should rename the descendant elements"
+    )
+
+    orig_id = storage.store(:new_id, {'foo' => 'bar'})
+    new_id  = storage.store(orig_id, {'_timestamp' => {'published' => Time.local(2010, 4, 15)}})
+
+    assert_not_equal(
+      orig_id,
+      new_id,
+      "#{storage.class}#store should rename the element given a different _timestamp"
+    )
+    assert_equal(
+      {'_timestamp' => {'published' => Time.local(2010, 4, 15)}},
+      storage.val(new_id),
+      "#{storage.class}#store should rename the element given a different _timestamp"
+    )
+    assert_nil(
+      storage.val(orig_id),
+      "#{storage.class}#store should rename the element given a different _timestamp"
+    )
+  end
+
+  def _test_clear(storage)
+    id1 = storage.store(:new_id, {'foo' => 'bar'})
+    id2 = storage.store(:new_id, {'foo' => 'bar'})
+
+    storage.clear
+
+    assert_nil(
+      storage.val(id1),
+      "#{storage.class}#clear should delete all elements"
+    )
+    assert_nil(
+      storage.val(id2),
+      "#{storage.class}#clear should delete all elements"
+    )
+  end
+
+  def _test_add_raw(storage)
+    id = nil
+    assert_nothing_raised(
+      "#{storage.class}#store should store raw value nicely"
+    ) {
+      id = storage.store(:new_id, "\x01\x02\x03", 'jpg')
+    }
+    assert_equal(
+      "\x01\x02\x03",
+      storage.val(id),
+      "#{storage.class}#store should store the raw file with the given id"
+    )
+    id # for other tests
+  end
+
+  def _test_update_raw(storage, id)
+    storage.store(id, "\x04\x05\x06", 'png')
+    assert_equal(
+      "\x04\x05\x06",
+      storage.val(id),
+      "#{storage.class}#store should overwrite a file with the same id"
+    )
+  end
+
+  def _test_delete_raw(storage, id)
+    assert_nothing_raised(
+      "#{storage.class}#delete should work nicely on raw files"
+    ) {
+      id = storage.delete(id)
+    }
+    assert_match(
+      Runo::REX::ID,
+      id,
+      "#{storage.class}#delete should return the id of the deleted item"
+    )
+    assert_nil(
+      storage.val(id),
+      "#{storage.class}#delete should delete the element with the given id"
+    )
+  end
+
+  def _test_clear_raw(storage)
+    id1 = storage.store('20100430_0001-file', "\x03\x02\x01", 'jpg')
+    id2 = storage.store('20100430_0002-file', "\x03\x02\x01", 'png')
+
+    storage.clear
+
+    assert_nil(
+      storage.val(id1),
+      "#{storage.class}#clear should delete all elements"
+    )
+    assert_nil(
+      storage.val(id2),
+      "#{storage.class}#clear should delete all elements"
+    )
+  end
+
+  def _test_load_skel(storage)
+    sd = Runo::Set::Static::Folder.root.item('t_summary', 'main')
+    storage = storage.class.new sd
+
+    storage.delete '20100326_0001'
+    assert_nil(storage.val('20100326_0001'))
+
+    storage.class.load_skel
+    assert_equal(
+      {'name' => 'frank', 'comment' => 'hi.'},
+      storage.val('20100326_0001'),
+      "#{storage.class}.load_skel should load the default entries"
+    )
+  end
+
+  def _test_delete_substr(storage)
+    storage.clear
+    storage.store('00000000_bob', {'foo' => 'bar'})
+    storage.store('00000000_bobby', {'foo' => 'baz'})
+    storage.delete '00000000_bob'
+    assert_equal(
+      {'00000000_bobby' => {'foo' => 'baz'}},
+      storage.val,
+      "#{storage.class}#delete should not delete another ids that matches the given id"
+    )
+
+    storage.clear
+    storage.store('20100527_1234', {'foo' => 'bar'})
+    storage.store('20100527_12345', {'foo' => 'baz'})
+    storage.delete '20100527_1234'
+    assert_equal(
+      {'20100527_12345' => {'foo' => 'baz'}},
+      storage.val,
+      "#{storage.class}#delete should not delete another ids that matches the given id"
+    )
+
+    storage.clear
+    storage.store('00000000_bob', {'foo' => 'bar'})
+    storage.store('00000000_bob-foo', 'qux', 'bin')
+    storage.store('00000000_bobby', {'foo' => 'baz'})
+    storage.delete '00000000_bob'
+    assert_equal(
+      {'00000000_bobby' => {'foo' => 'baz'}},
+      storage.val,
+      "#{storage.class}#delete should delete child ids that matches the given id"
+    )
+  end
+
+  def test_cast_d
+    sd = Runo::Set::Dynamic.new(
+      :klass => 'set-dynamic'
+    ).load(
+      '20091128_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091130_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091201_0001' => {'name' => 'frank', 'comment' => 'bar'}
+    )
+    storage = sd.storage
+
+    assert_equal(
+      {:d => '20100131'},
+      storage.send(
+        :_cast,
+        {:d => ['20100131']}
+      ),
+      'Storage#_cast should cast conds[:d] as a string'
+    )
+    assert_equal(
+      {:d => nil},
+      storage.send(
+        :_cast,
+        {:d => '30100131'}
+      ),
+      'Storage#_cast should bang malformed conds[:d]'
+    )
+    assert_equal(
+      {:d => '20091201'},
+      storage.send(
+        :_cast,
+        {:d => '99999999'}
+      ),
+      "Storage#_cast should cast 'the last' conds"
+    )
+    assert_equal(
+      {:d => '200912'},
+      storage.send(
+        :_cast,
+        {:d => '999999'}
+      ),
+      "Storage#_cast should cast 'the last' conds"
+    )
+  end
+
+  def test_cast_id
+    sd = Runo::Set::Dynamic.new(
+      :klass => 'set-dynamic'
+    ).load(
+      '20091128_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091130_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091226_0001' => {'name' => 'frank', 'comment' => 'bar'}
+    )
+    storage = sd.storage
+
+    assert_equal(
+      {:id => ['20091226_0001']},
+      storage.send(
+        :_cast,
+        {:id => '20091226_0001'}
+      ),
+      'Storage#_cast should cast conds[:id] as an array'
+    )
+    assert_equal(
+      {:id => ['20091226_0001']},
+      storage.send(
+        :_cast,
+        {:id => ['20091226_0001', '../i_am_evil']}
+      ),
+      'Storage#_cast should bang malformed conds[:id]'
+    )
+    assert_equal(
+      {:id => ['20091114_0001', '20091226_0001']},
+      storage.send(
+        :_cast,
+        {:id => ['20091114_0001', 'last']}
+      ),
+      "Storage#_cast should cast 'the last' conds"
+    )
+  end
+
+  def test_cast_p
+    sd = Runo::Set::Dynamic.new(
+      :klass => 'set-dynamic'
+    ).load(
+      '20091128_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091130_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20091226_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20100207_0001' => {'name' => 'frank', 'comment' => 'bar'},
+      '20100207_0002' => {'name' => 'frank', 'comment' => 'bar'}
+    )
+    storage = sd.storage
+
+    sd[:p_size] = 2
+    assert_equal(
+      {:p => '123'},
+      storage.send(
+        :_cast,
+        {:p => ['123']}
+      ),
+      'Storage#_cast should cast conds[:p] as a string'
+    )
+    assert_equal(
+      {:p => nil},
+      storage.send(
+        :_cast,
+        {:p => 'i am evil'}
+      ),
+      'Storage#_cast should bang malformed conds[:p]'
+    )
+    assert_equal(
+      {:p => '3'},
+      storage.send(
+        :_cast,
+        {:p => 'last'}
+      ),
+      "Storage#_cast should cast 'the last' conds"
+    )
+  end
+
+  def test_new_id?
+    storage = Runo::Set::Static::Folder.root.item('t_select', 'main').storage
+
+    assert(
+      storage.send(:new_id?, :new_id, {}),
+      'Storage#new_id? should return true if the current id is :new_id'
+    )
+
+    assert(
+      !storage.send(:new_id?, '20100523_0001', 'foo'),
+      'Storage#new_id? should return false if v is a scalar'
+    )
+
+    assert(
+      !storage.send(:new_id?, '00000000_foo', {'_id' => 'foo'}),
+      "Storage#new_id? should return false if v['_id'] is same as the current id"
+    )
+    assert(
+      storage.send(:new_id?, '00000000_foo', {'_id' => 'bar'}),
+      "Storage#new_id? should return true if v['_id'] differs from the current id"
+    )
+
+    assert(
+      !storage.send(:new_id?, '20100523_0001', {'_timestamp' => {'published' => Time.parse('2010-05-23')}}),
+      "Storage#new_id? should return false if v['_timestamp'] is same as the current id"
+    )
+    assert(
+      storage.send(:new_id?, '20100523_0001', {'_timestamp' => {'published' => Time.parse('2010-05-24')}}),
+      "Storage#new_id? should return false if v['_timestamp'] differs from the current id"
+    )
+
+    assert(
+      !storage.send(:new_id?, '00000000_foo', {'_id' => 'foo', '_timestamp' => {'published' => Time.parse('2010-05-24')}}),
+      "Storage#new_id? should not refer to v['timestamp'] if v['_id'] matched SHORT_ID"
+    )
+    assert(
+      !storage.send(:new_id?, '00000000_foo', {'_timestamp' => {'published' => Time.parse('2010-05-24')}}),
+      "Storage#new_id? should not refer to v['timestamp'] if v['_id'] matched SHORT_ID"
+    )
+  end
+
+end