test/test_registry.rb

   1 $:.unshift File.join(File.dirname(__FILE__), '../lib')
   2
   3 require 'test/unit'
   4 require 'rbot/ircbot'
   5 require 'rbot/registry'
   6
   7 require 'pp'
   8 require 'tmpdir'
   9
  10 class FooObj
  11   attr_reader :bar
  12   def initialize(bar)
  13     @bar = bar
  14   end
  15 end
  16
  17 module RegistryHashInterfaceTests
  18   def test_object
  19     @reg['store'] = {
  20       :my_obj => FooObj.new(42)
  21     }
  22
  23     assert_equal(42, @reg['store'][:my_obj].bar)
  24
  25     @reg.close
  26     @reg = open(@tempdir)
  27
  28     assert_equal(42, @reg['store'][:my_obj].bar)
  29   end
  30
  31   def test_default
  32     @reg.set_default(42)
  33     assert_equal(42, @reg['not-here'])
  34     assert_equal(42, @reg.default)
  35   end
  36
  37   def test_flush
  38     # I don't know if there really is a good way to test this:
  39     big_string = 'A' * (1024 * 512)
  40     @reg['foo'] = big_string+'a'
  41
  42     dbfile = @reg.filename
  43     assert_not_nil(dbfile)
  44     if not File.exists? dbfile
  45       # dbm ext. are arbitary
  46       dbfile = Dir.glob(dbfile+'.*').first
  47     end
  48     assert_not_nil(dbfile)
  49
  50     assert(File.exists?(dbfile), 'expected database to exist')
  51
  52     size_before = File.size(dbfile)
  53     @reg['bar'] = big_string
  54     @reg.flush
  55     size_after = File.size(dbfile)
  56
  57     assert(size_before < size_after, 'expected big string to be flushed on disk!')
  58   end
  59
  60   def test_optimize
  61     @reg.optimize
  62   end
  63
  64   def test_close
  65     @reg.close
  66   end
  67
  68   def test_getset # [] and []=
  69     @reg['mykey'] = 'myvalue'
  70     assert_equal('myvalue', @reg['mykey'],'expected set value')
  71     @reg['mykey'] = 42
  72     assert_equal(42, @reg['mykey'], 'expected set value to overwrite')
  73     @reg[23] = 5
  74     assert_equal(5, @reg[23], 'expected integer key to respond')
  75     @reg['myKey'] = 45
  76     assert_equal(42, @reg['mykey'], 'expected keys tobe case-sensitive')
  77     assert_equal(45, @reg['myKey'], 'expected keys tobe case-sensitive')
  78     assert_nil(@reg['not-there'])
  79   end
  80
  81   def test_getset_persists
  82     @reg['mykey'] = 'myvalue'
  83     @reg['myKey'] = 45
  84     @reg[23] = 5
  85     @reg.close
  86     @reg = open(@tempdir)
  87     assert_equal('myvalue', @reg['mykey'], 'expected value to persist')
  88     assert_equal(5, @reg[23], 'expected integer key to persist')
  89
  90     assert_equal(45, @reg['myKey'], 'expected keys tobe case-sensitive')
  91     assert_nil(@reg['not-there'])
  92   end
  93
  94   def test_each
  95     @reg['mykey1'] = 'myvalue1'
  96     @reg['mykey2'] = 'myvalue2'
  97     @reg['mykey3'] = 'myvalue3'
  98     resp = {}
  99     i = 0
 100     @reg.each do |key, value|
 101       resp[key] = value
 102       i += 1
 103     end
 104     assert_equal(3, i, 'expected block to yield 3 times')
 105     assert(resp.has_key? 'mykey1')
 106     assert(resp.has_key? 'mykey2')
 107     assert(resp.has_key? 'mykey3')
 108     assert_equal('myvalue1', resp['mykey1'])
 109     assert_equal('myvalue2', resp['mykey2'])
 110     assert_equal('myvalue3', resp['mykey3'])
 111   end
 112
 113   def test_each_pair
 114     @reg['mykey1'] = 'myvalue1'
 115     @reg['mykey2'] = 'myvalue2'
 116     @reg['mykey3'] = 'myvalue3'
 117     resp = {}
 118     i = 0
 119     @reg.each_pair do |key, value|
 120       resp[key] = value
 121       i += 1
 122     end
 123     assert_equal(3, i, 'expected block to yield 3 times')
 124     assert(resp.has_key? 'mykey1')
 125     assert(resp.has_key? 'mykey2')
 126     assert(resp.has_key? 'mykey3')
 127     assert_equal('myvalue1', resp['mykey1'])
 128     assert_equal('myvalue2', resp['mykey2'])
 129     assert_equal('myvalue3', resp['mykey3'])
 130   end
 131
 132   def test_each_key
 133     @reg['mykey1'] = 'myvalue1'
 134     @reg['mykey2'] = 'myvalue2'
 135     @reg['mykey3'] = 'myvalue3'
 136     resp = []
 137     i = 0
 138     @reg.each_key do |key|
 139       resp << key
 140       i += 1
 141     end
 142     assert_equal(3, i, 'expected block to yield 3 times')
 143     assert(resp.include? 'mykey1')
 144     assert(resp.include? 'mykey2')
 145     assert(resp.include? 'mykey3')
 146   end
 147
 148   def test_each_value
 149     @reg['mykey1'] = 'myvalue1'
 150     @reg['mykey2'] = 'myvalue2'
 151     @reg['mykey3'] = 'myvalue3'
 152     resp = []
 153     i = 0
 154     @reg.each_value do |value|
 155       resp << value
 156       i += 1
 157     end
 158     assert_equal(3, i, 'expected block to yield 3 times')
 159     assert(resp.include? 'myvalue1')
 160     assert(resp.include? 'myvalue2')
 161     assert(resp.include? 'myvalue3')
 162   end
 163
 164   def test_has_key
 165     @reg['mykey1'] = 'myvalue1'
 166     @reg['mykey2'] = 'myvalue2'
 167     @reg[23] = 5
 168     assert(@reg.has_key?('mykey1'))
 169     assert(@reg.has_key?('mykey2'))
 170     assert(@reg.has_key?(23))
 171     assert_equal(false, @reg.has_key?('mykey3'))
 172     assert_equal(false, @reg.has_key?(42))
 173   end
 174
 175   def test_has_value
 176     @reg['mykey1'] = 'myvalue1'
 177     @reg[23] = 5
 178     assert(@reg.has_value?('myvalue1'))
 179     assert(@reg.has_value?(5))
 180     assert_equal(false, @reg.has_value?('myvalue3'))
 181     assert_equal(false, @reg.has_value?(10))
 182   end
 183
 184   def test_index
 185     @reg['mykey1'] = 'myvalue1'
 186     @reg[23] = 5
 187     assert_equal('mykey1', @reg.index('myvalue1'))
 188     assert_equal('23', @reg.index(5))
 189   end
 190
 191   def test_delete
 192     @reg['mykey'] = 'myvalue'
 193     assert_not_nil(@reg['mykey'])
 194     @reg.delete('mykey')
 195     assert_nil(@reg['mykey'])
 196   end
 197
 198   def test_delete_return
 199     @reg['mykey'] = 'myvalue'
 200     assert_equal('myvalue', @reg.delete('mykey'), 'delete should return the deleted value')
 201     assert_nil(@reg.delete('mykey'))
 202   end
 203
 204   def test_to_a
 205     @reg['mykey1'] = 'myvalue1'
 206     @reg['mykey2'] = 'myvalue2'
 207     myhash = {}
 208     myhash['mykey1'] = 'myvalue1'
 209     myhash['mykey2'] = 'myvalue2'
 210     assert_equal(myhash.to_a, @reg.to_a)
 211   end
 212
 213   def test_to_hash
 214     @reg['mykey1'] = 'myvalue1'
 215     @reg['mykey2'] = 'myvalue2'
 216     myhash = {}
 217     myhash['mykey1'] = 'myvalue1'
 218     myhash['mykey2'] = 'myvalue2'
 219     assert_equal(myhash.to_hash, @reg.to_hash)
 220   end
 221
 222   def test_clear
 223     @reg['mykey1'] = 'myvalue1'
 224     @reg['mykey2'] = 'myvalue2'
 225     assert_not_nil(@reg['mykey1'])
 226     @reg.clear
 227     assert_nil(@reg['mykey1'])
 228   end
 229
 230   def test_clear_persists
 231     @reg['mykey1'] = 'myvalue1'
 232     @reg['mykey2'] = 'myvalue2'
 233     assert_not_nil(@reg['mykey1'])
 234     @reg.close
 235     @reg = open(@tempdir)
 236     assert_not_nil(@reg['mykey1'])
 237   end
 238
 239   def test_values
 240     @reg['mykey1'] = 'myvalue1'
 241     @reg['mykey2'] = 'myvalue2'
 242     myhash = {}
 243     myhash['mykey1'] = 'myvalue1'
 244     myhash['mykey2'] = 'myvalue2'
 245     assert_equal(myhash.values, @reg.values)
 246   end
 247
 248   def test_length
 249     @reg['mykey1'] = 'myvalue1'
 250     @reg['mykey2'] = 'myvalue2'
 251     assert_equal(2, @reg.length)
 252   end
 253 end
 254
 255 module RegistryTestModule
 256   def setup
 257     @tempdir = Dir.mktmpdir
 258     @reg = open(@tempdir)
 259   end
 260
 261   def teardown
 262     @reg.close
 263     FileUtils.remove_entry @tempdir
 264   end
 265
 266   def open(path, filename='testcase')
 267     puts 'open type: ' + @format
 268     @registry_class.new(File.join(path, filename))
 269   end
 270 end
 271
 272 class RegistryDBMTest < Test::Unit::TestCase
 273   include RegistryTestModule
 274   include RegistryHashInterfaceTests
 275
 276   def initialize(o)
 277     super o
 278     @format = 'dbm'
 279     Irc::Bot::Registry.new(@format)
 280     @registry_class = Irc::Bot::Registry::DBMAccessor
 281   end
 282 end
 283
 284 class RegistryTCTest < Test::Unit::TestCase
 285   include RegistryTestModule
 286   include RegistryHashInterfaceTests
 287
 288   def initialize(o)
 289     super o
 290     @format = 'tc'
 291     Irc::Bot::Registry.new(@format)
 292     @registry_class = Irc::Bot::Registry::TokyoCabinetAccessor
 293   end
 294 end
 295
 296 class RegistryDaybreakTest < Test::Unit::TestCase
 297   include RegistryTestModule
 298   include RegistryHashInterfaceTests
 299
 300   def initialize(o)
 301     super o
 302     @format = 'daybreak'
 303     Irc::Bot::Registry.new(@format)
 304     @registry_class = Irc::Bot::Registry::DaybreakAccessor
 305   end
 306 end
 307
 308 class RegistrySqliteTest < Test::Unit::TestCase
 309   include RegistryTestModule
 310   include RegistryHashInterfaceTests
 311
 312   def initialize(o)
 313     super o
 314     @format = 'sqlite'
 315     Irc::Bot::Registry.new(@format)
 316     @registry_class = Irc::Bot::Registry::SqliteAccessor
 317   end
 318
 319   def test_duplicate_keys
 320     @reg['foo'] = 1
 321     @reg['foo'] = 2
 322     res = @reg.registry.execute('select key from data')
 323     assert res.length == 1
 324   end
 325 end
 326