test/test_backend.rb

   1 # -*- encoding: binary -*-
   2 require 'test/unit'
   3 require './test/setup'
   4
   5 $TESTING = true
   6
   7 require 'mogilefs/backend'
   8
   9 class MogileFS::Backend
  10
  11   attr_accessor :hosts
  12   attr_reader :timeout, :dead
  13   attr_writer :lasterr, :lasterrstr, :socket
  14
  15 end
  16
  17 class TestBackend < Test::Unit::TestCase
  18
  19   def setup
  20     @backend = MogileFS::Backend.new :hosts => ['localhost:1']
  21   end
  22
  23   def test_initialize
  24     assert_raises ArgumentError do MogileFS::Backend.new end
  25     assert_raises ArgumentError do MogileFS::Backend.new :hosts => [] end
  26     assert_raises ArgumentError do MogileFS::Backend.new :hosts => [''] end
  27
  28     assert_equal ['localhost:1'], @backend.hosts
  29     assert_equal 3, @backend.timeout
  30     assert_equal nil, @backend.lasterr
  31     assert_equal nil, @backend.lasterrstr
  32     assert_equal({}, @backend.dead)
  33
  34     @backend = MogileFS::Backend.new :hosts => ['localhost:6001'], :timeout => 1
  35     assert_equal 1, @backend.timeout
  36   end
  37
  38   def test_do_request
  39     srv = TCPServer.new("127.0.0.1", 0)
  40     port = srv.addr[1]
  41     accepted = Thread.new do
  42       client = srv.accept
  43       client.write("OK 1 you=win\r\n")
  44       client
  45     end
  46     @backend.hosts = [ "127.0.0.1:#{port}" ]
  47     assert_equal({'you' => 'win'},
  48                  @backend.do_request('go!', { 'fight' => 'team fight!' }))
  49     accepted = accepted.value
  50     assert_equal "go! fight=team+fight%21\r\n", accepted.readpartial(4096)
  51   end
  52
  53   def test_automatic_exception
  54     assert ! MogileFS::Backend.const_defined?('PebkacError')
  55     assert @backend.error('pebkac')
  56     assert_equal MogileFS::Error, @backend.error('PebkacError').superclass
  57     assert MogileFS::Backend.const_defined?('PebkacError')
  58
  59     assert ! MogileFS::Backend.const_defined?('PebKacError')
  60     assert @backend.error('peb_kac')
  61     assert_equal MogileFS::Error, @backend.error('PebKacError').superclass
  62     assert MogileFS::Backend.const_defined?('PebKacError')
  63   end
  64
  65   def test_size_verify_error_defined
  66     # "ErrorError" just looks dumb, but we used to get it
  67     # since mogilefs would send us "size_verify_error" and we'd
  68     # blindly append "Error" to the exception
  69     assert ! MogileFS::Backend.const_defined?('SizeVerifyErrorError')
  70     assert MogileFS::Backend.const_defined?('SizeVerifyError')
  71   end
  72
  73   def test_make_request
  74     assert_equal "go! fight=team+fight%21\r\n",
  75                  @backend.make_request('go!', { 'fight' => 'team fight!' })
  76   end
  77
  78   def test_parse_response
  79     assert_equal({'foo' => 'bar', 'baz' => 'hoge'},
  80                  @backend.parse_response('OK 1 foo=bar&baz=hoge'))
  81
  82     err = nil
  83     begin
  84       @backend.parse_response('ERR you totally suck')
  85     rescue MogileFS::Error => err
  86       assert_equal 'MogileFS::Backend::YouError', err.class.to_s
  87       assert_equal 'totally suck', err.message
  88     end
  89     assert_equal 'MogileFS::Backend::YouError', err.class.to_s
  90
  91     assert_equal 'you', @backend.lasterr
  92     assert_equal 'totally suck', @backend.lasterrstr
  93
  94     assert_raises MogileFS::InvalidResponseError do
  95       @backend.parse_response 'garbage'
  96     end
  97   end
  98
  99   def test_parse_response_newline
 100     begin
 101       @backend.parse_response("ERR you totally suck\r\n")
 102     rescue MogileFS::Error => err
 103       assert_equal 'MogileFS::Backend::YouError', err.class.to_s
 104       assert_equal 'totally suck', err.message
 105     end
 106
 107     assert_equal 'you', @backend.lasterr
 108     assert_equal 'totally suck', @backend.lasterrstr
 109   end
 110
 111   def test_readable_eh_not_readable
 112     srv = TCPServer.new("127.0.0.1", 0)
 113     port = srv.addr[1]
 114     @backend = MogileFS::Backend.new(:hosts => [ "127.0.0.1:#{port}" ],
 115                                      :timeout => 0.5)
 116     begin
 117       @backend.do_request 'foo', {}
 118     rescue MogileFS::UnreadableSocketError => e
 119       assert_equal "127.0.0.1:#{port} never became readable", e.message
 120     rescue Exception => err
 121       flunk "MogileFS::UnreadableSocketError not raised #{err} #{err.backtrace}"
 122     else
 123       flunk "MogileFS::UnreadableSocketError not raised"
 124     end
 125   end
 126
 127   def test_socket_dead
 128     assert_equal({}, @backend.dead)
 129     assert_raises(MogileFS::UnreachableBackendError) do
 130       @backend.do_request('test', {})
 131     end
 132     assert_equal(['localhost:1'], @backend.dead.keys)
 133   end
 134
 135   def test_socket_robust_on_dead_server
 136     10.times do
 137       t1 = TCPServer.new("127.0.0.1", 0)
 138       t2 = TCPServer.new("127.0.0.1", 0)
 139       hosts = ["127.0.0.1:#{t1.addr[1]}", "127.0.0.1:#{t2.addr[1]}"]
 140       @backend = MogileFS::Backend.new(:hosts => hosts.dup)
 141       assert_equal({}, @backend.dead)
 142       t1.close
 143       thr = Thread.new do
 144         client = t2.accept
 145         client.write("OK 1 foo=bar\n")
 146         client
 147       end
 148       rv = nil
 149       assert_nothing_raised do
 150         rv = @backend.do_request('test', { "all" => "ALL" })
 151       end
 152       accepted = thr.value
 153       assert_equal "test all=ALL\r\n", accepted.readpartial(666)
 154       assert_equal({"foo"=>"bar"}, rv)
 155     end
 156   end
 157
 158   def test_shutdown
 159     srv = TCPServer.new('127.0.0.1', 0)
 160     port = srv.addr[1]
 161     @backend = MogileFS::Backend.new :hosts => [ "127.0.0.1:#{port}" ]
 162     assert @backend.socket
 163     assert ! @backend.socket.closed?
 164     client = srv.accept
 165     client.write '1'
 166     resp = @backend.socket.read(1)
 167     @backend.shutdown
 168     assert_equal nil, @backend.instance_variable_get(:@socket)
 169     assert_equal 1, resp.to_i
 170   end
 171
 172   def test_url_decode
 173     assert_equal({"\272z" => "\360opy", "f\000" => "\272r"},
 174                  @backend.url_decode("%baz=%f0opy&f%00=%bar"))
 175     assert_equal({}, @backend.url_decode(''))
 176   end
 177
 178   def test_url_encode
 179     params = [["f\000", "\272r"], ["\272z", "\360opy"]]
 180     assert_equal "f%00=%bar&%baz=%f0opy", @backend.url_encode(params)
 181   end
 182
 183   def test_url_escape # \n for unit_diff
 184     actual = (0..255).map { |c| @backend.url_escape c.chr }.join "\n"
 185
 186     expected = []
 187     expected.push(*(0..0x1f).map { |c| "%%%0.2x" % c })
 188     expected << '+'
 189     expected.push(*(0x21..0x2b).map { |c| "%%%0.2x" % c })
 190     expected.push(*%w[, - . /])
 191     expected.push(*('0'..'9'))
 192     expected.push(*%w[: %3b %3c %3d %3e %3f %40])
 193     expected.push(*('A'..'Z'))
 194     expected.push(*%w[%5b \\ %5d %5e _ %60])
 195     expected.push(*('a'..'z'))
 196     expected.push(*(0x7b..0xff).map { |c| "%%%0.2x" % c })
 197
 198     expected = expected.join "\n"
 199
 200     assert_equal expected, actual
 201   end
 202
 203   def test_url_unescape
 204     input = []
 205     input.push(*(0..0x1f).map { |c| "%%%0.2x" % c })
 206     input << '+'
 207     input.push(*(0x21..0x2b).map { |c| "%%%0.2x" % c })
 208     input.push(*%w[, - . /])
 209     input.push(*('0'..'9'))
 210     input.push(*%w[: %3b %3c %3d %3e %3f %40])
 211     input.push(*('A'..'Z'))
 212     input.push(*%w[%5b \\ %5d %5e _ %60])
 213     input.push(*('a'..'z'))
 214     input.push(*(0x7b..0xff).map { |c| "%%%0.2x" % c })
 215
 216     actual = input.map { |c| @backend.url_unescape c }.join "\n"
 217
 218     expected = (0..255).map { |c| c.chr }.join "\n"
 219     expected.sub! '+', ' '
 220
 221     assert_equal expected, actual
 222   end
 223
 224 end
 225