test/run_config2command_tests.pl

   1 #!/usr/bin/perl
   2
   3 use strict;
   4 use warnings;
   5
   6 use lib qw(..);
   7
   8 use Test::More;
   9 use Test::MockModule;
  10
  11 use PVE::Tools qw(file_get_contents file_set_contents run_command);
  12 use PVE::QemuConfig;
  13 use PVE::QemuServer;
  14
  15 my $base_env = {
  16     storage_config => {
  17         ids => {
  18             local => {
  19                 content => {
  20                     images => 1,
  21                 },
  22                 path => '/var/lib/vz',
  23                 type => 'dir',
  24                 shared => 0,
  25             },
  26             'cifs-store' => {
  27                 shared => 1,
  28                 path => '/mnt/pve/cifs-store',
  29                 username => 'guest',
  30                 server => '127.0.0.42',
  31                 type => 'cifs',
  32                 share => 'CIFShare',
  33                 content => {
  34                     images => 1
  35                 },
  36             },
  37             'rbd-store' => {
  38                 monhost => '127.0.0.42,127.0.0.21,::1',
  39                 content => {
  40                     images => 1
  41                 },
  42                 type => 'rbd',
  43                 pool => 'cpool',
  44                 username => 'admin',
  45                 shared => 1
  46             },
  47             'local-lvm' => {
  48                 vgname => 'pve',
  49                 bwlimit => 'restore=1024',
  50                 type => 'lvmthin',
  51                 thinpool => 'data',
  52                 content => {
  53                     images => 1,
  54                 }
  55             }
  56         }
  57     },
  58     vmid => 8006,
  59     real_qemu_version => PVE::QemuServer::kvm_user_version(), # not yet mocked
  60 };
  61
  62 my $current_test; # = {
  63 #   description => 'Test description', # if available
  64 #   qemu_version => '2.12',
  65 #   host_arch => 'HOST_ARCH',
  66 #   config => { config hash },
  67 #   expected => [ expected outcome cmd line array ],
  68 # };
  69
  70 # use the config description to allow changing environment, fields are:
  71 #   TEST: A single line describing the test, gets outputted
  72 #   QEMU_VERSION: \d+\.\d+(\.\d+)? (defaults to current version)
  73 #   HOST_ARCH: x86_64 | aarch64 (default to x86_64, to make tests stable)
  74 # all fields are optional
  75 sub parse_test($) {
  76     my ($config_fn) = @_;
  77
  78     $current_test = {}; # reset
  79
  80     my $fake_config_fn ="$config_fn/qemu-server/8006.conf";
  81     my $config_raw = file_get_contents($config_fn);
  82     my $config = PVE::QemuServer::parse_vm_config($fake_config_fn, $config_raw);
  83
  84     $current_test->{config} = $config;
  85
  86     my $description = $config->{description} // '';
  87
  88     while ($description =~ /^\h*(.*?)\h*$/gm) {
  89         my $line = $1;
  90         next if !$line || $line =~ /^#/;
  91         $line =~ s/^\s+//;
  92         $line =~ s/\s+$//;
  93
  94         if ($line =~ /^TEST:\s*(.*)\s*$/) {
  95             $current_test->{description} = "$1";
  96         } elsif ($line =~ /^QEMU_VERSION:\s*(.*)\s*$/) {
  97             $current_test->{qemu_version} = "$1";
  98         } elsif ($line =~ /^HOST_ARCH:\s*(.*)\s*$/) {
  99             $current_test->{host_arch} = "$1";
 100         }
 101     }
 102 }
 103
 104 my $qemu_server_module;
 105 $qemu_server_module = Test::MockModule->new('PVE::QemuServer');
 106 $qemu_server_module->mock(
 107     kvm_user_version => sub {
 108         return $current_test->{qemu_version} // $base_env->{real_qemu_version} // '2.12';
 109     },
 110     kvm_version => sub {
 111         return $current_test->{qemu_version} // $base_env->{real_qemu_version} // '2.12';
 112     },
 113     kernel_has_vhost_net => sub {
 114         return 1; # TODO: make this per-test configurable?
 115     },
 116     get_host_arch => sub() {
 117         return $current_test->{host_arch} // 'x86_64';
 118     },
 119     get_initiator_name => sub {
 120         return 'iqn.1993-08.org.debian:01:aabbccddeeff';
 121     }
 122 );
 123
 124 my $qemu_server_config;
 125 $qemu_server_config = Test::MockModule->new('PVE::QemuConfig');
 126 $qemu_server_config->mock(
 127     load_config => sub {
 128         my ($class, $vmid, $node) = @_;
 129
 130         return $current_test->{config};
 131     },
 132 );
 133
 134 sub diff($$) {
 135     my ($a, $b) = @_;
 136     return if $a eq $b;
 137
 138     my ($ra, $wa) = POSIX::pipe();
 139     my ($rb, $wb) = POSIX::pipe();
 140     my $ha = IO::Handle->new_from_fd($wa, 'w');
 141     my $hb = IO::Handle->new_from_fd($wb, 'w');
 142
 143     open my $diffproc, '-|', 'diff', '-up', "/proc/self/fd/$ra", "/proc/self/fd/$rb"
 144         or die "failed to run program 'diff': $!";
 145     POSIX::close($ra);
 146     POSIX::close($rb);
 147
 148     open my $f1, '<', \$a;
 149     open my $f2, '<', \$b;
 150     my ($line1, $line2);
 151     do {
 152         $ha->print($line1) if defined($line1 = <$f1>);
 153         $hb->print($line2) if defined($line2 = <$f2>);
 154     } while (defined($line1 // $line2));
 155     close $f1;
 156     close $f2;
 157     close $ha;
 158     close $hb;
 159
 160     local $/ = undef;
 161     my $diff = <$diffproc>;
 162     close $diffproc;
 163     die "files differ:\n$diff";
 164 }
 165
 166 sub do_test($) {
 167     my ($config_fn) = @_;
 168
 169     die "no such input test config: $config_fn\n" if ! -f $config_fn;
 170
 171     parse_test $config_fn;
 172
 173     $config_fn =~ /([^\/]+)$/;
 174     my $testname = "$1";
 175     if (my $desc = $current_test->{description}) {
 176         $testname = "'$testname' - $desc";
 177     }
 178
 179     my ($vmid, $storecfg) = $base_env->@{qw(vmid storage_config)};
 180
 181     my $cmdline = PVE::QemuServer::vm_commandline($storecfg, $vmid);
 182
 183     $cmdline =~ s/ -/ \\\n  -/g; # same as qm showcmd --pretty
 184     $cmdline .= "\n";
 185
 186     my $cmd_fn = "$config_fn.cmd";
 187
 188     if (-f $cmd_fn) {
 189         my $cmdline_expected = file_get_contents($cmd_fn);
 190
 191         my $cmd_expected = [ sort split /\s*\\?\n\s*/, $cmdline_expected ];
 192         my $cmd = [ sort split /\s*\\?\n\s*/, $cmdline ];
 193
 194         # comment out for easier debugging
 195         #file_set_contents("$cmd_fn.tmp", $cmdline);
 196
 197         my $exp = join("\n", @$cmd_expected);
 198         my $got = join("\n", @$cmd);
 199         eval { diff($exp, $got) };
 200         if (my $err = $@) {
 201             fail("$testname");
 202             note($err);
 203         } else {
 204             pass("$testname");
 205         }
 206     } else {
 207         file_set_contents($cmd_fn, $cmdline);
 208     }
 209 }
 210
 211 print "testing config to command stabillity\n";
 212
 213 # exec tests
 214 if (my $file = shift) {
 215     do_test $file;
 216 } else {
 217     foreach my $file (<cfg2cmd/*.conf>) {
 218         do_test $file;
 219     }
 220 }
 221
 222 done_testing();