]> git.proxmox.com Git - qemu-server.git/blame - test/snapshot-test.pm
projects / qemu-server.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
refactor: split check_running into _exists_ and _running_
[qemu-server.git] / test / snapshot-test.pm
CommitLineData
a157d0fd
FG		 1package PVE::QemuServer;
2
3use strict;
4use warnings;
5
6use lib qw(..);
7
8use PVE::Storage;
9use PVE::Storage::Plugin;
10use PVE::QemuServer;
ffda963f 11use PVE::QemuConfig;
a157d0fd 12use PVE::Tools;
d79a3e54 13use PVE::ReplicationConfig;
a157d0fd
FG		 14
15use Test::MockModule;
16use Test::More;
17
18my $nodename;
19my $snapshot_possible;
20my $vol_snapshot_possible = {};
21my $vol_snapshot_delete_possible = {};
22my $vol_snapshot_rollback_possible = {};
23my $vol_snapshot_rollback_enabled = {};
24my $vol_snapshot = {};
25my $vol_snapshot_delete = {};
26my $vol_snapshot_rollback = {};
27my $running;
28my $freeze_possible;
29my $stop_possible;
30my $save_vmstate_works;
31my $vm_mon = {};
32
33# Mocked methods
34
35sub mocked_volume_snapshot {
36 my ($storecfg, $volid, $snapname) = @_;
37 die "Storage config not mocked! aborting\n"
38 if defined($storecfg);
39 die "volid undefined\n"
40 if !defined($volid);
41 die "snapname undefined\n"
42 if !defined($snapname);
43 if ($vol_snapshot_possible->{$volid}) {
44 if (defined($vol_snapshot->{$volid})) {
45 $vol_snapshot->{$volid} .= ",$snapname";
46 } else {
47 $vol_snapshot->{$volid} = $snapname;
48 }
49 return 1;
50 } else {
51 die "volume snapshot disabled\n";
52 }
53}
54
55sub mocked_volume_snapshot_delete {
56 my ($storecfg, $volid, $snapname) = @_;
57 die "Storage config not mocked! aborting\n"
58 if defined($storecfg);
59 die "volid undefined\n"
60 if !defined($volid);
61 die "snapname undefined\n"
62 if !defined($snapname);
63 if ($vol_snapshot_delete_possible->{$volid}) {
64 if (defined($vol_snapshot_delete->{$volid})) {
65 $vol_snapshot_delete->{$volid} .= ",$snapname";
66 } else {
67 $vol_snapshot_delete->{$volid} = $snapname;
68 }
69 return 1;
70 } else {
71 die "volume snapshot delete disabled\n";
72 }
73}
74
75sub mocked_volume_snapshot_rollback {
76 my ($storecfg, $volid, $snapname) = @_;
77 die "Storage config not mocked! aborting\n"
78 if defined($storecfg);
79 die "volid undefined\n"
80 if !defined($volid);
81 die "snapname undefined\n"
82 if !defined($snapname);
83 if ($vol_snapshot_rollback_enabled->{$volid}) {
84 if (defined($vol_snapshot_rollback->{$volid})) {
85 $vol_snapshot_rollback->{$volid} .= ",$snapname";
86 } else {
87 $vol_snapshot_rollback->{$volid} = $snapname;
88 }
89 return 1;
90 } else {
91 die "volume snapshot rollback disabled\n";
92 }
93}
94
95sub mocked_volume_rollback_is_possible {
96 my ($storecfg, $volid, $snapname) = @_;
97 die "Storage config not mocked! aborting\n"
98 if defined($storecfg);
99 die "volid undefined\n"
100 if !defined($volid);
101 die "snapname undefined\n"
102 if !defined($snapname);
103 return $vol_snapshot_rollback_possible->{$volid}
104 if ($vol_snapshot_rollback_possible->{$volid});
105 die "volume_rollback_is_possible failed\n";
106}
107
101a1b3f
FG		 108sub mocked_activate_volumes {
109 my ($storecfg, $volumes) = @_;
110 die "Storage config not mocked! aborting\n"
111 if defined($storecfg);
112 die "wrong volume - fake vmstate expected!\n"
113 if ((scalar @$volumes != 1) || @$volumes[0] ne "somestorage:state-volume");
114 return;
115}
116
117sub mocked_deactivate_volumes {
118 my ($storecfg, $volumes) = @_;
119 die "Storage config not mocked! aborting\n"
120 if defined($storecfg);
121 die "wrong volume - fake vmstate expected!\n"
122 if ((scalar @$volumes != 1) || @$volumes[0] ne "somestorage:state-volume");
123 return;
124}
125
a157d0fd
FG		 126sub mocked_vdisk_free {
127 my ($storecfg, $vmstate) = @_;
128 die "Storage config not mocked! aborting\n"
129 if defined($storecfg);
130 die "wrong vdisk - fake vmstate expected!\n"
131 if ($vmstate ne "somestorage:state-volume");
132 return;
133}
134
135sub mocked_run_command {
136 my ($cmd, %param) = @_;
137 my $cmdstring;
138 if (my $ref = ref($cmd)) {
139 $cmdstring = PVE::Tools::cmd2string($cmd);
140 if ($cmdstring =~ m/.*\/qemu-(un)?freeze.*/) {
141 return 1 if $freeze_possible;
142 die "qemu-[un]freeze disabled\n";
143 }
144 if ($cmdstring =~ m/.*\/qemu-stop.*--kill.*/) {
145 if ($stop_possible) {
146 $running = 0;
147 return 1;
148 } else {
149 return 0;
150 }
151 }
152 }
153 die "unexpected run_command call: '$cmdstring', aborting\n";
154}
155
156# Testing methods
157
158sub test_file {
159 my ($exp_fn, $real_fn) = @_;
160 my $ret;
161 eval {
162 $ret = system("diff -u '$exp_fn' '$real_fn'");
163 };
164 die if $@;
165 return !$ret;
166}
167
168sub testcase_prepare {
169 my ($vmid, $snapname, $save_vmstate, $comment, $exp_err) = @_;
170 subtest "Preparing snapshot '$snapname' for vm '$vmid'" => sub {
171 plan tests => 2;
172 $@ = undef;
173 eval {
b2c9558d 174 PVE::QemuConfig->__snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
a157d0fd
FG		 175 };
176 is($@, $exp_err, "\$@ correct");
177 ok(test_file("snapshot-expected/prepare/qemu-server/$vmid.conf", "snapshot-working/prepare/qemu-server/$vmid.conf"), "config file correct");
178 };
179}
180
181sub testcase_commit {
182 my ($vmid, $snapname, $exp_err) = @_;
183 subtest "Committing snapshot '$snapname' for vm '$vmid'" => sub {
184 plan tests => 2;
185 $@ = undef;
186 eval {
b2c9558d 187 PVE::QemuConfig->__snapshot_commit($vmid, $snapname);
a157d0fd
FG		 188 };
189 is($@, $exp_err, "\$@ correct");
190 ok(test_file("snapshot-expected/commit/qemu-server/$vmid.conf", "snapshot-working/commit/qemu-server/$vmid.conf"), "config file correct");
191 }
192}
193
194sub testcase_create {
195 my ($vmid, $snapname, $save_vmstate, $comment, $exp_err, $exp_vol_snap, $exp_vol_snap_delete) = @_;
196 subtest "Creating snapshot '$snapname' for vm '$vmid'" => sub {
197 plan tests => 4;
198 $vol_snapshot = {};
199 $vol_snapshot_delete = {};
200 $exp_vol_snap = {} if !defined($exp_vol_snap);
201 $exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
202 $@ = undef;
203 eval {
b2c9558d 204 PVE::QemuConfig->snapshot_create($vmid, $snapname, $save_vmstate, $comment);
a157d0fd
FG		 205 };
206 is($@, $exp_err, "\$@ correct");
207 is_deeply($vol_snapshot, $exp_vol_snap, "created correct volume snapshots");
208 is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
209 ok(test_file("snapshot-expected/create/qemu-server/$vmid.conf", "snapshot-working/create/qemu-server/$vmid.conf"), "config file correct");
210 };
211}
212
213sub testcase_delete {
214 my ($vmid, $snapname, $force, $exp_err, $exp_vol_snap_delete) = @_;
215 subtest "Deleting snapshot '$snapname' of vm '$vmid'" => sub {
216 plan tests => 3;
217 $vol_snapshot_delete = {};
218 $exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
219 $@ = undef;
220 eval {
b2c9558d 221 PVE::QemuConfig->snapshot_delete($vmid, $snapname, $force);
a157d0fd
FG		 222 };
223 is($@, $exp_err, "\$@ correct");
224 is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
225 ok(test_file("snapshot-expected/delete/qemu-server/$vmid.conf", "snapshot-working/delete/qemu-server/$vmid.conf"), "config file correct");
226 };
227}
228
229sub testcase_rollback {
230 my ($vmid, $snapname, $exp_err, $exp_vol_snap_rollback) = @_;
231 subtest "Rolling back to snapshot '$snapname' of vm '$vmid'" => sub {
232 plan tests => 3;
233 $vol_snapshot_rollback = {};
234 $running = 1;
235 $exp_vol_snap_rollback = {} if !defined($exp_vol_snap_rollback);
236 $@ = undef;
237 eval {
b2c9558d 238 PVE::QemuConfig->snapshot_rollback($vmid, $snapname);
a157d0fd
FG		 239 };
240 is($@, $exp_err, "\$@ correct");
241 is_deeply($vol_snapshot_rollback, $exp_vol_snap_rollback, "rolled back to correct volume snapshots");
242 ok(test_file("snapshot-expected/rollback/qemu-server/$vmid.conf", "snapshot-working/rollback/qemu-server/$vmid.conf"), "config file correct");
243 };
244}
245
ffda963f 246# BEGIN mocked PVE::QemuConfig methods
a157d0fd
FG		 247sub config_file_lock {
248 return "snapshot-working/pve-test.lock";
249}
250
251sub cfs_config_path {
ffda963f 252 my ($class, $vmid, $node) = @_;
a157d0fd
FG		 253
254 $node = $nodename if !$node;
255 return "snapshot-working/$node/qemu-server/$vmid.conf";
256}
257
258sub load_config {
ffda963f 259 my ($class, $vmid, $node) = @_;
a157d0fd 260
ffda963f 261 my $filename = $class->cfs_config_path($vmid, $node);
a157d0fd
FG		 262
263 my $raw = PVE::Tools::file_get_contents($filename);
264
265 my $conf = PVE::QemuServer::parse_vm_config($filename, $raw);
266 return $conf;
267}
268
269sub write_config {
ffda963f 270 my ($class, $vmid, $conf) = @_;
a157d0fd 271
ffda963f 272 my $filename = $class->cfs_config_path($vmid);
a157d0fd
FG		 273
274 if ($conf->{snapshots}) {
275 foreach my $snapname (keys %{$conf->{snapshots}}) {
276 $conf->{snapshots}->{$snapname}->{snaptime} = "1234567890"
277 if $conf->{snapshots}->{$snapname}->{snaptime};
278 }
279 }
280
281 my $raw = PVE::QemuServer::write_vm_config($filename, $conf);
282
283 PVE::Tools::file_set_contents($filename, $raw);
284}
285
286sub has_feature {
b2c9558d 287 my ($class, $feature, $conf, $storecfg, $snapname, $running, $backup_only) = @_;
a157d0fd
FG		 288 return $snapshot_possible;
289}
290
b2c9558d
FG		 291sub __snapshot_save_vmstate {
292 my ($class, $vmid, $conf, $snapname, $storecfg) = @_;
a157d0fd
FG		 293 die "save_vmstate failed\n"
294 if !$save_vmstate_works;
295
296 my $snap = $conf->{snapshots}->{$snapname};
297 $snap->{vmstate} = "somestorage:state-volume";
c6737ef1 298 $snap->{runningmachine} = "somemachine"
a157d0fd 299}
babf613a
SR		 300
301sub assert_config_exists_on_node {
302 my ($vmid, $node) = @_;
303 return -f cfs_config_path(undef, $vmid, $node);
304}
b2c9558d
FG		 305# END mocked PVE::QemuConfig methods
306
babf613a 307# BEGIN mocked PVE::QemuServer::Helpers methods
b2c9558d 308
babf613a 309sub vm_running_locally {
b2c9558d
FG		 310 return $running;
311}
312
babf613a
SR		 313# END mocked PVE::QemuServer::Helpers methods
314
315# BEGIN redefine PVE::QemuServer methods
a157d0fd
FG		 316
317sub do_snapshots_with_qemu {
318 return 0;
319}
320
321sub vm_qmp_command {
322 my ($vmid, $cmd, $nocheck) = @_;
323
324 my $exec = $cmd->{execute};
325 if ($exec eq "delete-drive-snapshot") {
326 return;
327 }
328 if ($exec eq "guest-ping") {
329 die "guest-ping disabled\n"
330 if !$vm_mon->{guest_ping};
331 return;
332 }
333 if ($exec eq "guest-fsfreeze-freeze" || $exec eq "guest-fsfreeze-thaw") {
334 die "freeze disabled\n"
335 if !$freeze_possible;
336 return;
337 }
338 if ($exec eq "savevm-start") {
339 die "savevm-start disabled\n"
340 if !$vm_mon->{savevm_start};
341 return;
342 }
343 if ($exec eq "savevm-end") {
344 die "savevm-end disabled\n"
345 if !$vm_mon->{savevm_end};
346 return;
347 }
348 if ($exec eq "query-savevm") {
349 return { "status" => "completed" };
350 }
351 die "unexpected vm_qmp_command!\n";
352}
353
354sub vm_start {
355 my ($storecfg, $vmid, $statefile, $skiplock, $migratedfrom, $paused, $forcemachine) = @_;
356
357 die "Storage config not mocked! aborting\n"
358 if defined($storecfg);
359
360 die "statefile and forcemachine must be both defined or undefined! aborting\n"
361 if defined($statefile) xor defined($forcemachine);
362
363 return;
364}
365
366sub vm_stop {
367 my ($storecfg, $vmid, $skiplock, $nocheck, $timeout, $shutdown, $force, $keepActive, $migratedfrom) = @_;
368
369 $running = 0
370 if $stop_possible;
371
372 return;
373}
374
375# END redefine PVE::QemuServer methods
376
377PVE::Tools::run_command("rm -rf snapshot-working");
378PVE::Tools::run_command("cp -a snapshot-input snapshot-working");
379
babf613a
SR		 380my $qemu_helpers_module = new Test::MockModule('PVE::QemuServer::Helpers');
381$qemu_helpers_module->mock('vm_running_locally', \&vm_running_locally);
382
ffda963f
FG		 383my $qemu_config_module = new Test::MockModule('PVE::QemuConfig');
384$qemu_config_module->mock('config_file_lock', \&config_file_lock);
385$qemu_config_module->mock('cfs_config_path', \&cfs_config_path);
386$qemu_config_module->mock('load_config', \&load_config);
387$qemu_config_module->mock('write_config', \&write_config);
b2c9558d
FG		 388$qemu_config_module->mock('has_feature', \&has_feature);
389$qemu_config_module->mock('__snapshot_save_vmstate', \&__snapshot_save_vmstate);
babf613a 390$qemu_config_module->mock('assert_config_exists_on_node', \&assert_config_exists_on_node);
ffda963f 391
d79a3e54
DM		 392# ignore existing replication config
393my $repl_config_module = new Test::MockModule('PVE::ReplicationConfig');
9bfca2ca 394$repl_config_module->mock('new' => sub { return bless {}, "PVE::ReplicationConfig" });
d79a3e54
DM		 395$repl_config_module->mock('check_for_existing_jobs' => sub { return undef });
396
b4dab550
FG		 397my $storage_module = new Test::MockModule('PVE::Storage');
398$storage_module->mock('config', sub { return undef; });
399$storage_module->mock('path', sub { return "/some/store/statefile/path"; });
400$storage_module->mock('activate_volumes', \&mocked_activate_volumes);
401$storage_module->mock('deactivate_volumes', \&mocked_deactivate_volumes);
402$storage_module->mock('vdisk_free', \&mocked_vdisk_free);
403$storage_module->mock('volume_snapshot', \&mocked_volume_snapshot);
404$storage_module->mock('volume_snapshot_delete', \&mocked_volume_snapshot_delete);
405$storage_module->mock('volume_snapshot_rollback', \&mocked_volume_snapshot_rollback);
406$storage_module->mock('volume_rollback_is_possible', \&mocked_volume_rollback_is_possible);
407
a157d0fd
FG		 408$running = 1;
409$freeze_possible = 1;
410$save_vmstate_works = 1;
411
412printf("\n");
413printf("Running prepare tests\n");
414printf("\n");
415$nodename = "prepare";
416
417printf("\n");
418printf("Setting has_feature to return true\n");
419printf("\n");
420$snapshot_possible = 1;
421
422printf("Successful snapshot_prepare with no existing snapshots\n");
423testcase_prepare("101", "test", 0, "test comment", '');
424
425printf("Successful snapshot_prepare with no existing snapshots, including vmstate\n");
426testcase_prepare("102", "test", 1, "test comment", '');
427
428printf("Successful snapshot_prepare with one existing snapshot\n");
429testcase_prepare("103", "test2", 0, "test comment", "");
430
431printf("Successful snapshot_prepare with one existing snapshot, including vmstate\n");
432testcase_prepare("104", "test2", 1, "test comment", "");
433
434printf("Expected error for snapshot_prepare on locked container\n");
435testcase_prepare("200", "test", 0, "test comment", "VM is locked (snapshot)\n");
436
437printf("Expected error for snapshot_prepare with duplicate snapshot name\n");
438testcase_prepare("201", "test", 0, "test comment", "snapshot name 'test' already used\n");
439
440$save_vmstate_works = 0;
441
442printf("Expected error for snapshot_prepare with failing save_vmstate\n");
443testcase_prepare("202", "test", 1, "test comment", "save_vmstate failed\n");
444
445$save_vmstate_works = 1;
446
447printf("\n");
448printf("Setting has_feature to return false\n");
449printf("\n");
450$snapshot_possible = 0;
451
452printf("Expected error for snapshot_prepare if snapshots not possible\n");
453testcase_prepare("300", "test", 0, "test comment", "snapshot feature is not available\n");
454
455printf("\n");
456printf("Running commit tests\n");
457printf("\n");
458$nodename = "commit";
459
460printf("\n");
461printf("Setting has_feature to return true\n");
462printf("\n");
463$snapshot_possible = 1;
464
465printf("Successful snapshot_commit with one prepared snapshot\n");
466testcase_commit("101", "test", "");
467
468printf("Successful snapshot_commit with one committed and one prepared snapshot\n");
469testcase_commit("102", "test2", "");
470
471printf("Expected error for snapshot_commit with no snapshot lock\n");
472testcase_commit("201", "test", "missing snapshot lock\n");
473
474printf("Expected error for snapshot_commit with invalid snapshot name\n");
475testcase_commit("202", "test", "snapshot 'test' does not exist\n");
476
477printf("Expected error for snapshot_commit with invalid snapshot state\n");
478testcase_commit("203", "test", "wrong snapshot state\n");
479
480$vol_snapshot_possible->{"local:snapshotable-disk-1"} = 1;
481$vol_snapshot_possible->{"local:snapshotable-disk-2"} = 1;
482$vol_snapshot_possible->{"local:snapshotable-disk-3"} = 1;
483$vol_snapshot_delete_possible->{"local:snapshotable-disk-1"} = 1;
484$vol_snapshot_delete_possible->{"local:snapshotable-disk-3"} = 1;
485$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-1"} = 1;
486$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-2"} = 1;
487$vol_snapshot_rollback_enabled->{"local:snapshotable-disk-3"} = 1;
488$vol_snapshot_rollback_possible->{"local:snapshotable-disk-1"} = 1;
489$vol_snapshot_rollback_possible->{"local:snapshotable-disk-2"} = 1;
490$vol_snapshot_rollback_possible->{"local:snapshotable-disk-3"} = 1;
491$vol_snapshot_rollback_possible->{"local:snapshotable-disk-4"} = 1;
492$vm_mon->{guest_ping} = 1;
493$vm_mon->{savevm_start} = 1;
494$vm_mon->{savevm_end} = 1;
495
496# possible, but fails
497$vol_snapshot_rollback_possible->{"local:snapshotable-disk-4"} = 1;
498
a157d0fd
FG		 499
500#printf("\n");
501#printf("Setting up Mocking for PVE::Tools\n");
502#my $tools_module = new Test::MockModule('PVE::Tools');
503#$tools_module->mock('run_command' => \&mocked_run_command);
504#printf("\trun_command() mocked\n");
505#
506$nodename = "create";
507printf("\n");
508printf("Running create tests\n");
509printf("\n");
510
511printf("Successful snapshot_create with no existing snapshots\n");
512testcase_create("101", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test" });
513
514printf("Successful snapshot_create with no existing snapshots, including vmstate\n");
515testcase_create("102", "test", 1, "test comment", "", { "local:snapshotable-disk-1" => "test" });
516
517printf("Successful snapshot_create with one existing snapshots\n");
518testcase_create("103", "test2", 0, "test comment", "", { "local:snapshotable-disk-1" => "test2" });
519
520printf("Successful snapshot_create with one existing snapshots, including vmstate\n");
521testcase_create("104", "test2", 1, "test comment", "", { "local:snapshotable-disk-1" => "test2" });
522
523printf("Successful snapshot_create with multiple mps\n");
524testcase_create("105", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
525
526$freeze_possible = 0;
527printf("Successful snapshot_create with no existing snapshots and broken freeze\n");
528testcase_create("106", "test", 1, "test comment", "", { "local:snapshotable-disk-1" => "test" });
529$freeze_possible = 1;
530
531printf("Expected error for snapshot_create when volume snapshot is not possible\n");
b2c9558d 532testcase_create("201", "test", 0, "test comment", "volume snapshot disabled\n\n");
a157d0fd
FG		 533
534printf("Expected error for snapshot_create when volume snapshot is not possible for one drive\n");
b2c9558d 535testcase_create("202", "test", 0, "test comment", "volume snapshot disabled\n\n", { "local:snapshotable-disk-1" => "test" }, { "local:snapshotable-disk-1" => "test" });
a157d0fd
FG		 536
537$vm_mon->{savevm_start} = 0;
538printf("Expected error for snapshot_create when Qemu mon command 'savevm-start' fails\n");
b2c9558d 539testcase_create("203", "test", 0, "test comment", "savevm-start disabled\n\n");
a157d0fd
FG		 540$vm_mon->{savevm_start} = 1;
541
28831e10
DC		 542printf("Successful snapshot_create with no existing snapshots but set machine type\n");
543testcase_create("301", "test", 1, "test comment", "", { "local:snapshotable-disk-1" => "test" });
a157d0fd
FG		 544
545$nodename = "delete";
546printf("\n");
547printf("Running delete tests\n");
548printf("\n");
549
550printf("Successful snapshot_delete of only existing snapshot\n");
551testcase_delete("101", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
552
553printf("Successful snapshot_delete of leaf snapshot\n");
554testcase_delete("102", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
555
556printf("Successful snapshot_delete of root snapshot\n");
557testcase_delete("103", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
558
559printf("Successful snapshot_delete of intermediate snapshot\n");
560testcase_delete("104", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
561
562printf("Successful snapshot_delete with broken volume_snapshot_delete and force=1\n");
563testcase_delete("105", "test", 1, "");
564
565printf("Successful snapshot_delete with mp broken volume_snapshot_delete and force=1\n");
566testcase_delete("106", "test", 1, "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-3" => "test" });
567
568printf("Expected error when snapshot_delete fails with broken volume_snapshot_delete and force=0\n");
569testcase_delete("201", "test", 0, "volume snapshot delete disabled\n");
570
571printf("Expected error when snapshot_delete fails with broken mp volume_snapshot_delete and force=0\n");
572testcase_delete("202", "test", 0, "volume snapshot delete disabled\n", { "local:snapshotable-disk-1" => "test" });
573
574printf("Expected error for snapshot_delete with locked config\n");
575testcase_delete("203", "test", 0, "VM is locked (backup)\n");
576
577$nodename = "rollback";
578printf("\n");
579printf("Running rollback tests\n");
580printf("\n");
581
582$stop_possible = 1;
583
584printf("Successful snapshot_rollback to only existing snapshot\n");
585testcase_rollback("101", "test", "", { "local:snapshotable-disk-1" => "test" });
586
587printf("Successful snapshot_rollback to leaf snapshot\n");
588testcase_rollback("102", "test2", "", { "local:snapshotable-disk-1" => "test2" });
589
590printf("Successful snapshot_rollback to root snapshot\n");
591testcase_rollback("103", "test", "", { "local:snapshotable-disk-1" => "test" });
592
593printf("Successful snapshot_rollback to intermediate snapshot\n");
594testcase_rollback("104", "test2", "", { "local:snapshotable-disk-1" => "test2" });
595
596printf("Successful snapshot_rollback with multiple mp\n");
597testcase_rollback("105", "test", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
598
599printf("Successful snapshot_rollback to only existing snapshot, with saved vmstate and machine config\n");
600testcase_rollback("106", "test", "", { "local:snapshotable-disk-1" => "test" });
601
602printf("Expected error for snapshot_rollback with non-existing snapshot\n");
603testcase_rollback("201", "test2", "snapshot 'test2' does not exist\n");
604
605printf("Expected error for snapshot_rollback if volume rollback not possible\n");
606testcase_rollback("202", "test", "volume_rollback_is_possible failed\n");
607
608printf("Expected error for snapshot_rollback with incomplete snapshot\n");
609testcase_rollback("203", "test", "unable to rollback to incomplete snapshot (snapstate = delete)\n");
610
611printf("Expected error for snapshot_rollback with lock\n");
612testcase_rollback("204", "test", "VM is locked (backup)\n");
613
614$stop_possible = 0;
615
616printf("Expected error for snapshot_rollback with unkillable container\n");
617testcase_rollback("205", "test", "unable to rollback vm 205: vm is running\n");
618
619$stop_possible = 1;
620
621printf("Expected error for snapshot_rollback with mp rollback_is_possible failure\n");
622testcase_rollback("206", "test", "volume_rollback_is_possible failed\n");
623
624printf("Expected error for snapshot_rollback with mp rollback failure (results in inconsistent state)\n");
625testcase_rollback("207", "test", "volume snapshot rollback disabled\n", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test" });
626
28831e10
DC		 627printf("Successful snapshot_rollback with saved vmstate and machine config only in snapshot\n");
628testcase_rollback("301", "test", "", { "local:snapshotable-disk-1" => "test" });
629
630printf("Successful snapshot_rollback with saved vmstate and machine config and runningmachine \n");
631testcase_rollback("302", "test", "", { "local:snapshotable-disk-1" => "test" });
632
a157d0fd 633done_testing();
Virtual Machine Manager