mirror
/
borg
mirror of https://github.com/borgbackup/borg.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #1530 from ThomasWaldmann/simplify-repo-tests 

Simplify repo/hashindex tests
This commit is contained in:
TW 2016-08-23 22:33:15 +02:00 committed by GitHub
parent d938cf44d7 93517ca30e
commit b403a111fe
2 changed files with 58 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
borg/testsuite/hashindex.py
View File

@ -23,19 +23,19 @@ class HashIndexTestCase(BaseTestCase):
self.assert_equal(len(idx), 0)
# Test set
for x in range(100):
idx[bytes('%-32d' % x, 'ascii')] = make_value(x)
idx[H(x)] = make_value(x)
self.assert_equal(len(idx), 100)
for x in range(100):
self.assert_equal(idx[bytes('%-32d' % x, 'ascii')], make_value(x))
self.assert_equal(idx[H(x)], make_value(x))
# Test update
for x in range(100):
idx[bytes('%-32d' % x, 'ascii')] = make_value(x * 2)
idx[H(x)] = make_value(x * 2)
self.assert_equal(len(idx), 100)
for x in range(100):
self.assert_equal(idx[bytes('%-32d' % x, 'ascii')], make_value(x * 2))
self.assert_equal(idx[H(x)], make_value(x * 2))
# Test delete
for x in range(50):
del idx[bytes('%-32d' % x, 'ascii')]
del idx[H(x)]
self.assert_equal(len(idx), 50)
idx_name = tempfile.NamedTemporaryFile()
idx.write(idx_name.name)
@ -47,7 +47,7 @@ class HashIndexTestCase(BaseTestCase):
idx = cls.read(idx_name.name)
self.assert_equal(len(idx), 50)
for x in range(50, 100):
self.assert_equal(idx[bytes('%-32d' % x, 'ascii')], make_value(x * 2))
self.assert_equal(idx[H(x)], make_value(x * 2))
idx.clear()
self.assert_equal(len(idx), 0)
idx.write(idx_name.name)
@ -56,11 +56,11 @@ class HashIndexTestCase(BaseTestCase):
def test_nsindex(self):
self._generic_test(NSIndex, lambda x: (x, x),
'80fba5b40f8cf12f1486f1ba33c9d852fb2b41a5b5961d3b9d1228cf2aa9c4c9')
'b96ec1ddabb4278cc92261ee171f7efc979dc19397cc5e89b778f05fa25bf93f')
def test_chunkindex(self):
self._generic_test(ChunkIndex, lambda x: (x, x, x),
'1d71865e72e3c3af18d3c7216b6fa7b014695eaa3ed7f14cf9cd02fba75d1c95')
'9d437a1e145beccc790c69e66ba94fc17bd982d83a401c9c6e524609405529d8')
def test_resize(self):
n = 2000 # Must be >= MIN_BUCKETS
@ -70,11 +70,11 @@ class HashIndexTestCase(BaseTestCase):
initial_size = os.path.getsize(idx_name.name)
self.assert_equal(len(idx), 0)
for x in range(n):
idx[bytes('%-32d' % x, 'ascii')] = x, x
idx[H(x)] = x, x
idx.write(idx_name.name)
self.assert_true(initial_size < os.path.getsize(idx_name.name))
for x in range(n):
del idx[bytes('%-32d' % x, 'ascii')]
del idx[H(x)]
self.assert_equal(len(idx), 0)
idx.write(idx_name.name)
self.assert_equal(initial_size, os.path.getsize(idx_name.name))
@ -82,7 +82,7 @@ class HashIndexTestCase(BaseTestCase):
def test_iteritems(self):
idx = NSIndex()
for x in range(100):
idx[bytes('%-0.32d' % x, 'ascii')] = x, x
idx[H(x)] = x, x
all = list(idx.iteritems())
self.assert_equal(len(all), 100)
second_half = list(idx.iteritems(marker=all[49][0]))

94
borg/testsuite/repository.py
View File

@ -44,8 +44,8 @@ class RepositoryTestCase(RepositoryTestCaseBase):
def test1(self):
for x in range(100):
self.repository.put(('%-32d' % x).encode('ascii'), b'SOMEDATA')
key50 = ('%-32d' % 50).encode('ascii')
self.repository.put(H(x), b'SOMEDATA')
key50 = H(50)
self.assert_equal(self.repository.get(key50), b'SOMEDATA')
self.repository.delete(key50)
self.assert_raises(Repository.ObjectNotFound, lambda: self.repository.get(key50))
@ -56,69 +56,69 @@ class RepositoryTestCase(RepositoryTestCaseBase):
for x in range(100):
if x == 50:
continue
self.assert_equal(repository2.get(('%-32d' % x).encode('ascii')), b'SOMEDATA')
self.assert_equal(repository2.get(H(x)), b'SOMEDATA')
def test2(self):
"""Test multiple sequential transactions
"""
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(b'00000000000000000000000000000001', b'foo')
self.repository.put(H(0), b'foo')
self.repository.put(H(1), b'foo')
self.repository.commit()
self.repository.delete(b'00000000000000000000000000000000')
self.repository.put(b'00000000000000000000000000000001', b'bar')
self.repository.delete(H(0))
self.repository.put(H(1), b'bar')
self.repository.commit()
self.assert_equal(self.repository.get(b'00000000000000000000000000000001'), b'bar')
self.assert_equal(self.repository.get(H(1)), b'bar')
def test_consistency(self):
"""Test cache consistency
"""
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo')
self.repository.put(b'00000000000000000000000000000000', b'foo2')
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo2')
self.repository.put(b'00000000000000000000000000000000', b'bar')
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'bar')
self.repository.delete(b'00000000000000000000000000000000')
self.assert_raises(Repository.ObjectNotFound, lambda: self.repository.get(b'00000000000000000000000000000000'))
self.repository.put(H(0), b'foo')
self.assert_equal(self.repository.get(H(0)), b'foo')
self.repository.put(H(0), b'foo2')
self.assert_equal(self.repository.get(H(0)), b'foo2')
self.repository.put(H(0), b'bar')
self.assert_equal(self.repository.get(H(0)), b'bar')
self.repository.delete(H(0))
self.assert_raises(Repository.ObjectNotFound, lambda: self.repository.get(H(0)))
def test_consistency2(self):
"""Test cache consistency2
"""
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo')
self.repository.put(H(0), b'foo')
self.assert_equal(self.repository.get(H(0)), b'foo')
self.repository.commit()
self.repository.put(b'00000000000000000000000000000000', b'foo2')
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo2')
self.repository.put(H(0), b'foo2')
self.assert_equal(self.repository.get(H(0)), b'foo2')
self.repository.rollback()
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo')
self.assert_equal(self.repository.get(H(0)), b'foo')
def test_overwrite_in_same_transaction(self):
"""Test cache consistency2
"""
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(b'00000000000000000000000000000000', b'foo2')
self.repository.put(H(0), b'foo')
self.repository.put(H(0), b'foo2')
self.repository.commit()
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), b'foo2')
self.assert_equal(self.repository.get(H(0)), b'foo2')
def test_single_kind_transactions(self):
# put
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(H(0), b'foo')
self.repository.commit()
self.repository.close()
# replace
self.repository = self.open()
with self.repository:
self.repository.put(b'00000000000000000000000000000000', b'bar')
self.repository.put(H(0), b'bar')
self.repository.commit()
# delete
self.repository = self.open()
with self.repository:
self.repository.delete(b'00000000000000000000000000000000')
self.repository.delete(H(0))
self.repository.commit()
def test_list(self):
for x in range(100):
self.repository.put(('%-32d' % x).encode('ascii'), b'SOMEDATA')
self.repository.put(H(x), b'SOMEDATA')
all = self.repository.list()
self.assert_equal(len(all), 100)
first_half = self.repository.list(limit=50)
@ -131,22 +131,22 @@ class RepositoryTestCase(RepositoryTestCaseBase):
def test_max_data_size(self):
max_data = b'x' * MAX_DATA_SIZE
self.repository.put(b'00000000000000000000000000000000', max_data)
self.assert_equal(self.repository.get(b'00000000000000000000000000000000'), max_data)
self.repository.put(H(0), max_data)
self.assert_equal(self.repository.get(H(0)), max_data)
self.assert_raises(IntegrityError,
lambda: self.repository.put(b'00000000000000000000000000000001', max_data + b'x'))
lambda: self.repository.put(H(1), max_data + b'x'))
class RepositoryCommitTestCase(RepositoryTestCaseBase):
def add_keys(self):
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(b'00000000000000000000000000000001', b'bar')
self.repository.put(b'00000000000000000000000000000003', b'bar')
self.repository.put(H(0), b'foo')
self.repository.put(H(1), b'bar')
self.repository.put(H(3), b'bar')
self.repository.commit()
self.repository.put(b'00000000000000000000000000000001', b'bar2')
self.repository.put(b'00000000000000000000000000000002', b'boo')
self.repository.delete(b'00000000000000000000000000000003')
self.repository.put(H(1), b'bar2')
self.repository.put(H(2), b'boo')
self.repository.delete(H(3))
def test_replay_of_missing_index(self):
self.add_keys()
@ -222,7 +222,7 @@ class RepositoryCommitTestCase(RepositoryTestCaseBase):
self.assert_equal(len(self.repository), 3)
def test_ignores_commit_tag_in_data(self):
self.repository.put(b'0' * 32, LoggedIO.COMMIT)
self.repository.put(H(0), LoggedIO.COMMIT)
self.reopen()
with self.repository:
io = self.repository.io
@ -264,19 +264,19 @@ class RepositoryAppendOnlyTestCase(RepositoryTestCaseBase):
def test_append_only(self):
def segments_in_repository():
return len(list(self.repository.io.segment_iterator()))
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(H(0), b'foo')
self.repository.commit()
self.repository.append_only = False
assert segments_in_repository() == 1
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(H(0), b'foo')
self.repository.commit()
# normal: compact squashes the data together, only one segment
assert segments_in_repository() == 1
self.repository.append_only = True
assert segments_in_repository() == 1
self.repository.put(b'00000000000000000000000000000000', b'foo')
self.repository.put(H(0), b'foo')
self.repository.commit()
# append only: does not compact, only new segments written
assert segments_in_repository() == 2
@ -294,12 +294,12 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
def get_objects(self, *ids):
for id_ in ids:
self.repository.get(('%032d' % id_).encode('ascii'))
self.repository.get(H(id_))
def add_objects(self, segments):
for ids in segments:
for id_ in ids:
self.repository.put(('%032d' % id_).encode('ascii'), b'data')
self.repository.put(H(id_), b'data')
self.repository.commit()
def get_head(self):
@ -310,7 +310,7 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
def corrupt_object(self, id_):
idx = self.open_index()
segment, offset = idx[('%032d' % id_).encode('ascii')]
segment, offset = idx[H(id_)]
with open(os.path.join(self.tmppath, 'repository', 'data', '0', str(segment)), 'r+b') as fd:
fd.seek(offset)
fd.write(b'BOOM')
@ -401,8 +401,8 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
self.assert_equal(set([1, 2, 3, 4, 5, 6]), self.list_objects())
def test_crash_before_compact(self):
self.repository.put(bytes(32), b'data')
self.repository.put(bytes(32), b'data2')
self.repository.put(H(0), b'data')
self.repository.put(H(0), b'data2')
# Simulate a crash before compact
with patch.object(Repository, 'compact_segments') as compact:
self.repository.commit()
@ -410,7 +410,7 @@ class RepositoryCheckTestCase(RepositoryTestCaseBase):
self.reopen()
with self.repository:
self.check(repair=True)
self.assert_equal(self.repository.get(bytes(32)), b'data2')
self.assert_equal(self.repository.get(H(0)), b'data2')
class RemoteRepositoryTestCase(RepositoryTestCase):