thin-provisioning-tools/unit-tests/metadata_checker_t.cc

216 lines
4.6 KiB
C++
Raw Normal View History

2013-04-25 20:57:07 +05:30
#include "gmock/gmock.h"
#include "test_utils.h"
#include "persistent-data/block.h"
2013-04-29 17:54:19 +05:30
#include "thin-provisioning/device_checker.h"
2013-04-25 20:57:07 +05:30
#include "thin-provisioning/restore_emitter.h"
#include "thin-provisioning/superblock_checker.h"
2013-04-29 20:07:53 +05:30
#include "thin-provisioning/superblock_validator.h"
2013-04-25 20:57:07 +05:30
#include <unistd.h>
using namespace persistent_data;
using namespace std;
using namespace test;
using namespace testing;
using namespace thin_provisioning;
//----------------------------------------------------------------
namespace {
block_address const BLOCK_SIZE = 4096;
block_address const NR_BLOCKS = 10240;
// FIXME: move to utils
class with_directory {
public:
with_directory(std::string const &path)
: old_path_(pwd()) {
chdir(path);
}
~with_directory() {
chdir(old_path_);
}
private:
std::string pwd() const {
char buffer[PATH_MAX];
char *ptr = getcwd(buffer, sizeof(buffer));
if (!ptr) {
// FIXME: still need a standard syscall failed exception
throw std::runtime_error("getcwd failed");
}
return ptr;
}
void chdir(std::string const &path) {
int r = ::chdir(path.c_str());
if (r < 0)
throw std::runtime_error("chdir failed");
}
std::string old_path_;
std::string new_path_;
};
class with_temp_directory {
public:
with_temp_directory() {
std::string name("./tmp");
rm_rf(name);
mkdir(name);
dir_.reset(new with_directory(name));
}
private:
void rm_rf(std::string const &name) {
std::string cmd("rm -rf ");
cmd += name;
system(cmd);
}
void mkdir(std::string const &name) {
std::string cmd("mkdir ");
cmd += name;
system(cmd);
}
void system(std::string const &cmd) {
int r = ::system(cmd.c_str());
if (r < 0)
throw std::runtime_error("system failed");
}
std::auto_ptr<with_directory> dir_;
};
//--------------------------------
class metadata_builder {
public:
metadata_builder(block_manager<>::ptr bm)
: bm_(bm) {
}
void build() {
metadata::ptr md(new metadata(bm_, metadata::CREATE, 128, 10240));
emitter::ptr restorer = create_restore_emitter(md);
restorer->begin_superblock("test-generated", 0, 0, 128, 10240, boost::optional<uint64_t>());
restorer->end_superblock();
}
// FIXME: add methods to specify volumes with particular
// mapping patterns.
private:
block_manager<>::ptr bm_;
};
2013-04-29 17:54:19 +05:30
//--------------------------------
class MetadataCheckerTests : public Test {
2013-04-25 20:57:07 +05:30
public:
2013-04-29 17:54:19 +05:30
MetadataCheckerTests()
2013-04-25 20:57:07 +05:30
: bm_(create_bm<BLOCK_SIZE>()) {
metadata_builder builder(bm_);
builder.build();
}
2013-04-29 20:07:53 +05:30
superblock read_superblock() {
superblock sb;
block_manager<>::read_ref r = bm_->read_lock(SUPERBLOCK_LOCATION, superblock_validator());
superblock_disk const *sbd = reinterpret_cast<superblock_disk const *>(&r.data());
superblock_traits::unpack(*sbd, sb);
return sb;
}
void zero_block(block_address b) {
::test::zero_block(bm_, b);
}
2013-04-29 17:54:19 +05:30
with_temp_directory dir_;
block_manager<>::ptr bm_;
};
class SuperBlockCheckerTests : public MetadataCheckerTests {
public:
2013-04-25 20:57:07 +05:30
void corrupt_superblock() {
2013-04-29 20:07:53 +05:30
zero_block(SUPERBLOCK_LOCATION);
2013-04-25 20:57:07 +05:30
}
2013-04-29 17:54:19 +05:30
};
2013-04-25 20:57:07 +05:30
}
//----------------------------------------------------------------
TEST_F(SuperBlockCheckerTests, creation_requires_a_block_manager)
{
superblock_checker sc(bm_);
}
TEST_F(SuperBlockCheckerTests, passes_with_good_superblock)
{
superblock_checker sc(bm_);
damage_list_ptr damage = sc.check();
ASSERT_THAT(damage->size(), Eq(0U));
}
TEST_F(SuperBlockCheckerTests, fails_with_bad_checksum)
{
corrupt_superblock();
superblock_checker sc(bm_);
damage_list_ptr damage = sc.check();
ASSERT_THAT(damage->size(), Eq(1u));
metadata_damage::ptr d = *damage->begin();
ASSERT_THAT(dynamic_cast<super_block_corruption *>(d.get()), NotNull());
}
//----------------------------------------------------------------
2013-04-29 17:54:19 +05:30
2013-04-29 20:07:53 +05:30
namespace {
class DeviceCheckerTests : public MetadataCheckerTests {
public:
DeviceCheckerTests() {
}
block_address devices_root() {
superblock sb = read_superblock();
return sb.device_details_root_;
}
device_checker::ptr mk_checker() {
return device_checker::ptr(new device_checker(bm_, devices_root()));
}
};
}
TEST_F(DeviceCheckerTests, create_require_a_block_manager_and_a_root_block)
2013-04-29 17:54:19 +05:30
{
2013-04-29 20:07:53 +05:30
mk_checker();
}
TEST_F(DeviceCheckerTests, passes_with_valid_metadata_and_zero_devices)
{
damage_list_ptr damage = mk_checker()->check();
ASSERT_THAT(damage->size(), Eq(0u));
}
TEST_F(DeviceCheckerTests, fails_with_corrupt_root)
{
zero_block(devices_root());
damage_list_ptr damage = mk_checker()->check();
ASSERT_THAT(damage->size(), Gt(0u));
2013-04-29 17:54:19 +05:30
}
//----------------------------------------------------------------