[pve-container.git] / src / test / snapshot-test.pm

package PVE::LXC;

use strict;
use warnings;

use lib qw(..);

use PVE::Storage;
use PVE::Storage::Plugin;
use PVE::LXC;
use PVE::LXC::Config;
use PVE::Tools;

use Test::MockModule;
use Test::More;

my $nodename;
my $snapshot_possible;
my $vol_snapshot_possible = {};
my $vol_snapshot_delete_possible = {};
my $vol_snapshot_rollback_possible = {};
my $vol_snapshot_rollback_enabled = {};
my $vol_snapshot = {};
my $vol_snapshot_delete = {};
my $vol_snapshot_rollback = {};
my $running;
my $freeze_possible;
my $kill_possible;

# Mocked methods

sub mocked_volume_snapshot {
    my ($storecfg, $volid, $snapname) = @_;
    die "Storage config not mocked! aborting\n"
	if defined($storecfg);
    die "volid undefined\n"
	if !defined($volid);
    die "snapname undefined\n"
	if !defined($snapname);
    if ($vol_snapshot_possible->{$volid}) {
	if (defined($vol_snapshot->{$volid})) {
	    $vol_snapshot->{$volid} .= ",$snapname";
	} else {
	    $vol_snapshot->{$volid} = $snapname;
	}
	return 1;
    } else {
	die "volume snapshot disabled\n";
    }
}

sub mocked_volume_snapshot_delete {
    my ($storecfg, $volid, $snapname) = @_;
    die "Storage config not mocked! aborting\n"
	if defined($storecfg);
    die "volid undefined\n"
	if !defined($volid);
    die "snapname undefined\n"
	if !defined($snapname);
    if ($vol_snapshot_delete_possible->{$volid}) {
	if (defined($vol_snapshot_delete->{$volid})) {
	    $vol_snapshot_delete->{$volid} .= ",$snapname";
	} else {
	    $vol_snapshot_delete->{$volid} = $snapname;
	}
	return 1;
    } else {
	die "volume snapshot delete disabled\n";
    }
}

sub mocked_volume_snapshot_rollback {
    my ($storecfg, $volid, $snapname) = @_;
    die "Storage config not mocked! aborting\n"
	if defined($storecfg);
    die "volid undefined\n"
	if !defined($volid);
    die "snapname undefined\n"
	if !defined($snapname);
    if ($vol_snapshot_rollback_enabled->{$volid}) {
	if (defined($vol_snapshot_rollback->{$volid})) {
	    $vol_snapshot_rollback->{$volid} .= ",$snapname";
	} else {
	    $vol_snapshot_rollback->{$volid} = $snapname;
	}
	return 1;
    } else {
	die "volume snapshot rollback disabled\n";
    }
}

sub mocked_volume_rollback_is_possible {
    my ($storecfg, $volid, $snapname) = @_;
    die "Storage config not mocked! aborting\n"
	if defined($storecfg);
    die "volid undefined\n"
	if !defined($volid);
    die "snapname undefined\n"
	if !defined($snapname);
    return $vol_snapshot_rollback_possible->{$volid}
	if ($vol_snapshot_rollback_possible->{$volid});
    die "volume_rollback_is_possible failed\n";
}

sub mocked_run_command {
    my ($cmd, %param) = @_;
    my $cmdstring;
    if (my $ref = ref($cmd)) {
	$cmdstring = PVE::Tools::cmd2string($cmd);
	if ($cmdstring =~ m/.*\/lxc-(un)?freeze.*/) {
	    return 1 if $freeze_possible;
	    die "lxc-[un]freeze disabled\n";
	}
	if ($cmdstring =~ m/.*\/lxc-stop.*--kill.*/) {
	    if ($kill_possible) {
		$running = 0;
		return 1;
	    } else {
		return 0;
	    }
	}
    }
    die "unexpected run_command call: '$cmdstring', aborting\n";
}

# Testing methods

sub test_file {
    my ($exp_fn, $real_fn) = @_;
    my $ret;
    eval {
	$ret = system("diff -u '$exp_fn' '$real_fn'");
    };
    die if $@;
    return !$ret;
}

sub testcase_prepare {
    my ($vmid, $snapname, $save_vmstate, $comment, $exp_err) = @_;
    subtest "Preparing snapshot '$snapname' for vm '$vmid'" => sub {
	plan tests => 2;
	$@ = undef;
	eval {
	    PVE::LXC::snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
	};
	is($@, $exp_err, "\$@ correct");
	ok(test_file("snapshot-expected/prepare/lxc/$vmid.conf", "snapshot-working/prepare/lxc/$vmid.conf"), "config file correct");
    };
}

sub testcase_commit {
    my ($vmid, $snapname, $exp_err) = @_;
    subtest "Committing snapshot '$snapname' for vm '$vmid'" => sub {
	plan tests => 2;
	$@ = undef;
	eval {
	    PVE::LXC::snapshot_commit($vmid, $snapname);
	};
	is($@, $exp_err, "\$@ correct");
	ok(test_file("snapshot-expected/commit/lxc/$vmid.conf", "snapshot-working/commit/lxc/$vmid.conf"), "config file correct");
    }
}

sub testcase_create {
    my ($vmid, $snapname, $save_vmstate, $comment, $exp_err, $exp_vol_snap, $exp_vol_snap_delete) = @_;
    subtest "Creating snapshot '$snapname' for vm '$vmid'" => sub {
	plan tests => 4;
	$vol_snapshot = {};
	$vol_snapshot_delete = {};
	$exp_vol_snap = {} if !defined($exp_vol_snap);
	$exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
	$@ = undef;
	eval {
	    PVE::LXC::snapshot_create($vmid, $snapname, $save_vmstate, $comment);
	};
	is($@, $exp_err, "\$@ correct");
	is_deeply($vol_snapshot, $exp_vol_snap, "created correct volume snapshots");
	is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
	ok(test_file("snapshot-expected/create/lxc/$vmid.conf", "snapshot-working/create/lxc/$vmid.conf"), "config file correct");
    };
}

sub testcase_delete {
    my ($vmid, $snapname, $force, $exp_err, $exp_vol_snap_delete) = @_;
    subtest "Deleting snapshot '$snapname' of vm '$vmid'" => sub {
	plan tests => 3;
	$vol_snapshot_delete = {};
	$exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
	$@ = undef;
	eval {
	    PVE::LXC::snapshot_delete($vmid, $snapname, $force);
	};
	is($@, $exp_err, "\$@ correct");
	is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
	ok(test_file("snapshot-expected/delete/lxc/$vmid.conf", "snapshot-working/delete/lxc/$vmid.conf"), "config file correct");
    };
}

sub testcase_rollback {
    my ($vmid, $snapname, $exp_err, $exp_vol_snap_rollback) = @_;
    subtest "Rolling back to snapshot '$snapname' of vm '$vmid'" => sub {
	plan tests => 3;
	$vol_snapshot_rollback = {};
	$running = 1;
	$exp_vol_snap_rollback = {} if !defined($exp_vol_snap_rollback);
	$@ = undef;
	eval {
	    PVE::LXC::snapshot_rollback($vmid, $snapname);
	};
	is($@, $exp_err, "\$@ correct");
	is_deeply($vol_snapshot_rollback, $exp_vol_snap_rollback, "rolled back to correct volume snapshots");
	ok(test_file("snapshot-expected/rollback/lxc/$vmid.conf", "snapshot-working/rollback/lxc/$vmid.conf"), "config file correct");
    };
}

# BEGIN mocked PVE::LXC::Config methods
sub mocked_config_file_lock {
    return "snapshot-working/pve-test.lock";
}

sub mocked_cfs_config_path {
    my ($class, $vmid, $node) = @_;

    $node = $nodename if !$node;
    return "snapshot-working/$node/lxc/$vmid.conf";
}

sub mocked_load_config {
    my ($class, $vmid, $node) = @_;

    my $filename = PVE::LXC::Config->cfs_config_path($vmid, $node);

    my $raw = PVE::Tools::file_get_contents($filename);

    my $conf = PVE::LXC::parse_pct_config($filename, $raw);
    return $conf;
}

sub mocked_write_config {
    my ($class, $vmid, $conf) = @_;

    my $filename = PVE::LXC::Config->cfs_config_path($vmid);

    if ($conf->{snapshots}) {
	foreach my $snapname (keys %{$conf->{snapshots}}) {
	    $conf->{snapshots}->{$snapname}->{snaptime} = "1234567890"
		if $conf->{snapshots}->{$snapname}->{snaptime};
	}
    }

    my $raw = PVE::LXC::write_pct_config($filename, $conf);

    PVE::Tools::file_set_contents($filename, $raw);
}

sub has_feature {
    my ($feature, $conf, $storecfg, $snapname) = @_;
    return $snapshot_possible;
}

sub check_running {
    return $running;
}
# END mocked PVE::LXC methods

sub sync_container_namespace {
    return;
}

# END redefine PVE::LXC methods

PVE::Tools::run_command("rm -rf snapshot-working");
PVE::Tools::run_command("cp -a snapshot-input snapshot-working");

my $lxc_config_module = new Test::MockModule('PVE::LXC::Config');
$lxc_config_module->mock('config_file_lock', sub { return "snapshot-working/pve-test.lock"; });
$lxc_config_module->mock('cfs_config_path', \&mocked_cfs_config_path);
$lxc_config_module->mock('load_config', \&mocked_load_config);
$lxc_config_module->mock('write_config', \&mocked_write_config);

$running = 1;
$freeze_possible = 1;

printf("\n");
printf("Running prepare tests\n");
printf("\n");
$nodename = "prepare";

printf("\n");
printf("Setting has_feature to return true\n");
printf("\n");
$snapshot_possible = 1;

printf("Successful snapshot_prepare with no existing snapshots\n");
testcase_prepare("101", "test", 0, "test comment", '');

printf("Successful snapshot_prepare with one existing snapshot\n");
testcase_prepare("102", "test2", 0, "test comment", "");

printf("Expected error for snapshot_prepare on locked container\n");
testcase_prepare("200", "test", 0, "test comment", "CT is locked (snapshot)\n");

printf("Expected error for snapshot_prepare with duplicate snapshot name\n");
testcase_prepare("201", "test", 0, "test comment", "snapshot name 'test' already used\n");

printf("Expected error for snapshot_prepare with save_vmstate\n");
testcase_prepare("202", "test", 1, "test comment", "implement me - snapshot_save_vmstate\n");

printf("\n");
printf("Setting has_feature to return false\n");
printf("\n");
$snapshot_possible = 0;

printf("Expected error for snapshot_prepare if snapshots not possible\n");
testcase_prepare("300", "test", 0, "test comment", "snapshot feature is not available\n");

printf("\n");
printf("Running commit tests\n");
printf("\n");
$nodename = "commit";

printf("\n");
printf("Setting has_feature to return true\n");
printf("\n");
$snapshot_possible = 1;

printf("Successful snapshot_commit with one prepared snapshot\n");
testcase_commit("101", "test", "");

printf("Successful snapshot_commit with one committed and one prepared snapshot\n");
testcase_commit("102", "test2", "");

printf("Expected error for snapshot_commit with no snapshot lock\n");
testcase_commit("201", "test", "missing snapshot lock\n");

printf("Expected error for snapshot_commit with invalid snapshot name\n");
testcase_commit("202", "test", "snapshot 'test' does not exist\n");

printf("Expected error for snapshot_commit with invalid snapshot state\n");
testcase_commit("203", "test", "wrong snapshot state\n");

$vol_snapshot_possible->{"local:snapshotable-disk-1"} = 1;
$vol_snapshot_possible->{"local:snapshotable-disk-2"} = 1;
$vol_snapshot_possible->{"local:snapshotable-disk-3"} = 1;
$vol_snapshot_delete_possible->{"local:snapshotable-disk-1"} = 1;
$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-1"} = 1;
$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-2"} = 1;
$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-3"} = 1;
$vol_snapshot_rollback_possible->{"local:snapshotable-disk-1"} = 1;
$vol_snapshot_rollback_possible->{"local:snapshotable-disk-2"} = 1;
$vol_snapshot_rollback_possible->{"local:snapshotable-disk-3"} = 1;

# possible, but fails
$vol_snapshot_rollback_possible->{"local:snapshotable-disk-4"} = 1;

printf("\n");
printf("Setting up Mocking for PVE::Storage\n");
my $storage_module = new Test::MockModule('PVE::Storage');
$storage_module->mock('config', sub { return undef; });
$storage_module->mock('volume_snapshot', \&mocked_volume_snapshot);
$storage_module->mock('volume_snapshot_delete', \&mocked_volume_snapshot_delete);
$storage_module->mock('volume_snapshot_rollback', \&mocked_volume_snapshot_rollback);
$storage_module->mock('volume_rollback_is_possible', \&mocked_volume_rollback_is_possible);
printf("\tconfig(), volume_snapshot(), volume_snapshot_delete(), volume_snapshot_rollback() and volume_rollback_is_possible() mocked\n");

printf("\n");
printf("Setting up Mocking for PVE::Tools\n");
my $tools_module = new Test::MockModule('PVE::Tools');
$tools_module->mock('run_command' => \&mocked_run_command);
printf("\trun_command() mocked\n");

$nodename = "create";
printf("\n");
printf("Running create tests\n");
printf("\n");

printf("Successful snapshot_create with no existing snapshots\n");
testcase_create("101", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test" });

printf("Successful snapshot_create with one existing snapshots\n");
testcase_create("102", "test2", 0, "test comment", "", { "local:snapshotable-disk-1" => "test2" });

printf("Successful snapshot_create with multiple mps\n");
testcase_create("103", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });

printf("Expected error for snapshot_create when volume snapshot is not possible\n");
testcase_create("201", "test", 0, "test comment", "volume snapshot disabled\n\n");

printf("Expected error for snapshot_create with broken lxc-freeze\n");
$freeze_possible = 0;
testcase_create("202", "test", 0, "test comment", "lxc-[un]freeze disabled\n\n");
$freeze_possible = 1;

printf("Expected error for snapshot_create when mp volume snapshot is not possible\n");
testcase_create("203", "test", 0, "test comment", "volume snapshot disabled\n\n", { "local:snapshotable-disk-1" => "test" }, { "local:snapshotable-disk-1" => "test" });

$nodename = "delete";
printf("\n");
printf("Running delete tests\n");
printf("\n");

printf("Successful snapshot_delete of only existing snapshot\n");
testcase_delete("101", "test", 0, "", { "local:snapshotable-disk-1" => "test" });

printf("Successful snapshot_delete of leaf snapshot\n");
testcase_delete("102", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });

printf("Successful snapshot_delete of root snapshot\n");
testcase_delete("103", "test", 0, "", { "local:snapshotable-disk-1" => "test" });

printf("Successful snapshot_delete of intermediate snapshot\n");
testcase_delete("104", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });

printf("Successful snapshot_delete with broken volume_snapshot_delete and force=1\n");
testcase_delete("105", "test", 1, "");

printf("Successful snapshot_delete with mp broken volume_snapshot_delete and force=1\n");
testcase_delete("106", "test", 1, "", { "local:snapshotable-disk-1" => "test" });

printf("Expected error when snapshot_delete fails with broken volume_snapshot_delete and force=0\n");
testcase_delete("201", "test", 0, "volume snapshot delete disabled\n");

printf("Expected error when snapshot_delete fails with broken mp volume_snapshot_delete and force=0\n");
testcase_delete("203", "test", 0, "volume snapshot delete disabled\n", { "local:snapshotable-disk-1" => "test" });

printf("Expected error for snapshot_delete with locked config\n");
testcase_delete("202", "test", 0, "CT is locked (backup)\n");

$nodename = "rollback";
printf("\n");
printf("Running rollback tests\n");
printf("\n");

$kill_possible = 1;

printf("Successful snapshot_rollback to only existing snapshot\n");
testcase_rollback("101", "test", "", { "local:snapshotable-disk-1" => "test" });

printf("Successful snapshot_rollback to leaf snapshot\n");
testcase_rollback("102", "test2", "", { "local:snapshotable-disk-1" => "test2" });

printf("Successful snapshot_rollback to root snapshot\n");
testcase_rollback("103", "test", "", { "local:snapshotable-disk-1" => "test" });

printf("Successful snapshot_rollback to intermediate snapshot\n");
testcase_rollback("104", "test2", "", { "local:snapshotable-disk-1" => "test2" });

printf("Successful snapshot_rollback with multiple mp\n");
testcase_rollback("105", "test", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });

printf("Expected error for snapshot_rollback with non-existing snapshot\n");
testcase_rollback("201", "test2", "snapshot 'test2' does not exist\n");

printf("Expected error for snapshot_rollback if volume rollback not possible\n");
testcase_rollback("202", "test", "volume_rollback_is_possible failed\n");

printf("Expected error for snapshot_rollback with incomplete snapshot\n");
testcase_rollback("203", "test", "unable to rollback to incomplete snapshot (snapstate = delete)\n");

printf("Expected error for snapshot_rollback with lock\n");
testcase_rollback("204", "test", "CT is locked (backup)\n");

printf("Expected error for snapshot_rollback with saved vmstate\n");
testcase_rollback("205", "test", "implement me - save vmstate\n", { "local:snapshotable-disk-1" => "test" });

$kill_possible = 0;

printf("Expected error for snapshot_rollback with unkillable container\n");
testcase_rollback("206", "test", "unable to rollback vm 206: vm is running\n");

$kill_possible = 1;

printf("Expected error for snapshot_rollback with mp rollback_is_possible failure\n");
testcase_rollback("207", "test", "volume_rollback_is_possible failed\n");

printf("Expected error for snapshot_rollback with mp rollback failure (results in inconsistent state)\n");
testcase_rollback("208", "test", "volume snapshot rollback disabled\n", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test" });

done_testing();
Commit	Line	Data
0fdbd016 FG	1	package PVE::LXC;
	2
	3	use strict;
	4	use warnings;
	5
0fff7963 DM	6	use lib qw(..);
0fff7963 DM	7
0fdbd016 FG	8	use PVE::Storage;
	9	use PVE::Storage::Plugin;
	10	use PVE::LXC;
67afe46e	11	use PVE::LXC::Config;
0fdbd016 FG	12	use PVE::Tools;
	13
	14	use Test::MockModule;
	15	use Test::More;
	16
	17	my $nodename;
	18	my $snapshot_possible;
	19	my $vol_snapshot_possible = {};
	20	my $vol_snapshot_delete_possible = {};
5ab55c6d FG	21	my $vol_snapshot_rollback_possible = {};
5ab55c6d FG	22	my $vol_snapshot_rollback_enabled = {};
0fdbd016 FG	23	my $vol_snapshot = {};
0fdbd016 FG	24	my $vol_snapshot_delete = {};
5ab55c6d	25	my $vol_snapshot_rollback = {};
0fdbd016 FG	26	my $running;
0fdbd016 FG	27	my $freeze_possible;
5ab55c6d	28	my $kill_possible;
0fdbd016 FG	29
	30	# Mocked methods
	31
	32	sub mocked_volume_snapshot {
	33	my ($storecfg, $volid, $snapname) = @_;
19d36a45	34	die "Storage config not mocked! aborting\n"
0fdbd016	35	if defined($storecfg);
19d36a45	36	die "volid undefined\n"
0fdbd016	37	if !defined($volid);
19d36a45	38	die "snapname undefined\n"
0fdbd016 FG	39	if !defined($snapname);
	40	if ($vol_snapshot_possible->{$volid}) {
	41	if (defined($vol_snapshot->{$volid})) {
	42	$vol_snapshot->{$volid} .= ",$snapname";
	43	} else {
	44	$vol_snapshot->{$volid} = $snapname;
	45	}
	46	return 1;
	47	} else {
19d36a45	48	die "volume snapshot disabled\n";
0fdbd016 FG	49	}
	50	}
	51
	52	sub mocked_volume_snapshot_delete {
	53	my ($storecfg, $volid, $snapname) = @_;
19d36a45	54	die "Storage config not mocked! aborting\n"
0fdbd016	55	if defined($storecfg);
19d36a45	56	die "volid undefined\n"
0fdbd016	57	if !defined($volid);
19d36a45	58	die "snapname undefined\n"
0fdbd016 FG	59	if !defined($snapname);
	60	if ($vol_snapshot_delete_possible->{$volid}) {
	61	if (defined($vol_snapshot_delete->{$volid})) {
	62	$vol_snapshot_delete->{$volid} .= ",$snapname";
	63	} else {
	64	$vol_snapshot_delete->{$volid} = $snapname;
	65	}
	66	return 1;
	67	} else {
19d36a45	68	die "volume snapshot delete disabled\n";
0fdbd016 FG	69	}
	70	}
	71
5ab55c6d FG	72	sub mocked_volume_snapshot_rollback {
	73	my ($storecfg, $volid, $snapname) = @_;
	74	die "Storage config not mocked! aborting\n"
	75	if defined($storecfg);
	76	die "volid undefined\n"
	77	if !defined($volid);
	78	die "snapname undefined\n"
	79	if !defined($snapname);
	80	if ($vol_snapshot_rollback_enabled->{$volid}) {
	81	if (defined($vol_snapshot_rollback->{$volid})) {
	82	$vol_snapshot_rollback->{$volid} .= ",$snapname";
	83	} else {
	84	$vol_snapshot_rollback->{$volid} = $snapname;
	85	}
	86	return 1;
	87	} else {
	88	die "volume snapshot rollback disabled\n";
	89	}
	90	}
	91
	92	sub mocked_volume_rollback_is_possible {
	93	my ($storecfg, $volid, $snapname) = @_;
	94	die "Storage config not mocked! aborting\n"
	95	if defined($storecfg);
	96	die "volid undefined\n"
	97	if !defined($volid);
	98	die "snapname undefined\n"
	99	if !defined($snapname);
	100	return $vol_snapshot_rollback_possible->{$volid}
	101	if ($vol_snapshot_rollback_possible->{$volid});
	102	die "volume_rollback_is_possible failed\n";
	103	}
	104
0fdbd016 FG	105	sub mocked_run_command {
	106	my ($cmd, %param) = @_;
	107	my $cmdstring;
	108	if (my $ref = ref($cmd)) {
	109	$cmdstring = PVE::Tools::cmd2string($cmd);
	110	if ($cmdstring =~ m/.\/lxc-(un)?freeze./) {
	111	return 1 if $freeze_possible;
19d36a45	112	die "lxc-[un]freeze disabled\n";
0fdbd016	113	}
5ab55c6d FG	114	if ($cmdstring =~ m/.\/lxc-stop.--kill.*/) {
	115	if ($kill_possible) {
	116	$running = 0;
	117	return 1;
	118	} else {
	119	return 0;
	120	}
	121	}
0fdbd016	122	}
e2f2d0dc	123	die "unexpected run_command call: '$cmdstring', aborting\n";
0fdbd016 FG	124	}
	125
	126	# Testing methods
	127
	128	sub test_file {
	129	my ($exp_fn, $real_fn) = @_;
	130	my $ret;
	131	eval {
	132	$ret = system("diff -u '$exp_fn' '$real_fn'");
	133	};
	134	die if $@;
	135	return !$ret;
	136	}
	137
	138	sub testcase_prepare {
	139	my ($vmid, $snapname, $save_vmstate, $comment, $exp_err) = @_;
	140	subtest "Preparing snapshot '$snapname' for vm '$vmid'" => sub {
	141	plan tests => 2;
	142	$@ = undef;
	143	eval {
	144	PVE::LXC::snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
	145	};
	146	is($@, $exp_err, "\$@ correct");
	147	ok(test_file("snapshot-expected/prepare/lxc/$vmid.conf", "snapshot-working/prepare/lxc/$vmid.conf"), "config file correct");
	148	};
	149	}
	150
	151	sub testcase_commit {
	152	my ($vmid, $snapname, $exp_err) = @_;
	153	subtest "Committing snapshot '$snapname' for vm '$vmid'" => sub {
	154	plan tests => 2;
	155	$@ = undef;
	156	eval {
	157	PVE::LXC::snapshot_commit($vmid, $snapname);
	158	};
	159	is($@, $exp_err, "\$@ correct");
	160	ok(test_file("snapshot-expected/commit/lxc/$vmid.conf", "snapshot-working/commit/lxc/$vmid.conf"), "config file correct");
	161	}
	162	}
	163
	164	sub testcase_create {
	165	my ($vmid, $snapname, $save_vmstate, $comment, $exp_err, $exp_vol_snap, $exp_vol_snap_delete) = @_;
	166	subtest "Creating snapshot '$snapname' for vm '$vmid'" => sub {
	167	plan tests => 4;
	168	$vol_snapshot = {};
	169	$vol_snapshot_delete = {};
	170	$exp_vol_snap = {} if !defined($exp_vol_snap);
	171	$exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
	172	$@ = undef;
	173	eval {
	174	PVE::LXC::snapshot_create($vmid, $snapname, $save_vmstate, $comment);
	175	};
	176	is($@, $exp_err, "\$@ correct");
	177	is_deeply($vol_snapshot, $exp_vol_snap, "created correct volume snapshots");
	178	is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
	179	ok(test_file("snapshot-expected/create/lxc/$vmid.conf", "snapshot-working/create/lxc/$vmid.conf"), "config file correct");
	180	};
	181	}
	182
	183	sub testcase_delete {
	184	my ($vmid, $snapname, $force, $exp_err, $exp_vol_snap_delete) = @_;
	185	subtest "Deleting snapshot '$snapname' of vm '$vmid'" => sub {
	186	plan tests => 3;
	187	$vol_snapshot_delete = {};
188	$exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
189	$@ = undef;
190	eval {
191	PVE::LXC::snapshot_delete($vmid, $snapname, $force);
192	};
193	is($@, $exp_err, "\$@ correct");
194	is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
195	ok(test_file("snapshot-expected/delete/lxc/$vmid.conf", "snapshot-working/delete/lxc/$vmid.conf"), "config file correct");
196	};
197	}
198
5ab55c6d FG	199	sub testcase_rollback {
	200	my ($vmid, $snapname, $exp_err, $exp_vol_snap_rollback) = @_;
	201	subtest "Rolling back to snapshot '$snapname' of vm '$vmid'" => sub {
	202	plan tests => 3;
	203	$vol_snapshot_rollback = {};
	204	$running = 1;
	205	$exp_vol_snap_rollback = {} if !defined($exp_vol_snap_rollback);
	206	$@ = undef;
	207	eval {
	208	PVE::LXC::snapshot_rollback($vmid, $snapname);
	209	};
	210	is($@, $exp_err, "\$@ correct");
	211	is_deeply($vol_snapshot_rollback, $exp_vol_snap_rollback, "rolled back to correct volume snapshots");
	212	ok(test_file("snapshot-expected/rollback/lxc/$vmid.conf", "snapshot-working/rollback/lxc/$vmid.conf"), "config file correct");
	213	};
	214	}
	215
67afe46e FG	216	# BEGIN mocked PVE::LXC::Config methods
67afe46e FG	217	sub mocked_config_file_lock {
0fdbd016 FG	218	return "snapshot-working/pve-test.lock";
	219	}
	220
67afe46e FG	221	sub mocked_cfs_config_path {
67afe46e FG	222	my ($class, $vmid, $node) = @_;
0fdbd016 FG	223
	224	$node = $nodename if !$node;
	225	return "snapshot-working/$node/lxc/$vmid.conf";
	226	}
	227
67afe46e FG	228	sub mocked_load_config {
67afe46e FG	229	my ($class, $vmid, $node) = @_;
0fdbd016	230
67afe46e	231	my $filename = PVE::LXC::Config->cfs_config_path($vmid, $node);
0fdbd016 FG	232
	233	my $raw = PVE::Tools::file_get_contents($filename);
	234
	235	my $conf = PVE::LXC::parse_pct_config($filename, $raw);
	236	return $conf;
	237	}
	238
67afe46e FG	239	sub mocked_write_config {
67afe46e FG	240	my ($class, $vmid, $conf) = @_;
0fdbd016	241
67afe46e	242	my $filename = PVE::LXC::Config->cfs_config_path($vmid);
0fdbd016 FG	243
	244	if ($conf->{snapshots}) {
	245	foreach my $snapname (keys %{$conf->{snapshots}}) {
	246	$conf->{snapshots}->{$snapname}->{snaptime} = "1234567890"
	247	if $conf->{snapshots}->{$snapname}->{snaptime};
	248	}
	249	}
	250
	251	my $raw = PVE::LXC::write_pct_config($filename, $conf);
	252
	253	PVE::Tools::file_set_contents($filename, $raw);
	254	}
	255
	256	sub has_feature {
	257	my ($feature, $conf, $storecfg, $snapname) = @_;
	258	return $snapshot_possible;
	259	}
	260
	261	sub check_running {
	262	return $running;
	263	}
67afe46e	264	# END mocked PVE::LXC methods
0fdbd016 FG	265
	266	sub sync_container_namespace {
	267	return;
	268	}
	269
	270	# END redefine PVE::LXC methods
	271
	272	PVE::Tools::run_command("rm -rf snapshot-working");
	273	PVE::Tools::run_command("cp -a snapshot-input snapshot-working");
	274
67afe46e FG	275	my $lxc_config_module = new Test::MockModule('PVE::LXC::Config');
	276	$lxc_config_module->mock('config_file_lock', sub { return "snapshot-working/pve-test.lock"; });
	277	$lxc_config_module->mock('cfs_config_path', \&mocked_cfs_config_path);
	278	$lxc_config_module->mock('load_config', \&mocked_load_config);
	279	$lxc_config_module->mock('write_config', \&mocked_write_config);
	280
0fdbd016 FG	281	$running = 1;
	282	$freeze_possible = 1;
	283
e2f2d0dc FG	284	printf("\n");
	285	printf("Running prepare tests\n");
	286	printf("\n");
0fdbd016 FG	287	$nodename = "prepare";
0fdbd016 FG	288
e2f2d0dc FG	289	printf("\n");
	290	printf("Setting has_feature to return true\n");
	291	printf("\n");
0fdbd016 FG	292	$snapshot_possible = 1;
0fdbd016 FG	293
e2f2d0dc	294	printf("Successful snapshot_prepare with no existing snapshots\n");
0fdbd016 FG	295	testcase_prepare("101", "test", 0, "test comment", '');
0fdbd016 FG	296
e2f2d0dc	297	printf("Successful snapshot_prepare with one existing snapshot\n");
0fdbd016 FG	298	testcase_prepare("102", "test2", 0, "test comment", "");
0fdbd016 FG	299
e2f2d0dc	300	printf("Expected error for snapshot_prepare on locked container\n");
67afe46e	301	testcase_prepare("200", "test", 0, "test comment", "CT is locked (snapshot)\n");
0fdbd016	302
e2f2d0dc	303	printf("Expected error for snapshot_prepare with duplicate snapshot name\n");
0fdbd016 FG	304	testcase_prepare("201", "test", 0, "test comment", "snapshot name 'test' already used\n");
0fdbd016 FG	305
e2f2d0dc	306	printf("Expected error for snapshot_prepare with save_vmstate\n");
0fdbd016 FG	307	testcase_prepare("202", "test", 1, "test comment", "implement me - snapshot_save_vmstate\n");
0fdbd016 FG	308
e2f2d0dc FG	309	printf("\n");
	310	printf("Setting has_feature to return false\n");
	311	printf("\n");
0fdbd016 FG	312	$snapshot_possible = 0;
0fdbd016 FG	313
e2f2d0dc	314	printf("Expected error for snapshot_prepare if snapshots not possible\n");
0fdbd016 FG	315	testcase_prepare("300", "test", 0, "test comment", "snapshot feature is not available\n");
0fdbd016 FG	316
e2f2d0dc FG	317	printf("\n");
	318	printf("Running commit tests\n");
	319	printf("\n");
0fdbd016 FG	320	$nodename = "commit";
0fdbd016 FG	321
e2f2d0dc FG	322	printf("\n");
	323	printf("Setting has_feature to return true\n");
	324	printf("\n");
0fdbd016 FG	325	$snapshot_possible = 1;
0fdbd016 FG	326
e2f2d0dc	327	printf("Successful snapshot_commit with one prepared snapshot\n");
0fdbd016 FG	328	testcase_commit("101", "test", "");
0fdbd016 FG	329
e2f2d0dc	330	printf("Successful snapshot_commit with one committed and one prepared snapshot\n");
0fdbd016 FG	331	testcase_commit("102", "test2", "");
0fdbd016 FG	332
e2f2d0dc	333	printf("Expected error for snapshot_commit with no snapshot lock\n");
0fdbd016 FG	334	testcase_commit("201", "test", "missing snapshot lock\n");
0fdbd016 FG	335
e2f2d0dc	336	printf("Expected error for snapshot_commit with invalid snapshot name\n");
0fdbd016 FG	337	testcase_commit("202", "test", "snapshot 'test' does not exist\n");
0fdbd016 FG	338
e2f2d0dc	339	printf("Expected error for snapshot_commit with invalid snapshot state\n");
0fdbd016 FG	340	testcase_commit("203", "test", "wrong snapshot state\n");
	341
	342	$vol_snapshot_possible->{"local:snapshotable-disk-1"} = 1;
3c8677f8 FG	343	$vol_snapshot_possible->{"local:snapshotable-disk-2"} = 1;
3c8677f8 FG	344	$vol_snapshot_possible->{"local:snapshotable-disk-3"} = 1;
0fdbd016	345	$vol_snapshot_delete_possible->{"local:snapshotable-disk-1"} = 1;
5ab55c6d	346	$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-1"} = 1;
3c8677f8 FG	347	$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-2"} = 1;
3c8677f8 FG	348	$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-3"} = 1;
5ab55c6d	349	$vol_snapshot_rollback_possible->{"local:snapshotable-disk-1"} = 1;
3c8677f8 FG	350	$vol_snapshot_rollback_possible->{"local:snapshotable-disk-2"} = 1;
	351	$vol_snapshot_rollback_possible->{"local:snapshotable-disk-3"} = 1;
	352
	353	# possible, but fails
	354	$vol_snapshot_rollback_possible->{"local:snapshotable-disk-4"} = 1;
5ab55c6d	355
e2f2d0dc FG	356	printf("\n");
e2f2d0dc FG	357	printf("Setting up Mocking for PVE::Storage\n");
0fdbd016 FG	358	my $storage_module = new Test::MockModule('PVE::Storage');
	359	$storage_module->mock('config', sub { return undef; });
	360	$storage_module->mock('volume_snapshot', \&mocked_volume_snapshot);
	361	$storage_module->mock('volume_snapshot_delete', \&mocked_volume_snapshot_delete);
5ab55c6d FG	362	$storage_module->mock('volume_snapshot_rollback', \&mocked_volume_snapshot_rollback);
	363	$storage_module->mock('volume_rollback_is_possible', \&mocked_volume_rollback_is_possible);
	364	printf("\tconfig(), volume_snapshot(), volume_snapshot_delete(), volume_snapshot_rollback() and volume_rollback_is_possible() mocked\n");
0fdbd016	365
e2f2d0dc FG	366	printf("\n");
e2f2d0dc FG	367	printf("Setting up Mocking for PVE::Tools\n");
0fdbd016 FG	368	my $tools_module = new Test::MockModule('PVE::Tools');
0fdbd016 FG	369	$tools_module->mock('run_command' => \&mocked_run_command);
e2f2d0dc	370	printf("\trun_command() mocked\n");
0fdbd016 FG	371
0fdbd016 FG	372	$nodename = "create";
e2f2d0dc FG	373	printf("\n");
	374	printf("Running create tests\n");
	375	printf("\n");
0fdbd016	376
e2f2d0dc	377	printf("Successful snapshot_create with no existing snapshots\n");
0fdbd016 FG	378	testcase_create("101", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test" });
0fdbd016 FG	379
e2f2d0dc	380	printf("Successful snapshot_create with one existing snapshots\n");
0fdbd016 FG	381	testcase_create("102", "test2", 0, "test comment", "", { "local:snapshotable-disk-1" => "test2" });
0fdbd016 FG	382
3c8677f8 FG	383	printf("Successful snapshot_create with multiple mps\n");
	384	testcase_create("103", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
	385
e2f2d0dc	386	printf("Expected error for snapshot_create when volume snapshot is not possible\n");
19d36a45	387	testcase_create("201", "test", 0, "test comment", "volume snapshot disabled\n\n");
0fdbd016	388
e2f2d0dc	389	printf("Expected error for snapshot_create with broken lxc-freeze\n");
0fdbd016	390	$freeze_possible = 0;
3c8677f8	391	testcase_create("202", "test", 0, "test comment", "lxc-[un]freeze disabled\n\n");
0fdbd016 FG	392	$freeze_possible = 1;
0fdbd016 FG	393
3c8677f8 FG	394	printf("Expected error for snapshot_create when mp volume snapshot is not possible\n");
	395	testcase_create("203", "test", 0, "test comment", "volume snapshot disabled\n\n", { "local:snapshotable-disk-1" => "test" }, { "local:snapshotable-disk-1" => "test" });
	396
0fdbd016	397	$nodename = "delete";
e2f2d0dc FG	398	printf("\n");
	399	printf("Running delete tests\n");
	400	printf("\n");
0fdbd016	401
e2f2d0dc	402	printf("Successful snapshot_delete of only existing snapshot\n");
0fdbd016 FG	403	testcase_delete("101", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
0fdbd016 FG	404
e2f2d0dc	405	printf("Successful snapshot_delete of leaf snapshot\n");
0fdbd016 FG	406	testcase_delete("102", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
0fdbd016 FG	407
e2f2d0dc	408	printf("Successful snapshot_delete of root snapshot\n");
0fdbd016 FG	409	testcase_delete("103", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
0fdbd016 FG	410
e2f2d0dc	411	printf("Successful snapshot_delete of intermediate snapshot\n");
0fdbd016 FG	412	testcase_delete("104", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
0fdbd016 FG	413
e2f2d0dc	414	printf("Successful snapshot_delete with broken volume_snapshot_delete and force=1\n");
0fdbd016 FG	415	testcase_delete("105", "test", 1, "");
0fdbd016 FG	416
3c8677f8 FG	417	printf("Successful snapshot_delete with mp broken volume_snapshot_delete and force=1\n");
	418	testcase_delete("106", "test", 1, "", { "local:snapshotable-disk-1" => "test" });
	419
e2f2d0dc	420	printf("Expected error when snapshot_delete fails with broken volume_snapshot_delete and force=0\n");
19d36a45	421	testcase_delete("201", "test", 0, "volume snapshot delete disabled\n");
0fdbd016	422
3c8677f8 FG	423	printf("Expected error when snapshot_delete fails with broken mp volume_snapshot_delete and force=0\n");
	424	testcase_delete("203", "test", 0, "volume snapshot delete disabled\n", { "local:snapshotable-disk-1" => "test" });
	425
e2f2d0dc	426	printf("Expected error for snapshot_delete with locked config\n");
67afe46e	427	testcase_delete("202", "test", 0, "CT is locked (backup)\n");
0fdbd016	428
5ab55c6d FG	429	$nodename = "rollback";
	430	printf("\n");
	431	printf("Running rollback tests\n");
	432	printf("\n");
	433
	434	$kill_possible = 1;
	435
	436	printf("Successful snapshot_rollback to only existing snapshot\n");
	437	testcase_rollback("101", "test", "", { "local:snapshotable-disk-1" => "test" });
	438
	439	printf("Successful snapshot_rollback to leaf snapshot\n");
	440	testcase_rollback("102", "test2", "", { "local:snapshotable-disk-1" => "test2" });
	441
	442	printf("Successful snapshot_rollback to root snapshot\n");
	443	testcase_rollback("103", "test", "", { "local:snapshotable-disk-1" => "test" });
	444
	445	printf("Successful snapshot_rollback to intermediate snapshot\n");
	446	testcase_rollback("104", "test2", "", { "local:snapshotable-disk-1" => "test2" });
	447
3c8677f8 FG	448	printf("Successful snapshot_rollback with multiple mp\n");
	449	testcase_rollback("105", "test", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
	450
5ab55c6d FG	451	printf("Expected error for snapshot_rollback with non-existing snapshot\n");
	452	testcase_rollback("201", "test2", "snapshot 'test2' does not exist\n");
	453
	454	printf("Expected error for snapshot_rollback if volume rollback not possible\n");
	455	testcase_rollback("202", "test", "volume_rollback_is_possible failed\n");
	456
	457	printf("Expected error for snapshot_rollback with incomplete snapshot\n");
	458	testcase_rollback("203", "test", "unable to rollback to incomplete snapshot (snapstate = delete)\n");
	459
	460	printf("Expected error for snapshot_rollback with lock\n");
67afe46e	461	testcase_rollback("204", "test", "CT is locked (backup)\n");
5ab55c6d FG	462
	463	printf("Expected error for snapshot_rollback with saved vmstate\n");
	464	testcase_rollback("205", "test", "implement me - save vmstate\n", { "local:snapshotable-disk-1" => "test" });
	465
	466	$kill_possible = 0;
	467
	468	printf("Expected error for snapshot_rollback with unkillable container\n");
	469	testcase_rollback("206", "test", "unable to rollback vm 206: vm is running\n");
0fdbd016	470
3c8677f8 FG	471	$kill_possible = 1;
	472
	473	printf("Expected error for snapshot_rollback with mp rollback_is_possible failure\n");
	474	testcase_rollback("207", "test", "volume_rollback_is_possible failed\n");
	475
	476	printf("Expected error for snapshot_rollback with mp rollback failure (results in inconsistent state)\n");
	477	testcase_rollback("208", "test", "volume snapshot rollback disabled\n", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test" });
	478
0fdbd016	479	done_testing();