nixos/tests/switch-test.nix

   1 # Test configuration switching.
   2
   3 import ./make-test-python.nix ({ pkgs, ...} : let
   4
   5   # Simple service that can either be socket-activated or that will
   6   # listen on port 1234 if not socket-activated.
   7   # A connection to the socket causes 'hello' to be written to the client.
   8   socketTest = pkgs.writeScript "socket-test.py" /* python */ ''
   9     #!${pkgs.python3}/bin/python3
  10
  11     from socketserver import TCPServer, StreamRequestHandler
  12     import socket
  13     import os
  14
  15
  16     class Handler(StreamRequestHandler):
  17         def handle(self):
  18             self.wfile.write("hello".encode("utf-8"))
  19
  20
  21     class Server(TCPServer):
  22         def __init__(self, server_address, handler_cls):
  23             listenFds = os.getenv('LISTEN_FDS')
  24             if listenFds is None or int(listenFds) < 1:
  25                 print(f'Binding to {server_address}')
  26                 TCPServer.__init__(
  27                         self, server_address, handler_cls, bind_and_activate=True)
  28             else:
  29                 TCPServer.__init__(
  30                         self, server_address, handler_cls, bind_and_activate=False)
  31                 # Override socket
  32                 print(f'Got activated by {os.getenv("LISTEN_FDNAMES")} '
  33                       f'with {listenFds} FDs')
  34                 self.socket = socket.fromfd(3, self.address_family,
  35                                             self.socket_type)
  36
  37
  38     if __name__ == "__main__":
  39         server = Server(("localhost", 1234), Handler)
  40         server.serve_forever()
  41   '';
  42
  43 in {
  44   name = "switch-test";
  45   meta = with pkgs.lib.maintainers; {
  46     maintainers = [ gleber das_j ];
  47   };
  48
  49   nodes = {
  50     machine = { pkgs, lib, ... }: {
  51       environment.systemPackages = [ pkgs.socat ]; # for the socket activation stuff
  52       users.mutableUsers = false;
  53
  54       # For boot/switch testing
  55       system.build.installBootLoader = lib.mkForce (pkgs.writeShellScript "install-dummy-loader" ''
  56         echo "installing dummy bootloader"
  57         touch /tmp/bootloader-installed
  58       '');
  59
  60       specialisation = rec {
  61         simpleService.configuration = {
  62           systemd.services.test = {
  63             wantedBy = [ "multi-user.target" ];
  64             serviceConfig = {
  65               Type = "oneshot";
  66               RemainAfterExit = true;
  67               ExecStart = "${pkgs.coreutils}/bin/true";
  68               ExecReload = "${pkgs.coreutils}/bin/true";
  69             };
  70           };
  71         };
  72
  73         simpleServiceDifferentDescription.configuration = {
  74           imports = [ simpleService.configuration ];
  75           systemd.services.test.description = "Test unit";
  76         };
  77
  78         simpleServiceModified.configuration = {
  79           imports = [ simpleService.configuration ];
  80           systemd.services.test.serviceConfig.X-Test = true;
  81         };
  82
  83         simpleServiceNostop.configuration = {
  84           imports = [ simpleService.configuration ];
  85           systemd.services.test.stopIfChanged = false;
  86         };
  87
  88         simpleServiceReload.configuration = {
  89           imports = [ simpleService.configuration ];
  90           systemd.services.test = {
  91             reloadIfChanged = true;
  92             serviceConfig.ExecReload = "${pkgs.coreutils}/bin/true";
  93           };
  94         };
  95
  96         simpleServiceNorestart.configuration = {
  97           imports = [ simpleService.configuration ];
  98           systemd.services.test.restartIfChanged = false;
  99         };
 100
 101         simpleServiceFailing.configuration = {
 102           imports = [ simpleServiceModified.configuration ];
 103           systemd.services.test.serviceConfig.ExecStart = lib.mkForce "${pkgs.coreutils}/bin/false";
 104         };
 105
 106         autorestartService.configuration = {
 107           # A service that immediately goes into restarting (but without failing)
 108           systemd.services.autorestart = {
 109             wantedBy = [ "multi-user.target" ];
 110             serviceConfig = {
 111               Type = "simple";
 112               Restart = "always";
 113               RestartSec = "20y"; # Should be long enough
 114               ExecStart = "${pkgs.coreutils}/bin/true";
 115             };
 116           };
 117         };
 118
 119         autorestartServiceFailing.configuration = {
 120           imports = [ autorestartService.configuration ];
 121           systemd.services.autorestart.serviceConfig = {
 122             ExecStart = lib.mkForce "${pkgs.coreutils}/bin/false";
 123           };
 124         };
 125
 126         simpleServiceWithExtraSection.configuration = {
 127           imports = [ simpleServiceNostop.configuration ];
 128           systemd.packages = [ (pkgs.writeTextFile {
 129             name = "systemd-extra-section";
 130             destination = "/etc/systemd/system/test.service";
 131             text = ''
 132               [X-Test]
 133               X-Test-Value=a
 134             '';
 135           }) ];
 136         };
 137
 138         simpleServiceWithExtraSectionOtherName.configuration = {
 139           imports = [ simpleServiceNostop.configuration ];
 140           systemd.packages = [ (pkgs.writeTextFile {
 141             name = "systemd-extra-section";
 142             destination = "/etc/systemd/system/test.service";
 143             text = ''
 144               [X-Test2]
 145               X-Test-Value=a
 146             '';
 147           }) ];
 148         };
 149
 150         simpleServiceWithInstallSection.configuration = {
 151           imports = [ simpleServiceNostop.configuration ];
 152           systemd.packages = [ (pkgs.writeTextFile {
 153             name = "systemd-extra-section";
 154             destination = "/etc/systemd/system/test.service";
 155             text = ''
 156               [Install]
 157               WantedBy=multi-user.target
 158             '';
 159           }) ];
 160         };
 161
 162         simpleServiceWithExtraKey.configuration = {
 163           imports = [ simpleServiceNostop.configuration ];
 164           systemd.services.test.serviceConfig."X-Test" = "test";
 165         };
 166
 167         simpleServiceWithExtraKeyOtherValue.configuration = {
 168           imports = [ simpleServiceNostop.configuration ];
 169           systemd.services.test.serviceConfig."X-Test" = "test2";
 170         };
 171
 172         simpleServiceWithExtraKeyOtherName.configuration = {
 173           imports = [ simpleServiceNostop.configuration ];
 174           systemd.services.test.serviceConfig."X-Test2" = "test";
 175         };
 176
 177         simpleServiceReloadTrigger.configuration = {
 178           imports = [ simpleServiceNostop.configuration ];
 179           systemd.services.test.reloadTriggers = [ "/dev/null" ];
 180         };
 181
 182         simpleServiceReloadTriggerModified.configuration = {
 183           imports = [ simpleServiceNostop.configuration ];
 184           systemd.services.test.reloadTriggers = [ "/dev/zero" ];
 185         };
 186
 187         simpleServiceReloadTriggerModifiedAndSomethingElse.configuration = {
 188           imports = [ simpleServiceNostop.configuration ];
 189           systemd.services.test = {
 190             reloadTriggers = [ "/dev/zero" ];
 191             serviceConfig."X-Test" = "test";
 192           };
 193         };
 194
 195         simpleServiceReloadTriggerModifiedSomethingElse.configuration = {
 196           imports = [ simpleServiceNostop.configuration ];
 197           systemd.services.test.serviceConfig."X-Test" = "test";
 198         };
 199
 200         unitWithBackslash.configuration = {
 201           systemd.services."escaped\\x2ddash" = {
 202             wantedBy = [ "multi-user.target" ];
 203             serviceConfig = {
 204               Type = "oneshot";
 205               RemainAfterExit = true;
 206               ExecStart = "${pkgs.coreutils}/bin/true";
 207               ExecReload = "${pkgs.coreutils}/bin/true";
 208             };
 209           };
 210         };
 211
 212         unitWithBackslashModified.configuration = {
 213           imports = [ unitWithBackslash.configuration ];
 214           systemd.services."escaped\\x2ddash".serviceConfig.X-Test = "test";
 215         };
 216
 217         unitStartingWithDash.configuration = {
 218           systemd.services."-" = {
 219             wantedBy = [ "multi-user.target" ];
 220             serviceConfig = {
 221               Type = "oneshot";
 222               RemainAfterExit = true;
 223               ExecStart = "${pkgs.coreutils}/bin/true";
 224             };
 225           };
 226         };
 227
 228         unitStartingWithDashModified.configuration = {
 229           imports = [ unitStartingWithDash.configuration ];
 230           systemd.services."-" = {
 231             reloadIfChanged = true;
 232             serviceConfig.ExecReload = "${pkgs.coreutils}/bin/true";
 233           };
 234         };
 235
 236         unitWithRequirement.configuration = {
 237           systemd.services.required-service = {
 238             wantedBy = [ "multi-user.target" ];
 239             serviceConfig = {
 240               Type = "oneshot";
 241               RemainAfterExit = true;
 242               ExecStart = "${pkgs.coreutils}/bin/true";
 243               ExecReload = "${pkgs.coreutils}/bin/true";
 244             };
 245           };
 246           systemd.services.test-service = {
 247             wantedBy = [ "multi-user.target" ];
 248             requires = [ "required-service.service" ];
 249             serviceConfig = {
 250               Type = "oneshot";
 251               RemainAfterExit = true;
 252               ExecStart = "${pkgs.coreutils}/bin/true";
 253               ExecReload = "${pkgs.coreutils}/bin/true";
 254             };
 255           };
 256         };
 257
 258         unitWithRequirementModified.configuration = {
 259           imports = [ unitWithRequirement.configuration ];
 260           systemd.services.required-service.serviceConfig.X-Test = "test";
 261           systemd.services.test-service.reloadTriggers = [ "test" ];
 262         };
 263
 264         unitWithRequirementModifiedNostart.configuration = {
 265           imports = [ unitWithRequirement.configuration ];
 266           systemd.services.test-service.unitConfig.RefuseManualStart = true;
 267         };
 268
 269         restart-and-reload-by-activation-script.configuration = {
 270           systemd.services = rec {
 271             simple-service = {
 272               # No wantedBy so we can check if the activation script restart triggers them
 273               serviceConfig = {
 274                 Type = "oneshot";
 275                 RemainAfterExit = true;
 276                 ExecStart = "${pkgs.coreutils}/bin/true";
 277                 ExecReload = "${pkgs.coreutils}/bin/true";
 278               };
 279             };
 280
 281             simple-restart-service = simple-service // {
 282               stopIfChanged = false;
 283             };
 284
 285             simple-reload-service = simple-service // {
 286               reloadIfChanged = true;
 287             };
 288
 289             no-restart-service = simple-service // {
 290               restartIfChanged = false;
 291             };
 292
 293             reload-triggers = simple-service // {
 294               wantedBy = [ "multi-user.target" ];
 295             };
 296
 297             reload-triggers-and-restart-by-as = simple-service;
 298
 299             reload-triggers-and-restart = simple-service // {
 300               stopIfChanged = false; # easier to check for this
 301               wantedBy = [ "multi-user.target" ];
 302             };
 303           };
 304
 305           system.activationScripts.restart-and-reload-test = {
 306             supportsDryActivation = true;
 307             deps = [];
 308             text = ''
 309               if [ "$NIXOS_ACTION" = dry-activate ]; then
 310                 f=/run/nixos/dry-activation-restart-list
 311                 g=/run/nixos/dry-activation-reload-list
 312               else
 313                 f=/run/nixos/activation-restart-list
 314                 g=/run/nixos/activation-reload-list
 315               fi
 316               cat <<EOF >> "$f"
 317               simple-service.service
 318               simple-restart-service.service
 319               simple-reload-service.service
 320               no-restart-service.service
 321               reload-triggers-and-restart-by-as.service
 322               EOF
 323
 324               cat <<EOF >> "$g"
 325               reload-triggers.service
 326               reload-triggers-and-restart-by-as.service
 327               reload-triggers-and-restart.service
 328               EOF
 329             '';
 330           };
 331         };
 332
 333         restart-and-reload-by-activation-script-modified.configuration = {
 334           imports = [ restart-and-reload-by-activation-script.configuration ];
 335           systemd.services.reload-triggers-and-restart.serviceConfig.X-Modified = "test";
 336         };
 337
 338         simple-socket.configuration = {
 339           systemd.services.socket-activated = {
 340             description = "A socket-activated service";
 341             stopIfChanged = lib.mkDefault false;
 342             serviceConfig = {
 343               ExecStart = socketTest;
 344               ExecReload = "${pkgs.coreutils}/bin/true";
 345             };
 346           };
 347           systemd.sockets.socket-activated = {
 348             wantedBy = [ "sockets.target" ];
 349             listenStreams = [ "/run/test.sock" ];
 350             socketConfig.SocketMode = lib.mkDefault "0777";
 351           };
 352         };
 353
 354         simple-socket-service-modified.configuration = {
 355           imports = [ simple-socket.configuration ];
 356           systemd.services.socket-activated.serviceConfig.X-Test = "test";
 357         };
 358
 359         simple-socket-stop-if-changed.configuration = {
 360           imports = [ simple-socket.configuration ];
 361           systemd.services.socket-activated.stopIfChanged = true;
 362         };
 363
 364         simple-socket-stop-if-changed-and-reloadtrigger.configuration = {
 365           imports = [ simple-socket.configuration ];
 366           systemd.services.socket-activated = {
 367             stopIfChanged = true;
 368             reloadTriggers = [ "test" ];
 369           };
 370         };
 371
 372         mount.configuration = {
 373           systemd.mounts = [
 374             {
 375               description = "Testmount";
 376               what = "tmpfs";
 377               type = "tmpfs";
 378               where = "/testmount";
 379               options = "size=1M";
 380               wantedBy = [ "local-fs.target" ];
 381             }
 382           ];
 383         };
 384
 385         mountModified.configuration = {
 386           systemd.mounts = [
 387             {
 388               description = "Testmount";
 389               what = "tmpfs";
 390               type = "tmpfs";
 391               where = "/testmount";
 392               options = "size=10M";
 393               wantedBy = [ "local-fs.target" ];
 394             }
 395           ];
 396         };
 397
 398         timer.configuration = {
 399           systemd.timers.test-timer = {
 400             wantedBy = [ "timers.target" ];
 401             timerConfig.OnCalendar = "@1395716396"; # chosen by fair dice roll
 402           };
 403           systemd.services.test-timer = {
 404             serviceConfig = {
 405               Type = "oneshot";
 406               ExecStart = "${pkgs.coreutils}/bin/true";
 407             };
 408           };
 409         };
 410
 411         timerModified.configuration = {
 412           imports = [ timer.configuration ];
 413           systemd.timers.test-timer.timerConfig.OnCalendar = lib.mkForce "Fri 2012-11-23 16:00:00";
 414         };
 415
 416         hybridSleepModified.configuration = {
 417           systemd.targets.hybrid-sleep.unitConfig.X-Test = true;
 418         };
 419
 420         target.configuration = {
 421           systemd.targets.test-target.wantedBy = [ "multi-user.target" ];
 422           # We use this service to figure out whether the target was modified.
 423           # This is the only way because targets are filtered and therefore not
 424           # printed when they are started/stopped.
 425           systemd.services.test-service = {
 426             bindsTo = [ "test-target.target" ];
 427             serviceConfig.ExecStart = "${pkgs.coreutils}/bin/sleep infinity";
 428           };
 429         };
 430
 431         targetModified.configuration = {
 432           imports = [ target.configuration ];
 433           systemd.targets.test-target.unitConfig.X-Test = true;
 434         };
 435
 436         targetModifiedStopOnReconfig.configuration = {
 437           imports = [ target.configuration ];
 438           systemd.targets.test-target.unitConfig.X-StopOnReconfiguration = true;
 439         };
 440
 441         path.configuration = {
 442           systemd.paths.test-watch = {
 443             wantedBy = [ "paths.target" ];
 444             pathConfig.PathExists = "/testpath";
 445           };
 446           systemd.services.test-watch = {
 447             serviceConfig = {
 448               Type = "oneshot";
 449               RemainAfterExit = true;
 450               ExecStart = "${pkgs.coreutils}/bin/touch /testpath-modified";
 451             };
 452           };
 453         };
 454
 455         pathModified.configuration = {
 456           imports = [ path.configuration ];
 457           systemd.paths.test-watch.pathConfig.PathExists = lib.mkForce "/testpath2";
 458         };
 459
 460         slice.configuration = {
 461           systemd.slices.testslice.sliceConfig.MemoryMax = "1"; # don't allow memory allocation
 462           systemd.services.testservice = {
 463             serviceConfig = {
 464               Type = "oneshot";
 465               RemainAfterExit = true;
 466               ExecStart = "${pkgs.coreutils}/bin/true";
 467               Slice = "testslice.slice";
 468             };
 469           };
 470         };
 471
 472         sliceModified.configuration = {
 473           imports = [ slice.configuration ];
 474           systemd.slices.testslice.sliceConfig.MemoryMax = lib.mkForce null;
 475         };
 476       };
 477     };
 478
 479     other = {
 480       users.mutableUsers = true;
 481     };
 482   };
 483
 484   testScript = { nodes, ... }: let
 485     originalSystem = nodes.machine.config.system.build.toplevel;
 486     otherSystem = nodes.other.config.system.build.toplevel;
 487     machine = nodes.machine.config.system.build.toplevel;
 488
 489     # Ensures failures pass through using pipefail, otherwise failing to
 490     # switch-to-configuration is hidden by the success of `tee`.
 491     stderrRunner = pkgs.writeScript "stderr-runner" ''
 492       #! ${pkgs.runtimeShell}
 493       set -e
 494       set -o pipefail
 495       exec env -i "$@" | tee /dev/stderr
 496     '';
 497   in /* python */ ''
 498     def switch_to_specialisation(system, name, action="test", fail=False):
 499         if name == "":
 500             stc = f"{system}/bin/switch-to-configuration"
 501         else:
 502             stc = f"{system}/specialisation/{name}/bin/switch-to-configuration"
 503         out = machine.fail(f"{stc} {action} 2>&1") if fail \
 504             else machine.succeed(f"{stc} {action} 2>&1")
 505         assert_lacks(out, "switch-to-configuration line")  # Perl warnings
 506         return out
 507
 508     def assert_contains(haystack, needle):
 509         if needle not in haystack:
 510             print("The haystack that will cause the following exception is:")
 511             print("---")
 512             print(haystack)
 513             print("---")
 514             raise Exception(f"Expected string '{needle}' was not found")
 515
 516     def assert_lacks(haystack, needle):
 517         if needle in haystack:
 518             print("The haystack that will cause the following exception is:")
 519             print("---")
 520             print(haystack, end="")
 521             print("---")
 522             raise Exception(f"Unexpected string '{needle}' was found")
 523
 524
 525     machine.wait_for_unit("multi-user.target")
 526
 527     machine.succeed(
 528         "${stderrRunner} ${originalSystem}/bin/switch-to-configuration test"
 529     )
 530     # This tests whether the /etc/os-release parser works which is a fallback
 531     # when /etc/NIXOS is missing. If the parser does not work, switch-to-configuration
 532     # would fail.
 533     machine.succeed("rm /etc/NIXOS")
 534     machine.succeed(
 535         "${stderrRunner} ${otherSystem}/bin/switch-to-configuration test"
 536     )
 537
 538
 539     with subtest("actions"):
 540         # boot action
 541         machine.fail("test -f /tmp/bootloader-installed")
 542         out = switch_to_specialisation("${machine}", "simpleService", action="boot")
 543         assert_contains(out, "installing dummy bootloader")
 544         assert_lacks(out, "activating the configuration...")  # good indicator of a system activation
 545         machine.succeed("test -f /tmp/bootloader-installed")
 546         machine.succeed("rm /tmp/bootloader-installed")
 547
 548         # switch action
 549         machine.fail("test -f /tmp/bootloader-installed")
 550         out = switch_to_specialisation("${machine}", "", action="switch")
 551         assert_contains(out, "installing dummy bootloader")
 552         assert_contains(out, "activating the configuration...")  # good indicator of a system activation
 553         machine.succeed("test -f /tmp/bootloader-installed")
 554
 555         # test and dry-activate actions are tested further down below
 556
 557     with subtest("services"):
 558         switch_to_specialisation("${machine}", "")
 559         # Nothing happens when nothing is changed
 560         out = switch_to_specialisation("${machine}", "")
 561         assert_lacks(out, "stopping the following units:")
 562         assert_lacks(out, "NOT restarting the following changed units:")
 563         assert_lacks(out, "reloading the following units:")
 564         assert_lacks(out, "\nrestarting the following units:")
 565         assert_lacks(out, "\nstarting the following units:")
 566         assert_lacks(out, "the following new units were started:")
 567
 568         # Start a simple service
 569         out = switch_to_specialisation("${machine}", "simpleService")
 570         assert_lacks(out, "installing dummy bootloader")  # test does not install a bootloader
 571         assert_lacks(out, "stopping the following units:")
 572         assert_lacks(out, "NOT restarting the following changed units:")
 573         assert_contains(out, "reloading the following units: dbus.service\n")  # huh
 574         assert_lacks(out, "\nrestarting the following units:")
 575         assert_lacks(out, "\nstarting the following units:")
 576         assert_contains(out, "the following new units were started: test.service\n")
 577
 578         # Not changing anything doesn't do anything
 579         out = switch_to_specialisation("${machine}", "simpleService")
 580         assert_lacks(out, "stopping the following units:")
 581         assert_lacks(out, "NOT restarting the following changed units:")
 582         assert_lacks(out, "reloading the following units:")
 583         assert_lacks(out, "\nrestarting the following units:")
 584         assert_lacks(out, "\nstarting the following units:")
 585         assert_lacks(out, "the following new units were started:")
 586
 587         # Only changing the description does nothing
 588         out = switch_to_specialisation("${machine}", "simpleServiceDifferentDescription")
 589         assert_lacks(out, "stopping the following units:")
 590         assert_lacks(out, "NOT restarting the following changed units:")
 591         assert_lacks(out, "reloading the following units:")
 592         assert_lacks(out, "\nrestarting the following units:")
 593         assert_lacks(out, "\nstarting the following units:")
 594         assert_lacks(out, "the following new units were started:")
 595
 596         # Restart the simple service
 597         out = switch_to_specialisation("${machine}", "simpleServiceModified")
 598         assert_contains(out, "stopping the following units: test.service\n")
 599         assert_lacks(out, "NOT restarting the following changed units:")
 600         assert_lacks(out, "reloading the following units:")
 601         assert_lacks(out, "\nrestarting the following units:")
 602         assert_contains(out, "\nstarting the following units: test.service\n")
 603         assert_lacks(out, "the following new units were started:")
 604
 605         # Restart the service with stopIfChanged=false
 606         out = switch_to_specialisation("${machine}", "simpleServiceNostop")
 607         assert_lacks(out, "stopping the following units:")
 608         assert_lacks(out, "NOT restarting the following changed units:")
 609         assert_lacks(out, "reloading the following units:")
 610         assert_contains(out, "\nrestarting the following units: test.service\n")
 611         assert_lacks(out, "\nstarting the following units:")
 612         assert_lacks(out, "the following new units were started:")
 613
 614         # Reload the service with reloadIfChanged=true
 615         out = switch_to_specialisation("${machine}", "simpleServiceReload")
 616         assert_lacks(out, "stopping the following units:")
 617         assert_lacks(out, "NOT restarting the following changed units:")
 618         assert_contains(out, "reloading the following units: test.service\n")
 619         assert_lacks(out, "\nrestarting the following units:")
 620         assert_lacks(out, "\nstarting the following units:")
 621         assert_lacks(out, "the following new units were started:")
 622
 623         # Nothing happens when restartIfChanged=false
 624         out = switch_to_specialisation("${machine}", "simpleServiceNorestart")
 625         assert_lacks(out, "stopping the following units:")
 626         assert_contains(out, "NOT restarting the following changed units: test.service\n")
 627         assert_lacks(out, "reloading the following units:")
 628         assert_lacks(out, "\nrestarting the following units:")
 629         assert_lacks(out, "\nstarting the following units:")
 630         assert_lacks(out, "the following new units were started:")
 631
 632         # Dry mode shows different messages
 633         out = switch_to_specialisation("${machine}", "simpleService", action="dry-activate")
 634         assert_lacks(out, "stopping the following units:")
 635         assert_lacks(out, "NOT restarting the following changed units:")
 636         assert_lacks(out, "reloading the following units:")
 637         assert_lacks(out, "\nrestarting the following units:")
 638         assert_lacks(out, "\nstarting the following units:")
 639         assert_lacks(out, "the following new units were started:")
 640         assert_contains(out, "would start the following units: test.service\n")
 641
 642         # Ensure \ works in unit names
 643         out = switch_to_specialisation("${machine}", "unitWithBackslash")
 644         assert_contains(out, "stopping the following units: test.service\n")
 645         assert_lacks(out, "NOT restarting the following changed units:")
 646         assert_lacks(out, "reloading the following units:")
 647         assert_lacks(out, "\nrestarting the following units:")
 648         assert_lacks(out, "\nstarting the following units:")
 649         assert_contains(out, "the following new units were started: escaped\\x2ddash.service\n")
 650
 651         out = switch_to_specialisation("${machine}", "unitWithBackslashModified")
 652         assert_contains(out, "stopping the following units: escaped\\x2ddash.service\n")
 653         assert_lacks(out, "NOT restarting the following changed units:")
 654         assert_lacks(out, "reloading the following units:")
 655         assert_lacks(out, "\nrestarting the following units:")
 656         assert_contains(out, "\nstarting the following units: escaped\\x2ddash.service\n")
 657         assert_lacks(out, "the following new units were started:")
 658
 659         # Ensure units can start with a dash
 660         out = switch_to_specialisation("${machine}", "unitStartingWithDash")
 661         assert_contains(out, "stopping the following units: escaped\\x2ddash.service\n")
 662         assert_lacks(out, "NOT restarting the following changed units:")
 663         assert_lacks(out, "reloading the following units:")
 664         assert_lacks(out, "\nrestarting the following units:")
 665         assert_lacks(out, "\nstarting the following units:")
 666         assert_contains(out, "the following new units were started: -.service\n")
 667
 668         # The regression only occurs when reloading units
 669         out = switch_to_specialisation("${machine}", "unitStartingWithDashModified")
 670         assert_lacks(out, "stopping the following units:")
 671         assert_lacks(out, "NOT restarting the following changed units:")
 672         assert_contains(out, "reloading the following units: -.service")
 673         assert_lacks(out, "\nrestarting the following units:")
 674         assert_lacks(out, "\nstarting the following units:")
 675         assert_lacks(out, "the following new units were started:")
 676
 677         # Ensure units that require changed units are properly reloaded
 678         out = switch_to_specialisation("${machine}", "unitWithRequirement")
 679         assert_contains(out, "stopping the following units: -.service\n")
 680         assert_lacks(out, "NOT restarting the following changed units:")
 681         assert_lacks(out, "reloading the following units:")
 682         assert_lacks(out, "\nrestarting the following units:")
 683         assert_lacks(out, "\nstarting the following units:")
 684         assert_contains(out, "the following new units were started: required-service.service, test-service.service\n")
 685
 686         out = switch_to_specialisation("${machine}", "unitWithRequirementModified")
 687         assert_contains(out, "stopping the following units: required-service.service\n")
 688         assert_lacks(out, "NOT restarting the following changed units:")
 689         assert_lacks(out, "reloading the following units:")
 690         assert_lacks(out, "\nrestarting the following units:")
 691         assert_contains(out, "\nstarting the following units: required-service.service, test-service.service\n")
 692         assert_lacks(out, "the following new units were started:")
 693
 694         # Unless the unit asks to be not restarted
 695         out = switch_to_specialisation("${machine}", "unitWithRequirementModifiedNostart")
 696         assert_contains(out, "stopping the following units: required-service.service\n")
 697         assert_lacks(out, "NOT restarting the following changed units:")
 698         assert_lacks(out, "reloading the following units:")
 699         assert_lacks(out, "\nrestarting the following units:")
 700         assert_contains(out, "\nstarting the following units: required-service.service\n")
 701         assert_lacks(out, "the following new units were started:")
 702
 703     with subtest("failing units"):
 704         # Let the simple service fail
 705         switch_to_specialisation("${machine}", "simpleServiceModified")
 706         out = switch_to_specialisation("${machine}", "simpleServiceFailing", fail=True)
 707         assert_contains(out, "stopping the following units: test.service\n")
 708         assert_lacks(out, "NOT restarting the following changed units:")
 709         assert_lacks(out, "reloading the following units:")
 710         assert_lacks(out, "\nrestarting the following units:")
 711         assert_contains(out, "\nstarting the following units: test.service\n")
 712         assert_lacks(out, "the following new units were started:")
 713         assert_contains(out, "warning: the following units failed: test.service\n")
 714         assert_contains(out, "Main PID:")  # output of systemctl
 715
 716         # A unit that gets into autorestart without failing is not treated as failed
 717         out = switch_to_specialisation("${machine}", "autorestartService")
 718         assert_lacks(out, "stopping the following units:")
 719         assert_lacks(out, "NOT restarting the following changed units:")
 720         assert_lacks(out, "reloading the following units:")
 721         assert_lacks(out, "\nrestarting the following units:")
 722         assert_lacks(out, "\nstarting the following units:")
 723         assert_contains(out, "the following new units were started: autorestart.service\n")
 724         machine.systemctl('stop autorestart.service')  # cancel the 20y timer
 725
 726         # Switching to the same system should do nothing (especially not treat the unit as failed)
 727         out = switch_to_specialisation("${machine}", "autorestartService")
 728         assert_lacks(out, "stopping the following units:")
 729         assert_lacks(out, "NOT restarting the following changed units:")
 730         assert_lacks(out, "reloading the following units:")
 731         assert_lacks(out, "\nrestarting the following units:")
 732         assert_lacks(out, "\nstarting the following units:")
 733         assert_contains(out, "the following new units were started: autorestart.service\n")
 734         machine.systemctl('stop autorestart.service')  # cancel the 20y timer
 735
 736         # If systemd thinks the unit has failed and is in autorestart, we should show it as failed
 737         out = switch_to_specialisation("${machine}", "autorestartServiceFailing", fail=True)
 738         assert_lacks(out, "stopping the following units:")
 739         assert_lacks(out, "NOT restarting the following changed units:")
 740         assert_lacks(out, "reloading the following units:")
 741         assert_lacks(out, "\nrestarting the following units:")
 742         assert_lacks(out, "\nstarting the following units:")
 743         assert_lacks(out, "the following new units were started:")
 744         assert_contains(out, "warning: the following units failed: autorestart.service\n")
 745         assert_contains(out, "Main PID:")  # output of systemctl
 746
 747     with subtest("unit file parser"):
 748         # Switch to a well-known state
 749         switch_to_specialisation("${machine}", "simpleServiceNostop")
 750
 751         # Add a section
 752         out = switch_to_specialisation("${machine}", "simpleServiceWithExtraSection")
 753         assert_lacks(out, "stopping the following units:")
 754         assert_lacks(out, "NOT restarting the following changed units:")
 755         assert_lacks(out, "reloading the following units:")
 756         assert_contains(out, "\nrestarting the following units: test.service\n")
 757         assert_lacks(out, "\nstarting the following units:")
 758         assert_lacks(out, "the following new units were started:")
 759
 760         # Rename it
 761         out = switch_to_specialisation("${machine}", "simpleServiceWithExtraSectionOtherName")
 762         assert_lacks(out, "stopping the following units:")
 763         assert_lacks(out, "NOT restarting the following changed units:")
 764         assert_lacks(out, "reloading the following units:")
 765         assert_contains(out, "\nrestarting the following units: test.service\n")
 766         assert_lacks(out, "\nstarting the following units:")
 767         assert_lacks(out, "the following new units were started:")
 768
 769         # Remove it
 770         out = switch_to_specialisation("${machine}", "simpleServiceNostop")
 771         assert_lacks(out, "stopping the following units:")
 772         assert_lacks(out, "NOT restarting the following changed units:")
 773         assert_lacks(out, "reloading the following units:")
 774         assert_contains(out, "\nrestarting the following units: test.service\n")
 775         assert_lacks(out, "\nstarting the following units:")
 776         assert_lacks(out, "the following new units were started:")
 777
 778         # [Install] section is ignored
 779         out = switch_to_specialisation("${machine}", "simpleServiceWithInstallSection")
 780         assert_lacks(out, "stopping the following units:")
 781         assert_lacks(out, "NOT restarting the following changed units:")
 782         assert_lacks(out, "reloading the following units:")
 783         assert_lacks(out, "\nrestarting the following units:")
 784         assert_lacks(out, "\nstarting the following units:")
 785         assert_lacks(out, "the following new units were started:")
 786
 787         # Add a key
 788         out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKey")
 789         assert_lacks(out, "stopping the following units:")
 790         assert_lacks(out, "NOT restarting the following changed units:")
 791         assert_lacks(out, "reloading the following units:")
 792         assert_contains(out, "\nrestarting the following units: test.service\n")
 793         assert_lacks(out, "\nstarting the following units:")
 794         assert_lacks(out, "the following new units were started:")
 795
 796         # Change its value
 797         out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKeyOtherValue")
 798         assert_lacks(out, "stopping the following units:")
 799         assert_lacks(out, "NOT restarting the following changed units:")
 800         assert_lacks(out, "reloading the following units:")
 801         assert_contains(out, "\nrestarting the following units: test.service\n")
 802         assert_lacks(out, "\nstarting the following units:")
 803         assert_lacks(out, "the following new units were started:")
 804
 805         # Rename it
 806         out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKeyOtherName")
 807         assert_lacks(out, "stopping the following units:")
 808         assert_lacks(out, "NOT restarting the following changed units:")
 809         assert_lacks(out, "reloading the following units:")
 810         assert_contains(out, "\nrestarting the following units: test.service\n")
 811         assert_lacks(out, "\nstarting the following units:")
 812         assert_lacks(out, "the following new units were started:")
 813
 814         # Remove it
 815         out = switch_to_specialisation("${machine}", "simpleServiceNostop")
 816         assert_lacks(out, "stopping the following units:")
 817         assert_lacks(out, "NOT restarting the following changed units:")
 818         assert_lacks(out, "reloading the following units:")
 819         assert_contains(out, "\nrestarting the following units: test.service\n")
 820         assert_lacks(out, "\nstarting the following units:")
 821         assert_lacks(out, "the following new units were started:")
 822
 823         # Add a reload trigger
 824         out = switch_to_specialisation("${machine}", "simpleServiceReloadTrigger")
 825         assert_lacks(out, "stopping the following units:")
 826         assert_lacks(out, "NOT restarting the following changed units:")
 827         assert_contains(out, "reloading the following units: test.service\n")
 828         assert_lacks(out, "\nrestarting the following units:")
 829         assert_lacks(out, "\nstarting the following units:")
 830         assert_lacks(out, "the following new units were started:")
 831
 832         # Modify the reload trigger
 833         out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModified")
 834         assert_lacks(out, "stopping the following units:")
 835         assert_lacks(out, "NOT restarting the following changed units:")
 836         assert_contains(out, "reloading the following units: test.service\n")
 837         assert_lacks(out, "\nrestarting the following units:")
 838         assert_lacks(out, "\nstarting the following units:")
 839         assert_lacks(out, "the following new units were started:")
 840
 841         # Modify the reload trigger and something else
 842         out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModifiedAndSomethingElse")
 843         assert_lacks(out, "stopping the following units:")
 844         assert_lacks(out, "NOT restarting the following changed units:")
 845         assert_lacks(out, "reloading the following units:")
 846         assert_contains(out, "\nrestarting the following units: test.service\n")
 847         assert_lacks(out, "\nstarting the following units:")
 848         assert_lacks(out, "the following new units were started:")
 849
 850         # Remove the reload trigger
 851         out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModifiedSomethingElse")
 852         assert_lacks(out, "stopping the following units:")
 853         assert_lacks(out, "NOT restarting the following changed units:")
 854         assert_lacks(out, "reloading the following units:")
 855         assert_lacks(out, "\nrestarting the following units:")
 856         assert_lacks(out, "\nstarting the following units:")
 857         assert_lacks(out, "the following new units were started:")
 858
 859     with subtest("restart and reload by activation script"):
 860         switch_to_specialisation("${machine}", "simpleServiceNorestart")
 861         out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script")
 862         assert_contains(out, "stopping the following units: test.service\n")
 863         assert_lacks(out, "NOT restarting the following changed units:")
 864         assert_lacks(out, "reloading the following units:")
 865         assert_lacks(out, "restarting the following units:")
 866         assert_contains(out, "\nstarting the following units: no-restart-service.service, reload-triggers-and-restart-by-as.service, simple-reload-service.service, simple-restart-service.service, simple-service.service\n")
 867         assert_contains(out, "the following new units were started: no-restart-service.service, reload-triggers-and-restart-by-as.service, reload-triggers-and-restart.service, reload-triggers.service, simple-reload-service.service, simple-restart-service.service, simple-service.service\n")
 868         # Switch to the same system where the example services get restarted
 869         # and reloaded by the activation script
 870         out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script")
 871         assert_lacks(out, "stopping the following units:")
 872         assert_lacks(out, "NOT restarting the following changed units:")
 873         assert_contains(out, "reloading the following units: reload-triggers-and-restart.service, reload-triggers.service, simple-reload-service.service\n")
 874         assert_contains(out, "restarting the following units: reload-triggers-and-restart-by-as.service, simple-restart-service.service, simple-service.service\n")
 875         assert_lacks(out, "\nstarting the following units:")
 876         assert_lacks(out, "the following new units were started:")
 877         # Switch to the same system and see if the service gets restarted when it's modified
 878         # while the fact that it's supposed to be reloaded by the activation script is ignored.
 879         out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script-modified")
 880         assert_lacks(out, "stopping the following units:")
 881         assert_lacks(out, "NOT restarting the following changed units:")
 882         assert_contains(out, "reloading the following units: reload-triggers.service, simple-reload-service.service\n")
 883         assert_contains(out, "restarting the following units: reload-triggers-and-restart-by-as.service, reload-triggers-and-restart.service, simple-restart-service.service, simple-service.service\n")
 884         assert_lacks(out, "\nstarting the following units:")
 885         assert_lacks(out, "the following new units were started:")
 886         # The same, but in dry mode
 887         out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script", action="dry-activate")
 888         assert_lacks(out, "would stop the following units:")
 889         assert_lacks(out, "would NOT stop the following changed units:")
 890         assert_contains(out, "would reload the following units: reload-triggers.service, simple-reload-service.service\n")
 891         assert_contains(out, "would restart the following units: reload-triggers-and-restart-by-as.service, reload-triggers-and-restart.service, simple-restart-service.service, simple-service.service\n")
 892         assert_lacks(out, "\nwould start the following units:")
 893
 894     with subtest("socket-activated services"):
 895         # Socket-activated services don't get started, just the socket
 896         machine.fail("[ -S /run/test.sock ]")
 897         out = switch_to_specialisation("${machine}", "simple-socket")
 898         # assert_lacks(out, "stopping the following units:") not relevant
 899         assert_lacks(out, "NOT restarting the following changed units:")
 900         assert_lacks(out, "reloading the following units:")
 901         assert_lacks(out, "\nrestarting the following units:")
 902         assert_lacks(out, "\nstarting the following units:")
 903         assert_contains(out, "the following new units were started: socket-activated.socket\n")
 904         machine.succeed("[ -S /run/test.sock ]")
 905
 906         # Changing a non-activated service does nothing
 907         out = switch_to_specialisation("${machine}", "simple-socket-service-modified")
 908         assert_lacks(out, "stopping the following units:")
 909         assert_lacks(out, "NOT restarting the following changed units:")
 910         assert_lacks(out, "reloading the following units:")
 911         assert_lacks(out, "\nrestarting the following units:")
 912         assert_lacks(out, "\nstarting the following units:")
 913         assert_lacks(out, "the following new units were started:")
 914         machine.succeed("[ -S /run/test.sock ]")
 915         # The unit is properly activated when the socket is accessed
 916         if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
 917             raise Exception("Socket was not properly activated")  # idk how that would happen tbh
 918
 919         # Changing an activated service with stopIfChanged=false restarts the service
 920         out = switch_to_specialisation("${machine}", "simple-socket")
 921         assert_lacks(out, "stopping the following units:")
 922         assert_lacks(out, "NOT restarting the following changed units:")
 923         assert_lacks(out, "reloading the following units:")
 924         assert_contains(out, "\nrestarting the following units: socket-activated.service\n")
 925         assert_lacks(out, "\nstarting the following units:")
 926         assert_lacks(out, "the following new units were started:")
 927         machine.succeed("[ -S /run/test.sock ]")
 928         # Socket-activation of the unit still works
 929         if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
 930             raise Exception("Socket was not properly activated after the service was restarted")
 931
 932         # Changing an activated service with stopIfChanged=true stops the service and
 933         # socket and starts the socket
 934         out = switch_to_specialisation("${machine}", "simple-socket-stop-if-changed")
 935         assert_contains(out, "stopping the following units: socket-activated.service, socket-activated.socket\n")
 936         assert_lacks(out, "NOT restarting the following changed units:")
 937         assert_lacks(out, "reloading the following units:")
 938         assert_lacks(out, "\nrestarting the following units:")
 939         assert_contains(out, "\nstarting the following units: socket-activated.socket\n")
 940         assert_lacks(out, "the following new units were started:")
 941         machine.succeed("[ -S /run/test.sock ]")
 942         # Socket-activation of the unit still works
 943         if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
 944             raise Exception("Socket was not properly activated after the service was restarted")
 945
 946         # Changing a reload trigger of a socket-activated unit only reloads it
 947         out = switch_to_specialisation("${machine}", "simple-socket-stop-if-changed-and-reloadtrigger")
 948         assert_lacks(out, "stopping the following units:")
 949         assert_lacks(out, "NOT restarting the following changed units:")
 950         assert_contains(out, "reloading the following units: socket-activated.service\n")
 951         assert_lacks(out, "\nrestarting the following units:")
 952         assert_lacks(out, "\nstarting the following units: socket-activated.socket")
 953         assert_lacks(out, "the following new units were started:")
 954         machine.succeed("[ -S /run/test.sock ]")
 955         # Socket-activation of the unit still works
 956         if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
 957             raise Exception("Socket was not properly activated after the service was restarted")
 958
 959     with subtest("mounts"):
 960         switch_to_specialisation("${machine}", "mount")
 961         out = machine.succeed("mount | grep 'on /testmount'")
 962         assert_contains(out, "size=1024k")
 963         out = switch_to_specialisation("${machine}", "mountModified")
 964         assert_lacks(out, "stopping the following units:")
 965         assert_lacks(out, "NOT restarting the following changed units:")
 966         assert_contains(out, "reloading the following units: testmount.mount\n")
 967         assert_lacks(out, "\nrestarting the following units:")
 968         assert_lacks(out, "\nstarting the following units:")
 969         assert_lacks(out, "the following new units were started:")
 970         # It changed
 971         out = machine.succeed("mount | grep 'on /testmount'")
 972         assert_contains(out, "size=10240k")
 973
 974     with subtest("timers"):
 975         switch_to_specialisation("${machine}", "timer")
 976         out = machine.succeed("systemctl show test-timer.timer")
 977         assert_contains(out, "OnCalendar=2014-03-25 02:59:56 UTC")
 978         out = switch_to_specialisation("${machine}", "timerModified")
 979         assert_lacks(out, "stopping the following units:")
 980         assert_lacks(out, "NOT restarting the following units:")
 981         assert_lacks(out, "reloading the following units:")
 982         assert_contains(out, "\nrestarting the following units: test-timer.timer\n")
 983         assert_lacks(out, "\nstarting the following units:")
 984         assert_lacks(out, "the following new units were started:")
 985         # It changed
 986         out = machine.succeed("systemctl show test-timer.timer")
 987         assert_contains(out, "OnCalendar=Fri 2012-11-23 16:00:00")
 988
 989     with subtest("targets"):
 990         # Modifying some special targets like hybrid-sleep.target does nothing
 991         out = switch_to_specialisation("${machine}", "hybridSleepModified")
 992         assert_contains(out, "stopping the following units: test-timer.timer\n")
 993         assert_lacks(out, "NOT restarting the following changed units:")
 994         assert_lacks(out, "reloading the following units:")
 995         assert_lacks(out, "\nrestarting the following units:")
 996         assert_lacks(out, "\nstarting the following units:")
 997         assert_lacks(out, "the following new units were started:")
 998
 999         # Adding a new target starts it
1000         out = switch_to_specialisation("${machine}", "target")
1001         assert_lacks(out, "stopping the following units:")
1002         assert_lacks(out, "NOT restarting the following changed units:")
1003         assert_lacks(out, "reloading the following units:")
1004         assert_lacks(out, "\nrestarting the following units:")
1005         assert_lacks(out, "\nstarting the following units:")
1006         assert_contains(out, "the following new units were started: test-target.target\n")
1007
1008         # Changing a target doesn't print anything because the unit is filtered
1009         machine.systemctl("start test-service.service")
1010         out = switch_to_specialisation("${machine}", "targetModified")
1011         assert_lacks(out, "stopping the following units:")
1012         assert_lacks(out, "NOT restarting the following changed units:")
1013         assert_lacks(out, "reloading the following units:")
1014         assert_lacks(out, "\nrestarting the following units:")
1015         assert_lacks(out, "\nstarting the following units:")
1016         assert_lacks(out, "the following new units were started:")
1017         machine.succeed("systemctl is-active test-service.service")  # target was not restarted
1018
1019         # With X-StopOnReconfiguration, the target gets stopped and started
1020         out = switch_to_specialisation("${machine}", "targetModifiedStopOnReconfig")
1021         assert_lacks(out, "stopping the following units:")
1022         assert_lacks(out, "NOT restarting the following changed units:")
1023         assert_lacks(out, "reloading the following units:")
1024         assert_lacks(out, "\nrestarting the following units:")
1025         assert_lacks(out, "\nstarting the following units:")
1026         assert_lacks(out, "the following new units were started:")
1027         machine.fail("systemctl is-active test-service.servce")  # target was restarted
1028
1029         # Remove the target by switching to the old specialisation
1030         out = switch_to_specialisation("${machine}", "timerModified")
1031         assert_contains(out, "stopping the following units: test-target.target\n")
1032         assert_lacks(out, "NOT restarting the following changed units:")
1033         assert_lacks(out, "reloading the following units:")
1034         assert_lacks(out, "\nrestarting the following units:")
1035         assert_lacks(out, "\nstarting the following units:")
1036         assert_contains(out, "the following new units were started: test-timer.timer\n")
1037
1038     with subtest("paths"):
1039         out = switch_to_specialisation("${machine}", "path")
1040         assert_contains(out, "stopping the following units: test-timer.timer\n")
1041         assert_lacks(out, "NOT restarting the following changed units:")
1042         assert_lacks(out, "reloading the following units:")
1043         assert_lacks(out, "\nrestarting the following units:")
1044         assert_lacks(out, "\nstarting the following units:")
1045         assert_contains(out, "the following new units were started: test-watch.path\n")
1046         machine.fail("test -f /testpath-modified")
1047
1048         # touch the file, unit should be triggered
1049         machine.succeed("touch /testpath")
1050         machine.wait_until_succeeds("test -f /testpath-modified")
1051         machine.succeed("rm /testpath /testpath-modified")
1052         machine.systemctl("stop test-watch.service")
1053         switch_to_specialisation("${machine}", "pathModified")
1054         machine.succeed("touch /testpath")
1055         machine.fail("test -f /testpath-modified")
1056         machine.succeed("touch /testpath2")
1057         machine.wait_until_succeeds("test -f /testpath-modified")
1058
1059     # This test ensures that changes to slice configuration get applied.
1060     # We test this by having a slice that allows no memory allocation at
1061     # all and starting a service within it. If the service crashes, the slice
1062     # is applied and if we modify the slice to allow memory allocation, the
1063     # service should successfully start.
1064     with subtest("slices"):
1065         machine.succeed("echo 0 > /proc/sys/vm/panic_on_oom")  # allow OOMing
1066         out = switch_to_specialisation("${machine}", "slice")
1067         # assert_lacks(out, "stopping the following units:") not relevant
1068         assert_lacks(out, "NOT restarting the following changed units:")
1069         assert_lacks(out, "reloading the following units:")
1070         assert_lacks(out, "\nrestarting the following units:")
1071         assert_lacks(out, "\nstarting the following units:")
1072         assert_lacks(out, "the following new units were started:")
1073         machine.fail("systemctl start testservice.service")
1074
1075         out = switch_to_specialisation("${machine}", "sliceModified")
1076         assert_lacks(out, "stopping the following units:")
1077         assert_lacks(out, "NOT restarting the following changed units:")
1078         assert_lacks(out, "reloading the following units:")
1079         assert_lacks(out, "\nrestarting the following units:")
1080         assert_lacks(out, "\nstarting the following units:")
1081         assert_lacks(out, "the following new units were started:")
1082         machine.succeed("systemctl start testservice.service")
1083         machine.succeed("echo 1 > /proc/sys/vm/panic_on_oom")  # disallow OOMing
1084   '';
1085 })