156 lines
3.4 KiB
Ruby
156 lines
3.4 KiB
Ruby
require 'test/unit'
|
|
require 'environment'
|
|
require 'flexnbd/constants'
|
|
|
|
class TestHappyPath < Test::Unit::TestCase
|
|
def setup
|
|
@env = Environment.new
|
|
end
|
|
|
|
def bin(str)
|
|
FlexNBD.binary str
|
|
end
|
|
|
|
def teardown
|
|
@env.nbd1.can_die(0)
|
|
@env.nbd2.can_die(0)
|
|
@env.cleanup
|
|
end
|
|
|
|
def test_read1
|
|
@env.writefile1('f' * 64)
|
|
@env.serve1
|
|
|
|
[0, 12, 63].each do |num|
|
|
assert_equal(
|
|
bin(@env.nbd1.read(num * @env.blocksize, @env.blocksize)),
|
|
bin(@env.file1.read(num * @env.blocksize, @env.blocksize))
|
|
)
|
|
end
|
|
|
|
[124, 1200, 10_028, 25_488].each do |num|
|
|
assert_equal(bin(@env.nbd1.read(num, 4)), bin(@env.file1.read(num, 4)))
|
|
end
|
|
end
|
|
|
|
# Check that we're not
|
|
#
|
|
def test_writeread1
|
|
@env.writefile1('0' * 64)
|
|
@env.serve1
|
|
|
|
[0, 12, 63].each do |num|
|
|
data = 'X' * @env.blocksize
|
|
@env.nbd1.write(num * @env.blocksize, data)
|
|
assert_equal(data, @env.file1.read(num * @env.blocksize, data.size))
|
|
assert_equal(data, @env.nbd1.read(num * @env.blocksize, data.size))
|
|
end
|
|
end
|
|
|
|
# Check that we're not overstepping or understepping where our writes end
|
|
# up.
|
|
#
|
|
def test_writeread2
|
|
@env.writefile1('0' * 1024)
|
|
@env.serve1
|
|
|
|
d0 = "\0" * @env.blocksize
|
|
d1 = 'X' * @env.blocksize
|
|
(0..63).each do |num|
|
|
@env.nbd1.write(num * @env.blocksize * 2, d1)
|
|
end
|
|
(0..63).each do |num|
|
|
assert_equal(d0, @env.nbd1.read(((2 * num) + 1) * @env.blocksize, d0.size))
|
|
end
|
|
end
|
|
|
|
def setup_to_mirror
|
|
@env.writefile1('f' * 4)
|
|
@env.serve1
|
|
|
|
@env.writefile2('0' * 4)
|
|
@env.listen2
|
|
end
|
|
|
|
def test_mirror
|
|
@env.nbd1.can_die
|
|
@env.nbd2.can_die(0)
|
|
setup_to_mirror
|
|
|
|
stdout, stderr = @env.mirror12
|
|
|
|
@env.nbd1.join
|
|
@env.nbd2.join
|
|
|
|
assert(File.file?(@env.filename1),
|
|
'The source file was incorrectly deleted')
|
|
assert_equal(@env.file1.read_original(0, @env.blocksize),
|
|
@env.file2.read(0, @env.blocksize))
|
|
end
|
|
|
|
def test_mirror_unlink
|
|
@env.nbd1.can_die(0)
|
|
@env.nbd2.can_die(0)
|
|
setup_to_mirror
|
|
|
|
assert File.file?(@env.filename1)
|
|
|
|
stdout, stderr = @env.mirror12_unlink
|
|
|
|
assert_no_match(/unrecognized/, stderr)
|
|
|
|
Timeout.timeout(10) { @env.nbd1.join }
|
|
|
|
assert !File.file?(@env.filename1)
|
|
end
|
|
|
|
def test_write_to_high_block
|
|
#
|
|
# This test does not work on 32 bit platforms.
|
|
#
|
|
skip('Not relevant on 32-bit platforms') if ['a'].pack('p').size < 8
|
|
|
|
# Create a large file, then try to write to somewhere after the 2G boundary
|
|
@env.truncate1 '4G'
|
|
@env.serve1
|
|
|
|
@env.nbd1.write(2**31 + 2**29, '12345678')
|
|
sleep(1)
|
|
assert_equal '12345678', @env.nbd1.read(2**31 + 2**29, 8)
|
|
end
|
|
|
|
def test_set_acl
|
|
# Just check that we get sane feedback here
|
|
@env.writefile1('f' * 4)
|
|
@env.serve1
|
|
|
|
_, stderr = @env.acl1('127.0.0.1')
|
|
assert_no_match(/^(F|E):/, stderr)
|
|
end
|
|
|
|
def test_write_more_than_one_run
|
|
one_mb = 2**20
|
|
data = "\0" * 256 * one_mb
|
|
|
|
File.open(@env.filename1, 'wb') { |f| f.write('1' * 256 * one_mb) }
|
|
|
|
@env.serve1
|
|
sleep 5
|
|
@env.write1(data)
|
|
@env.nbd1.can_die(0)
|
|
@env.nbd1.kill
|
|
|
|
i = 0
|
|
File.open(@env.filename1, 'rb') do |f|
|
|
while mb = f.read(one_mb)
|
|
unless "\0" * one_mb == mb
|
|
msg = format("Read non-zeros after offset %x:\n", (i * one_mb))
|
|
msg += `hexdump #{@env.filename1} | head -n5`
|
|
raise msg
|
|
end
|
|
i += 1
|
|
end
|
|
end
|
|
end
|
|
end
|