nixos/tests/atop.nix

   1 { system ? builtins.currentSystem
   2 , config ? { }
   3 , pkgs ? import ../.. { inherit system config; }
   4 }:
   5
   6 with import ../lib/testing-python.nix { inherit system pkgs; };
   7 with pkgs.lib;
   8
   9 let assertions = rec {
  10   path = program: path: ''
  11     with subtest("The path of ${program} should be ${path}"):
  12         p = machine.succeed("type -p \"${program}\" | head -c -1")
  13         assert p == "${path}", f"${program} is {p}, expected ${path}"
  14   '';
  15   unit = name: state: ''
  16     with subtest("Unit ${name} should be ${state}"):
  17         if "${state}" == "active":
  18             machine.wait_for_unit("${name}")
  19         else:
  20             machine.require_unit_state("${name}", "${state}")
  21   '';
  22   version = ''
  23     import re
  24
  25     with subtest("binary should report the correct version"):
  26         pkgver = "${pkgs.atop.version}"
  27         ver = re.sub(r'(?s)^Version: (\d+\.\d+\.\d+).*', r'\1', machine.succeed("atop -V"))
  28         assert ver == pkgver, f"Version is `{ver}`, expected `{pkgver}`"
  29   '';
  30   atoprc = contents:
  31     if builtins.stringLength contents > 0 then ''
  32       with subtest("/etc/atoprc should have the correct contents"):
  33           f = machine.succeed("cat /etc/atoprc")
  34           assert f == "${contents}", f"/etc/atoprc contents: '{f}', expected '${contents}'"
  35     '' else ''
  36       with subtest("/etc/atoprc should not be present"):
  37           machine.succeed("test ! -e /etc/atoprc")
  38     '';
  39   wrapper = present:
  40     if present then path "atop" "/run/wrappers/bin/atop" + ''
  41       with subtest("Wrapper should be setuid root"):
  42           stat = machine.succeed("stat --printf '%a %u' /run/wrappers/bin/atop")
  43           assert stat == "4511 0", f"Wrapper stat is {stat}, expected '4511 0'"
  44     ''
  45     else path "atop" "/run/current-system/sw/bin/atop";
  46   atopService = present:
  47     if present then
  48       unit "atop.service" "active"
  49       + ''
  50         with subtest("atop.service should write some data to /var/log/atop"):
  51
  52             def has_data_files(last: bool) -> bool:
  53                 files = int(machine.succeed("ls -1 /var/log/atop | wc -l"))
  54                 if files == 0:
  55                     machine.log("Did not find at least one 1 data file")
  56                     if not last:
  57                         machine.log("Will retry...")
  58                     return False
  59                 return True
  60
  61             with machine.nested("Waiting for data files"):
  62                 retry(has_data_files)
  63       '' else unit "atop.service" "inactive";
  64   atopRotateTimer = present:
  65     unit "atop-rotate.timer" (if present then "active" else "inactive");
  66   atopacctService = present:
  67     if present then
  68       unit "atopacct.service" "active"
  69       + ''
  70         with subtest("atopacct.service should enable process accounting"):
  71             machine.wait_until_succeeds("test -f /run/pacct_source")
  72
  73         with subtest("atopacct.service should write data to /run/pacct_shadow.d"):
  74
  75             def has_data_files(last: bool) -> bool:
  76                 files = int(machine.succeed("ls -1 /run/pacct_shadow.d | wc -l"))
  77                 if files == 0:
  78                     machine.log("Did not find at least one 1 data file")
  79                     if not last:
  80                         machine.log("Will retry...")
  81                     return False
  82                 return True
  83
  84             with machine.nested("Waiting for data files"):
  85                 retry(has_data_files)
  86       '' else unit "atopacct.service" "inactive";
  87   netatop = present:
  88     if present then
  89       unit "netatop.service" "active"
  90       + ''
  91         with subtest("The netatop kernel module should be loaded"):
  92             out = machine.succeed("modprobe -n -v netatop")
  93             assert out == "", f"Module should be loaded already, but modprobe would have done {out}."
  94       '' else ''
  95       with subtest("The netatop kernel module should be absent"):
  96           machine.fail("modprobe -n -v netatop")
  97     '';
  98   atopgpu = present:
  99     if present then
 100       (unit "atopgpu.service" "active") + (path "atopgpud" "/run/current-system/sw/bin/atopgpud")
 101     else (unit "atopgpu.service" "inactive") + ''
 102       with subtest("atopgpud should not be present"):
 103           machine.fail("type -p atopgpud")
 104     '';
 105 };
 106 meta = {
 107   timeout = 600;
 108 };
 109 in
 110 {
 111   justThePackage = makeTest {
 112     name = "atop-justThePackage";
 113     nodes.machine = {
 114       environment.systemPackages = [ pkgs.atop ];
 115     };
 116     testScript = with assertions; builtins.concatStringsSep "\n" [
 117       version
 118       (atoprc "")
 119       (wrapper false)
 120       (atopService false)
 121       (atopRotateTimer false)
 122       (atopacctService false)
 123       (netatop false)
 124       (atopgpu false)
 125     ];
 126     inherit meta;
 127   };
 128   defaults = makeTest {
 129     name = "atop-defaults";
 130     nodes.machine = {
 131       programs.atop = {
 132         enable = true;
 133       };
 134     };
 135     testScript = with assertions; builtins.concatStringsSep "\n" [
 136       version
 137       (atoprc "")
 138       (wrapper false)
 139       (atopService true)
 140       (atopRotateTimer true)
 141       (atopacctService true)
 142       (netatop false)
 143       (atopgpu false)
 144     ];
 145     inherit meta;
 146   };
 147   minimal = makeTest {
 148     name = "atop-minimal";
 149     nodes.machine = {
 150       programs.atop = {
 151         enable = true;
 152         atopService.enable = false;
 153         atopRotateTimer.enable = false;
 154         atopacctService.enable = false;
 155       };
 156     };
 157     testScript = with assertions; builtins.concatStringsSep "\n" [
 158       version
 159       (atoprc "")
 160       (wrapper false)
 161       (atopService false)
 162       (atopRotateTimer false)
 163       (atopacctService false)
 164       (netatop false)
 165       (atopgpu false)
 166     ];
 167     inherit meta;
 168   };
 169   netatop = makeTest {
 170     name = "atop-netatop";
 171     nodes.machine = {
 172       programs.atop = {
 173         enable = true;
 174         netatop.enable = true;
 175       };
 176     };
 177     testScript = with assertions; builtins.concatStringsSep "\n" [
 178       version
 179       (atoprc "")
 180       (wrapper false)
 181       (atopService true)
 182       (atopRotateTimer true)
 183       (atopacctService true)
 184       (netatop true)
 185       (atopgpu false)
 186     ];
 187     inherit meta;
 188   };
 189   atopgpu = makeTest {
 190     name = "atop-atopgpu";
 191     nodes.machine = {
 192       programs.atop = {
 193         enable = true;
 194         atopgpu.enable = true;
 195       };
 196     };
 197     testScript = with assertions; builtins.concatStringsSep "\n" [
 198       version
 199       (atoprc "")
 200       (wrapper false)
 201       (atopService true)
 202       (atopRotateTimer true)
 203       (atopacctService true)
 204       (netatop false)
 205       (atopgpu true)
 206     ];
 207     inherit meta;
 208   };
 209   everything = makeTest {
 210     name = "atop-everything";
 211     nodes.machine = {
 212       programs.atop = {
 213         enable = true;
 214         settings = {
 215           flags = "faf1";
 216           interval = 2;
 217         };
 218         setuidWrapper.enable = true;
 219         netatop.enable = true;
 220         atopgpu.enable = true;
 221       };
 222     };
 223     testScript = with assertions; builtins.concatStringsSep "\n" [
 224       version
 225       (atoprc "flags faf1\\ninterval 2\\n")
 226       (wrapper true)
 227       (atopService true)
 228       (atopRotateTimer true)
 229       (atopacctService true)
 230       (netatop true)
 231       (atopgpu true)
 232     ];
 233     inherit meta;
 234   };
 235 }