tests/virschematest.c

   1 /*
   2  * Copyright (C) 2016 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library.  If not, see
  16  * <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <config.h>
  20
  21
  22 #include "testutils.h"
  23
  24 #include "virlog.h"
  25 #include "virxml.h"
  26
  27 #define VIR_FROM_THIS VIR_FROM_NONE
  28
  29 VIR_LOG_INIT("tests.schematest");
  30
  31 struct testSchemaEntry {
  32     const char *dir;
  33     /* if dirRegex is non-NULL the provided regular expression is used to match
  34      * the file names in a directory (without path prefixed) and only matching
  35      * files are validated */
  36     const char **exceptions; /* optional NULL terminated list of filenames inside
  37                                 directory where the expected validation result is
  38                                 inverted */
  39     const char **skip; /* optional NULL terminated list of files to skip altogether */
  40     const char *dirRegex;
  41     const char *file;
  42 };
  43
  44
  45 struct testSchemaData {
  46     virXMLValidator *validator;
  47     bool exception;
  48     const char *xml_path;
  49 };
  50
  51
  52 static int
  53 testSchemaValidateXML(const void *args)
  54 {
  55     const struct testSchemaData *data = args;
  56     /* invalid XMLs have a '-invalid.' suffix, but not necessarily at the end
  57      * of the file name e.g. in case of qemuxmlconftest with real capabilities */
  58     bool shouldFail = !!strstr(data->xml_path, "-invalid.");
  59     g_autoptr(xmlDoc) xml = NULL;
  60
  61     if (data->exception)
  62         shouldFail = !shouldFail;
  63
  64     if (!(xml = virXMLParseFileCtxt(data->xml_path, NULL)))
  65         return -1;
  66
  67     if ((virXMLValidatorValidate(data->validator, xml) < 0) != shouldFail)
  68         return -1;
  69
  70     return 0;
  71 }
  72
  73
  74 static int
  75 testSchemaFile(const char *schema,
  76                virXMLValidator *validator,
  77                const char *path,
  78                bool exception)
  79 {
  80     g_autofree char *test_name = NULL;
  81     struct testSchemaData data = {
  82         .validator = validator,
  83         .xml_path = path,
  84         .exception = exception,
  85     };
  86
  87     test_name = g_strdup_printf("Checking %s against %s", path, schema);
  88
  89     return virTestRun(test_name, testSchemaValidateXML, &data);
  90 }
  91
  92
  93 static int
  94 testSchemaDir(const char *schema,
  95               virXMLValidator *validator,
  96               const char *dir_path,
  97               const struct testSchemaEntry *entry)
  98 {
  99     g_autoptr(DIR) dir = NULL;
 100     struct dirent *ent;
 101     int ret = 0;
 102     int rc;
 103     g_autoptr(GRegex) filter = NULL;
 104
 105     if (virDirOpen(&dir, dir_path) < 0) {
 106         virTestPropagateLibvirtError();
 107         return -1;
 108     }
 109
 110     if (entry->dirRegex) {
 111         g_autoptr(GError) err = NULL;
 112
 113         if (!(filter = g_regex_new(entry->dirRegex, 0, 0, &err))) {
 114             VIR_TEST_VERBOSE("\nfailed to compile regex '%s': %s", entry->dirRegex, err->message);
 115             return -1;
 116         }
 117     }
 118
 119     while ((rc = virDirRead(dir, &ent, dir_path)) > 0) {
 120         g_autofree char *xml_path = NULL;
 121         bool exception = false;
 122
 123         if (!virStringHasSuffix(ent->d_name, ".xml"))
 124             continue;
 125         if (ent->d_name[0] == '.')
 126             continue;
 127         if (filter &&
 128             !g_regex_match(filter, ent->d_name, 0, NULL))
 129             continue;
 130
 131         if (entry->skip &&
 132             g_strv_contains(entry->skip, ent->d_name))
 133             continue;
 134
 135         xml_path = g_strdup_printf("%s/%s", dir_path, ent->d_name);
 136
 137         if (virFileIsLink(xml_path) == 1)
 138             continue;
 139
 140         if (entry->exceptions)
 141             exception = g_strv_contains(entry->exceptions, ent->d_name);
 142
 143         if (testSchemaFile(schema, validator, xml_path, exception) < 0)
 144             ret = -1;
 145     }
 146
 147     if (rc < 0) {
 148         virTestPropagateLibvirtError();
 149         ret = -1;
 150     }
 151
 152     return ret;
 153 }
 154
 155
 156 /**
 157  * testSchemaGrammarReport:
 158  *
 159  * We need to parse the schema regardless since it's necessary also when tests
 160  * are skipped using VIR_TEST_RANGE so this function merely reports whether the
 161  * schema was parsed successfully via virTestRun.
 162  */
 163 static int
 164 testSchemaGrammarReport(const void *opaque)
 165 {
 166     const virXMLValidator *validator = opaque;
 167
 168     if (!validator)
 169         return -1;
 170
 171     return 0;
 172 }
 173
 174 static virXMLValidator *
 175 testSchemaGrammarLoad(const char *schema)
 176 {
 177     g_autofree char *testname = NULL;
 178     virXMLValidator *ret;
 179
 180     ret = virXMLValidatorInit(schema);
 181
 182     testname = g_strdup_printf("test schema grammar file: '%s'", schema);
 183
 184     ignore_value(virTestRun(testname, testSchemaGrammarReport, ret));
 185
 186     return ret;
 187 }
 188
 189
 190 static int
 191 testSchemaEntries(const char *schema,
 192                   const struct testSchemaEntry *entries,
 193                   size_t nentries)
 194 {
 195     g_autoptr(virXMLValidator) validator = NULL;
 196     size_t i;
 197     int ret = 0;
 198
 199     if (!(validator = testSchemaGrammarLoad(schema)))
 200         return -1;
 201
 202     for (i = 0; i < nentries; i++) {
 203         const struct testSchemaEntry *entry = entries + i;
 204
 205         if (!entry->file == !entry->dir) {
 206             VIR_TEST_VERBOSE("\nmust specify exactly one of 'dir' and 'file' for struct testSchemaEntry\n");
 207             ret = -1;
 208             continue;
 209         }
 210
 211         if (entry->dir) {
 212             g_autofree char *path = g_strdup_printf("%s/%s", abs_top_srcdir, entry->dir);
 213
 214             if (testSchemaDir(schema, validator, path, entry) < 0)
 215                 ret = -1;
 216         }
 217
 218         if (entry->file) {
 219             g_autofree char *path = g_strdup_printf("%s/%s", abs_top_srcdir, entry->file);
 220
 221             if (testSchemaFile(schema, validator, path, false) < 0)
 222                 ret = -1;
 223         }
 224     }
 225
 226     return ret;
 227 }
 228
 229
 230 static const struct testSchemaEntry schemaCapability[] = {
 231     { .dir = "tests/capabilityschemadata" },
 232     { .dir = "tests/vircaps2xmldata" },
 233     { .dir = "tests/qemucaps2xmloutdata" },
 234 };
 235
 236
 237 /* give exceptions for output files of invalid input XMLs */
 238 static const char *exceptions_qemuxmlconfdata[] = {
 239     "disk-cdrom-empty-network-invalid.x86_64-latest.xml",
 240     "numatune-auto-nodeset-invalid.x86_64-latest.xml",
 241     NULL
 242 };
 243
 244 /* skip tests with completely broken XML */
 245 static const char *skip_qemuxmlconfdata[] = {
 246     "broken-xml-invalid.xml",
 247     NULL
 248 };
 249
 250 static const struct testSchemaEntry schemaDomain[] = {
 251     { .dir = "tests/domainschemadata" },
 252     { .dir = "tests/qemuxmlconfdata",
 253       .exceptions = exceptions_qemuxmlconfdata,
 254       .skip = skip_qemuxmlconfdata,
 255     },
 256     { .dir = "tests/xmconfigdata" },
 257     { .dir = "tests/lxcxml2xmldata" },
 258     { .dir = "tests/lxcxml2xmloutdata" },
 259     { .dir = "tests/bhyvexml2argvdata" },
 260     { .dir = "tests/bhyvexml2xmloutdata" },
 261     { .dir = "tests/genericxml2xmlindata" },
 262     { .dir = "tests/genericxml2xmloutdata" },
 263     { .dir = "tests/xlconfigdata" },
 264     { .dir = "tests/libxlxml2domconfigdata" },
 265     { .dir = "tests/qemuhotplugtestdomains" },
 266     { .dir = "examples/xml/test/",
 267       .dirRegex = "testdom.*" },
 268     { .dir = "tests/qemuhotplugtestcpus" },
 269     { .dir = "tests/securityselinuxlabeldata" },
 270     { .dir = "tests/domainconfdata" },
 271     { .dir = "tests/lxcconf2xmldata" },
 272     { .dir = "tests/qemumemlockdata" },
 273     { .dir = "tests/vmx2xmldata" },
 274     { .dir = "tests/xml2vmxdata" },
 275     { .dir = "tests/bhyveargv2xmldata" },
 276     { .dir = "tests/qemuagentdata" },
 277     { .dir = "tests/chxml2xmlin" },
 278     { .dir = "tests/chxml2xmlout" },
 279 };
 280
 281 static const struct testSchemaEntry schemaDomainCaps[] = {
 282     { .dir = "tests/domaincapsdata" },
 283 };
 284
 285 static const struct testSchemaEntry schemaDomainBackup[] = {
 286     { .dir = "tests/domainbackupxml2xmlin" },
 287     { .dir = "tests/domainbackupxml2xmlout" },
 288 };
 289
 290 static const struct testSchemaEntry schemaDomainCheckpoint[] = {
 291     { .dir = "tests/qemudomaincheckpointxml2xmlin" },
 292     { .dir = "tests/qemudomaincheckpointxml2xmlout" },
 293 };
 294
 295 static const struct testSchemaEntry schemaDomainSnapshot[] = {
 296     { .dir = "tests/qemudomainsnapshotxml2xmlin" },
 297     { .dir = "tests/qemudomainsnapshotxml2xmlout" },
 298 };
 299
 300 static const struct testSchemaEntry schemaInterface[] = {
 301     { .dir = "tests/interfaceschemadata" },
 302 };
 303
 304 static const struct testSchemaEntry schemaNetwork[] = {
 305     { .dir = "src/network" },
 306     { .dir = "tests/networkxml2xmlin" },
 307     { .dir = "tests/networkxml2xmlout" },
 308     { .dir = "tests/networkxml2confdata" },
 309     { .dir = "examples/xml/test/",
 310       .dirRegex = "testnet.*" },
 311     { .dir = "tests/networkxml2xmlupdateout" },
 312     { .dir = "tests/networkxml2firewalldata" },
 313 };
 314
 315 static const struct testSchemaEntry schemaNetworkport[] = {
 316     { .dir = "tests/virnetworkportxml2xmldata" },
 317 };
 318
 319 static const struct testSchemaEntry schemaNodedev[] = {
 320     { .dir = "tests/nodedevschemadata" },
 321     { .dir = "tests/nodedevxml2xmlout" },
 322     { .file = "examples/xml/test/testdev.xml" },
 323 };
 324
 325 static const struct testSchemaEntry schemaNwfilter[] = {
 326     { .dir = "tests/nwfilterxml2xmlout" },
 327     { .dir = "src/nwfilter/xml" },
 328     { .dir = "tests/nwfilterxml2xmlin" },
 329     { .dir = "tests/nwfilterxml2firewalldata" },
 330 };
 331
 332 static const struct testSchemaEntry schemaNwfilterbinding[] = {
 333     { .dir = "tests/virnwfilterbindingxml2xmldata" },
 334 };
 335
 336 static const struct testSchemaEntry schemaSecret[] = {
 337     { .dir = "tests/secretxml2xmlin" },
 338 };
 339
 340 static const struct testSchemaEntry schemaStoragepoolcaps[] = {
 341     { .dir = "tests/storagepoolcapsschemadata" },
 342 };
 343
 344 static const struct testSchemaEntry schemaStoragePool[] = {
 345     { .dir = "tests/storagepoolxml2xmlin" },
 346     { .dir = "tests/storagepoolxml2xmlout" },
 347     { .dir = "tests/storagepoolschemadata" },
 348     { .dir = "examples/xml/storage",
 349       .dirRegex = "pool-.*" },
 350     { .file = "examples/xml/test/testpool.xml" },
 351 };
 352
 353 static const struct testSchemaEntry schemaStorageVol[] = {
 354     { .dir = "tests/storagevolxml2xmlin" },
 355     { .dir = "tests/storagevolxml2xmlout" },
 356     { .dir = "tests/storagevolschemadata" },
 357     { .dir = "examples/xml/storage",
 358       .dirRegex = "vol-.*" },
 359     { .file = "examples/xml/test/testvol.xml" },
 360 };
 361
 362 static const struct testSchemaEntry testsCpuBaseline[] = {
 363     { . dir = "tests/cputestdata" },
 364 };
 365
 366 static const struct testSchemaEntry testDevice[] = {
 367     { .dir = "tests/qemuhotplugtestdevices" },
 368     { .dir = "tests/qemublocktestdata/imagecreate" },
 369     { .dir = "tests/qemublocktestdata/xml2json" },
 370 };
 371
 372 static int
 373 mymain(void)
 374 {
 375     int ret = 0;
 376
 377 #define SCHEMAS_PATH abs_top_srcdir "/src/conf/schemas/"
 378 #define INTERNAL_SCHEMAS_PATH abs_builddir "/schemas/"
 379
 380 #define DO_TEST(sch, ent) \
 381     if (testSchemaEntries((sch), (ent), G_N_ELEMENTS(ent)) < 0) \
 382         ret = -1;
 383
 384     DO_TEST(SCHEMAS_PATH "capability.rng", schemaCapability);
 385     DO_TEST(SCHEMAS_PATH "domain.rng", schemaDomain);
 386     DO_TEST(SCHEMAS_PATH "domaincaps.rng", schemaDomainCaps);
 387     DO_TEST(SCHEMAS_PATH "domainbackup.rng", schemaDomainBackup);
 388     DO_TEST(SCHEMAS_PATH "domaincheckpoint.rng", schemaDomainCheckpoint);
 389     DO_TEST(SCHEMAS_PATH "domainsnapshot.rng", schemaDomainSnapshot);
 390     DO_TEST(SCHEMAS_PATH "interface.rng", schemaInterface);
 391     DO_TEST(SCHEMAS_PATH "network.rng", schemaNetwork);
 392     DO_TEST(SCHEMAS_PATH "networkport.rng", schemaNetworkport);
 393     DO_TEST(SCHEMAS_PATH "nodedev.rng", schemaNodedev);
 394     DO_TEST(SCHEMAS_PATH "nwfilter.rng", schemaNwfilter);
 395     DO_TEST(SCHEMAS_PATH "nwfilterbinding.rng", schemaNwfilterbinding);
 396     DO_TEST(SCHEMAS_PATH "secret.rng", schemaSecret);
 397     DO_TEST(SCHEMAS_PATH "storagepoolcaps.rng", schemaStoragepoolcaps);
 398     DO_TEST(SCHEMAS_PATH "storagepool.rng", schemaStoragePool);
 399     DO_TEST(SCHEMAS_PATH "storagevol.rng", schemaStorageVol);
 400
 401     DO_TEST(INTERNAL_SCHEMAS_PATH "cpu-baseline.rng", testsCpuBaseline);
 402     DO_TEST(INTERNAL_SCHEMAS_PATH "device.rng", testDevice);
 403
 404     return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 405 }
 406
 407 VIR_TEST_MAIN(mymain)