contrib/atf/atf-run/requirements_test.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2010 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 #include "atf-c++/config.hpp"
  31 #include "atf-c++/detail/text.hpp"
  32 #include "atf-c++/macros.hpp"
  33
  34 #include "requirements.hpp"
  35 #include "user.hpp"
  36
  37 namespace impl = atf::atf_run;
  38
  39 // -------------------------------------------------------------------------
  40 // Auxiliary functions.
  41 // -------------------------------------------------------------------------
  42
  43 namespace {
  44
  45 const atf::tests::vars_map no_config;
  46
  47 void
  48 do_check(const std::string& expected, const atf::tests::vars_map& metadata,
  49          const atf::tests::vars_map& config = no_config)
  50 {
  51     const std::string actual = impl::check_requirements(metadata, config);
  52     if (!atf::text::match(actual, expected))
  53         ATF_FAIL("Requirements failure reason \"" + actual + "\" does not "
  54                  "match \"" + expected + "\"");
  55 }
  56
  57 } // anonymous namespace
  58
  59 // -------------------------------------------------------------------------
  60 // Tests for the require.arch metadata property.
  61 // -------------------------------------------------------------------------
  62
  63 ATF_TEST_CASE(require_arch_one_ok);
  64 ATF_TEST_CASE_HEAD(require_arch_one_ok) {}
  65 ATF_TEST_CASE_BODY(require_arch_one_ok) {
  66     atf::tests::vars_map metadata;
  67     metadata["require.arch"] = atf::config::get("atf_arch");
  68     do_check("", metadata);
  69 }
  70
  71 ATF_TEST_CASE(require_arch_one_fail);
  72 ATF_TEST_CASE_HEAD(require_arch_one_fail) {}
  73 ATF_TEST_CASE_BODY(require_arch_one_fail) {
  74     atf::tests::vars_map metadata;
  75     metadata["require.arch"] = "__fake_arch__";
  76     do_check("Requires the '__fake_arch__' architecture", metadata);
  77 }
  78
  79 ATF_TEST_CASE(require_arch_many_ok);
  80 ATF_TEST_CASE_HEAD(require_arch_many_ok) {}
  81 ATF_TEST_CASE_BODY(require_arch_many_ok) {
  82     atf::tests::vars_map metadata;
  83     metadata["require.arch"] = "__foo__ " + atf::config::get("atf_arch") +
  84         " __bar__";
  85     do_check("", metadata);
  86 }
  87
  88 ATF_TEST_CASE(require_arch_many_fail);
  89 ATF_TEST_CASE_HEAD(require_arch_many_fail) {}
  90 ATF_TEST_CASE_BODY(require_arch_many_fail) {
  91     atf::tests::vars_map metadata;
  92     metadata["require.arch"] = "__foo__ __bar__ __baz__";
  93     do_check("Requires one of the '__foo__ __bar__ __baz__' architectures",
  94              metadata);
  95 }
  96
  97 // -------------------------------------------------------------------------
  98 // Tests for the require.config metadata property.
  99 // -------------------------------------------------------------------------
 100
 101 ATF_TEST_CASE(require_config_one_ok);
 102 ATF_TEST_CASE_HEAD(require_config_one_ok) {}
 103 ATF_TEST_CASE_BODY(require_config_one_ok) {
 104     atf::tests::vars_map metadata, config;
 105     metadata["require.config"] = "var1";
 106     config["var1"] = "some-value";
 107     do_check("", metadata, config);
 108 }
 109
 110 ATF_TEST_CASE(require_config_one_fail);
 111 ATF_TEST_CASE_HEAD(require_config_one_fail) {}
 112 ATF_TEST_CASE_BODY(require_config_one_fail) {
 113     atf::tests::vars_map metadata, config;
 114     metadata["require.config"] = "var1";
 115     do_check("Required configuration variable 'var1' not defined", metadata,
 116              config);
 117 }
 118
 119 ATF_TEST_CASE(require_config_many_ok);
 120 ATF_TEST_CASE_HEAD(require_config_many_ok) {}
 121 ATF_TEST_CASE_BODY(require_config_many_ok) {
 122     atf::tests::vars_map metadata, config;
 123     metadata["require.config"] = "var1 var2 var3";
 124     config["var1"] = "first-value";
 125     config["var2"] = "second-value";
 126     config["var3"] = "third-value";
 127     do_check("", metadata, config);
 128 }
 129
 130 ATF_TEST_CASE(require_config_many_fail);
 131 ATF_TEST_CASE_HEAD(require_config_many_fail) {}
 132 ATF_TEST_CASE_BODY(require_config_many_fail) {
 133     atf::tests::vars_map metadata, config;
 134     metadata["require.config"] = "var1 var2 var3";
 135     config["var1"] = "first-value";
 136     config["var3"] = "third-value";
 137     do_check("Required configuration variable 'var2' not defined", metadata,
 138              config);
 139 }
 140
 141 // -------------------------------------------------------------------------
 142 // Tests for the require.files metadata property.
 143 // -------------------------------------------------------------------------
 144
 145 ATF_TEST_CASE_WITHOUT_HEAD(require_files_one_ok);
 146 ATF_TEST_CASE_BODY(require_files_one_ok) {
 147     atf::tests::vars_map metadata;
 148     metadata["require.files"] = "/bin/ls";
 149     do_check("", metadata);
 150 }
 151
 152 ATF_TEST_CASE_WITHOUT_HEAD(require_files_one_missing);
 153 ATF_TEST_CASE_BODY(require_files_one_missing) {
 154     atf::tests::vars_map metadata;
 155     metadata["require.files"] = "/non-existent/foo";
 156     do_check("Required file '/non-existent/foo' not found", metadata);
 157 }
 158
 159 ATF_TEST_CASE_WITHOUT_HEAD(require_files_one_fail);
 160 ATF_TEST_CASE_BODY(require_files_one_fail) {
 161     atf::tests::vars_map metadata;
 162     metadata["require.files"] = "/bin/cp this-is-relative";
 163     ATF_REQUIRE_THROW_RE(std::runtime_error, "Relative.*(this-is-relative)",
 164                          impl::check_requirements(metadata, no_config));
 165 }
 166
 167 ATF_TEST_CASE_WITHOUT_HEAD(require_files_many_ok);
 168 ATF_TEST_CASE_BODY(require_files_many_ok) {
 169     atf::tests::vars_map metadata;
 170     metadata["require.files"] = "/bin/ls /bin/cp";
 171     do_check("", metadata);
 172 }
 173
 174 ATF_TEST_CASE_WITHOUT_HEAD(require_files_many_missing);
 175 ATF_TEST_CASE_BODY(require_files_many_missing) {
 176     atf::tests::vars_map metadata;
 177     metadata["require.files"] = "/bin/ls /non-existent/bar /bin/cp";
 178     do_check("Required file '/non-existent/bar' not found", metadata);
 179 }
 180
 181 ATF_TEST_CASE_WITHOUT_HEAD(require_files_many_fail);
 182 ATF_TEST_CASE_BODY(require_files_many_fail) {
 183     atf::tests::vars_map metadata;
 184     metadata["require.files"] = "/bin/cp also-relative";
 185     ATF_REQUIRE_THROW_RE(std::runtime_error, "Relative.*(also-relative)",
 186                          impl::check_requirements(metadata, no_config));
 187 }
 188
 189 // -------------------------------------------------------------------------
 190 // Tests for the require.machine metadata property.
 191 // -------------------------------------------------------------------------
 192
 193 ATF_TEST_CASE(require_machine_one_ok);
 194 ATF_TEST_CASE_HEAD(require_machine_one_ok) {}
 195 ATF_TEST_CASE_BODY(require_machine_one_ok) {
 196     atf::tests::vars_map metadata;
 197     metadata["require.machine"] = atf::config::get("atf_machine");
 198     do_check("", metadata);
 199 }
 200
 201 ATF_TEST_CASE(require_machine_one_fail);
 202 ATF_TEST_CASE_HEAD(require_machine_one_fail) {}
 203 ATF_TEST_CASE_BODY(require_machine_one_fail) {
 204     atf::tests::vars_map metadata;
 205     metadata["require.machine"] = "__fake_machine__";
 206     do_check("Requires the '__fake_machine__' machine type", metadata);
 207 }
 208
 209 ATF_TEST_CASE(require_machine_many_ok);
 210 ATF_TEST_CASE_HEAD(require_machine_many_ok) {}
 211 ATF_TEST_CASE_BODY(require_machine_many_ok) {
 212     atf::tests::vars_map metadata;
 213     metadata["require.machine"] = "__foo__ " + atf::config::get("atf_machine") +
 214         " __bar__";
 215     do_check("", metadata);
 216 }
 217
 218 ATF_TEST_CASE(require_machine_many_fail);
 219 ATF_TEST_CASE_HEAD(require_machine_many_fail) {}
 220 ATF_TEST_CASE_BODY(require_machine_many_fail) {
 221     atf::tests::vars_map metadata;
 222     metadata["require.machine"] = "__foo__ __bar__ __baz__";
 223     do_check("Requires one of the '__foo__ __bar__ __baz__' machine types",
 224              metadata);
 225 }
 226
 227 // -------------------------------------------------------------------------
 228 // Tests for the require.memory metadata property.
 229 // -------------------------------------------------------------------------
 230
 231 ATF_TEST_CASE_WITHOUT_HEAD(require_memory_ok);
 232 ATF_TEST_CASE_BODY(require_memory_ok) {
 233     atf::tests::vars_map metadata;
 234     metadata["require.memory"] = "1m";
 235     do_check("", metadata);
 236 }
 237
 238 ATF_TEST_CASE_WITHOUT_HEAD(require_memory_not_enough);
 239 ATF_TEST_CASE_BODY(require_memory_not_enough) {
 240     atf::tests::vars_map metadata;
 241     metadata["require.memory"] = "128t";
 242 #if defined(__APPLE__) || defined(__DragonFly__) || \
 243     defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 244     do_check("Not enough memory; needed 140737488355328, available [0-9]*",
 245              metadata);
 246 #else
 247     skip("Don't know how to check for the amount of physical memory");
 248 #endif
 249 }
 250
 251 ATF_TEST_CASE_WITHOUT_HEAD(require_memory_fail);
 252 ATF_TEST_CASE_BODY(require_memory_fail) {
 253     atf::tests::vars_map metadata;
 254     metadata["require.memory"] = "foo";
 255     ATF_REQUIRE_THROW(std::runtime_error,
 256                       impl::check_requirements(metadata, no_config));
 257 }
 258
 259 // -------------------------------------------------------------------------
 260 // Tests for the require.progs metadata property.
 261 // -------------------------------------------------------------------------
 262
 263 ATF_TEST_CASE(require_progs_one_ok);
 264 ATF_TEST_CASE_HEAD(require_progs_one_ok) {}
 265 ATF_TEST_CASE_BODY(require_progs_one_ok) {
 266     atf::tests::vars_map metadata;
 267     metadata["require.progs"] = "cp";
 268     do_check("", metadata);
 269 }
 270
 271 ATF_TEST_CASE(require_progs_one_missing);
 272 ATF_TEST_CASE_HEAD(require_progs_one_missing) {}
 273 ATF_TEST_CASE_BODY(require_progs_one_missing) {
 274     atf::tests::vars_map metadata;
 275     metadata["require.progs"] = "cp __non-existent__";
 276     do_check("Required program '__non-existent__' not found in the PATH",
 277              metadata);
 278 }
 279
 280 ATF_TEST_CASE(require_progs_one_fail);
 281 ATF_TEST_CASE_HEAD(require_progs_one_fail) {}
 282 ATF_TEST_CASE_BODY(require_progs_one_fail) {
 283     atf::tests::vars_map metadata;
 284     metadata["require.progs"] = "bin/cp";
 285     ATF_REQUIRE_THROW(std::runtime_error,
 286                     impl::check_requirements(metadata, no_config));
 287 }
 288
 289 ATF_TEST_CASE(require_progs_many_ok);
 290 ATF_TEST_CASE_HEAD(require_progs_many_ok) {}
 291 ATF_TEST_CASE_BODY(require_progs_many_ok) {
 292     atf::tests::vars_map metadata;
 293     metadata["require.progs"] = "cp ls mv";
 294     do_check("", metadata);
 295 }
 296
 297 ATF_TEST_CASE(require_progs_many_missing);
 298 ATF_TEST_CASE_HEAD(require_progs_many_missing) {}
 299 ATF_TEST_CASE_BODY(require_progs_many_missing) {
 300     atf::tests::vars_map metadata;
 301     metadata["require.progs"] = "mv ls __foo__ cp";
 302     do_check("Required program '__foo__' not found in the PATH", metadata);
 303 }
 304
 305 ATF_TEST_CASE(require_progs_many_fail);
 306 ATF_TEST_CASE_HEAD(require_progs_many_fail) {}
 307 ATF_TEST_CASE_BODY(require_progs_many_fail) {
 308     atf::tests::vars_map metadata;
 309     metadata["require.progs"] = "ls cp ../bin/cp";
 310     ATF_REQUIRE_THROW(std::runtime_error,
 311                     impl::check_requirements(metadata, no_config));
 312 }
 313
 314 // -------------------------------------------------------------------------
 315 // Tests for the require.user metadata property.
 316 // -------------------------------------------------------------------------
 317
 318 ATF_TEST_CASE(require_user_root);
 319 ATF_TEST_CASE_HEAD(require_user_root) {}
 320 ATF_TEST_CASE_BODY(require_user_root) {
 321     atf::tests::vars_map metadata;
 322     metadata["require.user"] = "root";
 323     if (atf::atf_run::is_root())
 324         do_check("", metadata);
 325     else
 326         do_check("Requires root privileges", metadata);
 327 }
 328
 329 ATF_TEST_CASE(require_user_unprivileged);
 330 ATF_TEST_CASE_HEAD(require_user_unprivileged) {}
 331 ATF_TEST_CASE_BODY(require_user_unprivileged) {
 332     atf::tests::vars_map metadata;
 333     metadata["require.user"] = "unprivileged";
 334     if (atf::atf_run::is_root())
 335         do_check("Requires an unprivileged user and the 'unprivileged-user' "
 336                  "configuration variable is not set", metadata);
 337     else
 338         do_check("", metadata);
 339 }
 340
 341 ATF_TEST_CASE(require_user_fail);
 342 ATF_TEST_CASE_HEAD(require_user_fail) {}
 343 ATF_TEST_CASE_BODY(require_user_fail) {
 344     atf::tests::vars_map metadata;
 345     metadata["require.user"] = "nobody";
 346     ATF_REQUIRE_THROW(std::runtime_error,
 347                     impl::check_requirements(metadata, no_config));
 348 }
 349
 350 // -------------------------------------------------------------------------
 351 // Main.
 352 // -------------------------------------------------------------------------
 353
 354 ATF_INIT_TEST_CASES(tcs)
 355 {
 356     // Add test cases for require.arch.
 357     ATF_ADD_TEST_CASE(tcs, require_arch_one_ok);
 358     ATF_ADD_TEST_CASE(tcs, require_arch_one_fail);
 359     ATF_ADD_TEST_CASE(tcs, require_arch_many_ok);
 360     ATF_ADD_TEST_CASE(tcs, require_arch_many_fail);
 361
 362     // Add test cases for require.config.
 363     ATF_ADD_TEST_CASE(tcs, require_config_one_ok);
 364     ATF_ADD_TEST_CASE(tcs, require_config_one_fail);
 365     ATF_ADD_TEST_CASE(tcs, require_config_many_ok);
 366     ATF_ADD_TEST_CASE(tcs, require_config_many_fail);
 367
 368     // Add test cases for require.files.
 369     ATF_ADD_TEST_CASE(tcs, require_files_one_ok);
 370     ATF_ADD_TEST_CASE(tcs, require_files_one_missing);
 371     ATF_ADD_TEST_CASE(tcs, require_files_one_fail);
 372     ATF_ADD_TEST_CASE(tcs, require_files_many_ok);
 373     ATF_ADD_TEST_CASE(tcs, require_files_many_missing);
 374     ATF_ADD_TEST_CASE(tcs, require_files_many_fail);
 375
 376     // Add test cases for require.machine.
 377     ATF_ADD_TEST_CASE(tcs, require_machine_one_ok);
 378     ATF_ADD_TEST_CASE(tcs, require_machine_one_fail);
 379     ATF_ADD_TEST_CASE(tcs, require_machine_many_ok);
 380     ATF_ADD_TEST_CASE(tcs, require_machine_many_fail);
 381
 382     // Add test cases for require.memory.
 383     ATF_ADD_TEST_CASE(tcs, require_memory_ok);
 384     ATF_ADD_TEST_CASE(tcs, require_memory_not_enough);
 385     ATF_ADD_TEST_CASE(tcs, require_memory_fail);
 386
 387     // Add test cases for require.progs.
 388     ATF_ADD_TEST_CASE(tcs, require_progs_one_ok);
 389     ATF_ADD_TEST_CASE(tcs, require_progs_one_missing);
 390     ATF_ADD_TEST_CASE(tcs, require_progs_one_fail);
 391     ATF_ADD_TEST_CASE(tcs, require_progs_many_ok);
 392     ATF_ADD_TEST_CASE(tcs, require_progs_many_missing);
 393     ATF_ADD_TEST_CASE(tcs, require_progs_many_fail);
 394
 395     // Add test cases for require.user.
 396     ATF_ADD_TEST_CASE(tcs, require_user_root);
 397     ATF_ADD_TEST_CASE(tcs, require_user_unprivileged);
 398     ATF_ADD_TEST_CASE(tcs, require_user_fail);
 399 }