git.oblomov.eu Git - rbot/blob - test/test_registry.rb

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