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