def test_gzip(self, tmpdir):
config_mock = mock.Mock()
compressor = PyGZipCompressor(config=config_mock, compression='pygzip')
src = tmpdir.join('sourcefile')
src.write('content')
compressor.compress(src.strpath, '%s/zipfile.zip' % tmpdir.strpath)
assert os.path.exists('%s/zipfile.zip' % tmpdir.strpath)
compression_zip = identify_compression('%s/zipfile.zip' % tmpdir.strpath)
assert compression_zip == "gzip"
compressor.decompress('%s/zipfile.zip' % tmpdir.strpath,
'%s/zipfile.uncompressed' % tmpdir.strpath)
f = open('%s/zipfile.uncompressed' % tmpdir.strpath).read()
assert f == 'content'
def test_gzip(self, tmpdir):
config_mock = mock.Mock()
compressor = PyGZipCompressor(config=config_mock, compression='pygzip')
src = tmpdir.join('sourcefile')
src.write('content')
compressor.compress(src.strpath, '%s/zipfile.zip' % tmpdir.strpath)
assert os.path.exists('%s/zipfile.zip' % tmpdir.strpath)
compression_zip = identify_compression('%s/zipfile.zip' %
tmpdir.strpath)
assert compression_zip == "gzip"
compressor.decompress('%s/zipfile.zip' % tmpdir.strpath,
'%s/zipfile.uncompressed' % tmpdir.strpath)
f = open('%s/zipfile.uncompressed' % tmpdir.strpath).read()
assert f == 'content'
def test_gzip(self, tmpdir):
config_mock = mock.Mock()
compressor = PyGZipCompressor(config=config_mock, compression="pygzip")
src = tmpdir.join("sourcefile")
src.write("content")
compressor.compress(src.strpath, "%s/zipfile.zip" % tmpdir.strpath)
assert os.path.exists("%s/zipfile.zip" % tmpdir.strpath)
compression_zip = identify_compression("%s/zipfile.zip" %
tmpdir.strpath)
assert compression_zip == "gzip"
compressor.decompress(
"%s/zipfile.zip" % tmpdir.strpath,
"%s/zipfile.uncompressed" % tmpdir.strpath,
)
f = open("%s/zipfile.uncompressed" % tmpdir.strpath).read()
assert f == "content"
def test_gzip(self, tmpdir):
config_mock = mock.Mock()
compression_manager = CompressionManager(config_mock, tmpdir.strpath)
compressor = PyGZipCompressor(config=config_mock, compression="pygzip")
src = tmpdir.join("sourcefile")
src.write("content")
compressor.compress(src.strpath, ZIP_FILE % tmpdir.strpath)
assert os.path.exists(ZIP_FILE % tmpdir.strpath)
compression_zip = compression_manager.identify_compression(
ZIP_FILE % tmpdir.strpath)
assert compression_zip == "gzip"
compressor.decompress(
ZIP_FILE % tmpdir.strpath,
ZIP_FILE_UNCOMPRESSED % tmpdir.strpath,
)
f = open(ZIP_FILE_UNCOMPRESSED % tmpdir.strpath).read()
assert f == "content"
def test_archive_wal(self, tmpdir, capsys):
"""
Test WalArchiver.archive_wal behaviour when the WAL file already
exists in the archive
"""
# Setup the test environment
backup_manager = build_backup_manager(
name="TestServer", global_conf={"barman_home": tmpdir.strpath}
)
backup_manager.compression_manager.get_compressor.return_value = None
backup_manager.server.get_backup.return_value = None
basedir = tmpdir.join("main")
incoming_dir = basedir.join("incoming")
archive_dir = basedir.join("wals")
xlog_db = archive_dir.join("xlog.db")
wal_name = "000000010000000000000001"
wal_file = incoming_dir.join(wal_name)
wal_file.ensure()
archive_dir.ensure(dir=True)
xlog_db.ensure()
backup_manager.server.xlogdb.return_value.__enter__.return_value = xlog_db.open(
mode="a"
)
archiver = FileWalArchiver(backup_manager)
backup_manager.server.archivers = [archiver]
# Tests a basic archival process
wal_info = WalFileInfo.from_file(wal_file.strpath)
archiver.archive_wal(None, wal_info)
assert not os.path.exists(wal_file.strpath)
assert os.path.exists(wal_info.fullpath(backup_manager.server))
# Tests the archiver behaviour for duplicate WAL files, as the
# wal file named '000000010000000000000001' was already archived
# in the previous test
wal_file.ensure()
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Tests the archiver behaviour for duplicated WAL files with
# different contents
wal_file.write("test")
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(DuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Tests the archiver behaviour for duplicate WAL files, as the
# wal file named '000000010000000000000001' was already archived
# in the previous test and the input file uses compression
compressor = PyGZipCompressor(backup_manager.config, "pygzip")
compressor.compress(wal_file.strpath, wal_file.strpath)
wal_info = WalFileInfo.from_file(wal_file.strpath)
assert os.path.exists(wal_file.strpath)
backup_manager.compression_manager.get_compressor.return_value = compressor
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Test the archiver behaviour when the incoming file is compressed
# and it has been already archived and compressed.
compressor.compress(
wal_info.fullpath(backup_manager.server),
wal_info.fullpath(backup_manager.server),
)
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Reset the status of the incoming and WALs directory
# removing the files archived during the preceding tests.
os.unlink(wal_info.fullpath(backup_manager.server))
os.unlink(wal_file.strpath)
# Test the archival of a WAL file using compression.
wal_file.write("test")
wal_info = WalFileInfo.from_file(wal_file.strpath)
archiver.archive_wal(compressor, wal_info)
assert os.path.exists(wal_info.fullpath(backup_manager.server))
assert not os.path.exists(wal_file.strpath)
assert "gzip" == identify_compression(wal_info.fullpath(backup_manager.server))
def test_archive_wal(self, tmpdir, capsys):
"""
Test WalArchiver.archive_wal behaviour when the WAL file already
exists in the archive
"""
# Setup the test environment
backup_manager = build_backup_manager(
name='TestServer',
global_conf={
'barman_home': tmpdir.strpath
})
backup_manager.compression_manager.get_compressor.return_value = None
backup_manager.server.get_backup.return_value = None
basedir = tmpdir.join('main')
incoming_dir = basedir.join('incoming')
archive_dir = basedir.join('wals')
xlog_db = archive_dir.join('xlog.db')
wal_name = '000000010000000000000001'
wal_file = incoming_dir.join(wal_name)
wal_file.ensure()
archive_dir.ensure(dir=True)
xlog_db.ensure()
backup_manager.server.xlogdb.return_value.__enter__.return_value = (
xlog_db.open(mode='a'))
archiver = FileWalArchiver(backup_manager)
backup_manager.server.archivers = [archiver]
# Tests a basic archival process
wal_info = WalFileInfo.from_file(wal_file.strpath)
archiver.archive_wal(None, wal_info)
assert not os.path.exists(wal_file.strpath)
assert os.path.exists(wal_info.fullpath(backup_manager.server))
# Tests the archiver behaviour for duplicate WAL files, as the
# wal file named '000000010000000000000001' was already archived
# in the previous test
wal_file.ensure()
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Tests the archiver behaviour for duplicated WAL files with
# different contents
wal_file.write('test')
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(DuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Tests the archiver behaviour for duplicate WAL files, as the
# wal file named '000000010000000000000001' was already archived
# in the previous test and the input file uses compression
compressor = PyGZipCompressor(backup_manager.config, 'pygzip')
compressor.compress(wal_file.strpath, wal_file.strpath)
wal_info = WalFileInfo.from_file(wal_file.strpath)
assert os.path.exists(wal_file.strpath)
backup_manager.compression_manager.get_compressor.return_value = (
compressor)
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Test the archiver behaviour when the incoming file is compressed
# and it has been already archived and compressed.
compressor.compress(wal_info.fullpath(backup_manager.server),
wal_info.fullpath(backup_manager.server))
wal_info = WalFileInfo.from_file(wal_file.strpath)
with pytest.raises(MatchingDuplicateWalFile):
archiver.archive_wal(None, wal_info)
# Reset the status of the incoming and WALs directory
# removing the files archived during the preceding tests.
os.unlink(wal_info.fullpath(backup_manager.server))
os.unlink(wal_file.strpath)
# Test the archival of a WAL file using compression.
wal_file.write('test')
wal_info = WalFileInfo.from_file(wal_file.strpath)
archiver.archive_wal(compressor, wal_info)
assert os.path.exists(wal_info.fullpath(backup_manager.server))
assert not os.path.exists(wal_file.strpath)
assert 'gzip' == identify_compression(
wal_info.fullpath(backup_manager.server)
)
