commit b3de22483cfd40e52dbe6fe7317b0f4901bd957d · pyrox.dev/nixpkgs

+20

nixos/lib/testing-python.nix

···

       166
       166
        
                 ${lib.optionalString (interactive) "--add-flags --interactive"}

     

       167
       167
        
             '');

     

       168
       168
        
       

     

       169
       169
       +
         evalTest = module: lib.evalModules { modules = testModules ++ [ module ]; };

     

       170
       170
       +
         runTest = module: (evalTest module).config.run;

     

       171
       171
       +
       

     

       172
       172
       +
         testModules = [

     

       173
       173
       +
           ./testing/driver.nix

     

       174
       174
       +
           ./testing/interactive.nix

     

       175
       175
       +
           ./testing/legacy.nix

     

       176
       176
       +
           ./testing/meta.nix

     

       177
       177
       +
           ./testing/name.nix

     

       178
       178
       +
           ./testing/network.nix

     

       179
       179
       +
           ./testing/nodes.nix

     

       180
       180
       +
           ./testing/run.nix

     

       181
       181
       +
           ./testing/testScript.nix

     

       182
       182
       +
           {

     

       183
       183
       +
             config = {

     

       184
       184
       +
               hostPkgs = pkgs;

     

       185
       185
       +
             };

     

       186
       186
       +
           }

     

       187
       187
       +
         ];

     

       188
       188
       +
       

     

       169
       189
        
         # Make a full-blown test

     

       170
       190
        
         makeTest =

     

       171
       191
        
           { machine ? null

+16

nixos/lib/testing/call-test.nix

···

       1
       1
       +
       { config, lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           callTest = mkOption {

     

       8
       8
       +
             internal = true;

     

       9
       9
       +
             type = types.functionTo types.raw;

     

       10
       10
       +
           };

     

       11
       11
       +
           result = mkOption {

     

       12
       12
       +
             internal = true;

     

       13
       13
       +
             default = config;

     

       14
       14
       +
           };

     

       15
       15
       +
         };

     

       16
       16
       +
       }

+177

nixos/lib/testing/driver.nix

···

       1
       1
       +
       { config, lib, hostPkgs, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       

     

       5
       5
       +
         # Reifies and correctly wraps the python test driver for

     

       6
       6
       +
         # the respective qemu version and with or without ocr support

     

       7
       7
       +
         testDriver = hostPkgs.callPackage ../test-driver {

     

       8
       8
       +
           inherit (config) enableOCR extraPythonPackages;

     

       9
       9
       +
           qemu_pkg = config.qemu.package;

     

       10
       10
       +
           imagemagick_light = hostPkgs.imagemagick_light.override { inherit (hostPkgs) libtiff; };

     

       11
       11
       +
           tesseract4 = hostPkgs.tesseract4.override { enableLanguages = [ "eng" ]; };

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
       

     

       15
       15
       +
         vlans = map (m: m.virtualisation.vlans) (lib.attrValues config.nodes);

     

       16
       16
       +
         vms = map (m: m.system.build.vm) (lib.attrValues config.nodes);

     

       17
       17
       +
       

     

       18
       18
       +
         nodeHostNames =

     

       19
       19
       +
           let

     

       20
       20
       +
             nodesList = map (c: c.system.name) (lib.attrValues config.nodes);

     

       21
       21
       +
           in

     

       22
       22
       +
           nodesList ++ lib.optional (lib.length nodesList == 1 && !lib.elem "machine" nodesList) "machine";

     

       23
       23
       +
       

     

       24
       24
       +
         # TODO: This is an implementation error and needs fixing

     

       25
       25
       +
         # the testing famework cannot legitimately restrict hostnames further

     

       26
       26
       +
         # beyond RFC1035

     

       27
       27
       +
         invalidNodeNames = lib.filter

     

       28
       28
       +
           (node: builtins.match "^[A-z_]([A-z0-9_]+)?$" node == null)

     

       29
       29
       +
           nodeHostNames;

     

       30
       30
       +
       

     

       31
       31
       +
         uniqueVlans = lib.unique (builtins.concatLists vlans);

     

       32
       32
       +
         vlanNames = map (i: "vlan${toString i}: VLan;") uniqueVlans;

     

       33
       33
       +
         machineNames = map (name: "${name}: Machine;") nodeHostNames;

     

       34
       34
       +
       

     

       35
       35
       +
         withChecks =

     

       36
       36
       +
           if lib.length invalidNodeNames > 0 then

     

       37
       37
       +
             throw ''

     

       38
       38
       +
               Cannot create machines out of (${lib.concatStringsSep ", " invalidNodeNames})!

     

       39
       39
       +
               All machines are referenced as python variables in the testing framework which will break the

     

       40
       40
       +
               script when special characters are used.

     

       41
       41
       +
       

     

       42
       42
       +
               This is an IMPLEMENTATION ERROR and needs to be fixed. Meanwhile,

     

       43
       43
       +
               please stick to alphanumeric chars and underscores as separation.

     

       44
       44
       +
             ''

     

       45
       45
       +
           else

     

       46
       46
       +
             lib.warnIf config.skipLint "Linting is disabled";

     

       47
       47
       +
       

     

       48
       48
       +
         driver =

     

       49
       49
       +
           hostPkgs.runCommand "nixos-test-driver-${config.name}"

     

       50
       50
       +
             {

     

       51
       51
       +
               # inherit testName; TODO (roberth): need this?

     

       52
       52
       +
               nativeBuildInputs = [

     

       53
       53
       +
                 hostPkgs.makeWrapper

     

       54
       54
       +
               ] ++ lib.optionals (!config.skipTypeCheck) [ hostPkgs.mypy ];

     

       55
       55
       +
               testScript = config.testScriptString;

     

       56
       56
       +
               preferLocalBuild = true;

     

       57
       57
       +
               passthru = config.passthru;

     

       58
       58
       +
               meta = config.meta // {

     

       59
       59
       +
                 mainProgram = "nixos-test-driver";

     

       60
       60
       +
               };

     

       61
       61
       +
             }

     

       62
       62
       +
             ''

     

       63
       63
       +
               mkdir -p $out/bin

     

       64
       64
       +
       

     

       65
       65
       +
               vmStartScripts=($(for i in ${toString vms}; do echo $i/bin/run-*-vm; done))

     

       66
       66
       +
       

     

       67
       67
       +
               ${lib.optionalString (!config.skipTypeCheck) ''

     

       68
       68
       +
                 # prepend type hints so the test script can be type checked with mypy

     

       69
       69
       +
                 cat "${../test-script-prepend.py}" >> testScriptWithTypes

     

       70
       70
       +
                 echo "${builtins.toString machineNames}" >> testScriptWithTypes

     

       71
       71
       +
                 echo "${builtins.toString vlanNames}" >> testScriptWithTypes

     

       72
       72
       +
                 echo -n "$testScript" >> testScriptWithTypes

     

       73
       73
       +
       

     

       74
       74
       +
                 cat -n testScriptWithTypes

     

       75
       75
       +
       

     

       76
       76
       +
                 # set pythonpath so mypy knows where to find the imports. this requires the py.typed file.

     

       77
       77
       +
                 export PYTHONPATH='${../test-driver}'

     

       78
       78
       +
                 mypy  --no-implicit-optional \

     

       79
       79
       +
                       --pretty \

     

       80
       80
       +
                       --no-color-output \

     

       81
       81
       +
                       testScriptWithTypes

     

       82
       82
       +
                 unset PYTHONPATH

     

       83
       83
       +
               ''}

     

       84
       84
       +
       

     

       85
       85
       +
               echo -n "$testScript" >> $out/test-script

     

       86
       86
       +
       

     

       87
       87
       +
               ln -s ${testDriver}/bin/nixos-test-driver $out/bin/nixos-test-driver

     

       88
       88
       +
       

     

       89
       89
       +
               ${testDriver}/bin/generate-driver-symbols

     

       90
       90
       +
               ${lib.optionalString (!config.skipLint) ''

     

       91
       91
       +
                 PYFLAKES_BUILTINS="$(

     

       92
       92
       +
                   echo -n ${lib.escapeShellArg (lib.concatStringsSep "," nodeHostNames)},

     

       93
       93
       +
                   < ${lib.escapeShellArg "driver-symbols"}

     

       94
       94
       +
                 )" ${hostPkgs.python3Packages.pyflakes}/bin/pyflakes $out/test-script

     

       95
       95
       +
               ''}

     

       96
       96
       +
       

     

       97
       97
       +
               # set defaults through environment

     

       98
       98
       +
               # see: ./test-driver/test-driver.py argparse implementation

     

       99
       99
       +
               wrapProgram $out/bin/nixos-test-driver \

     

       100
       100
       +
                 --set startScripts "''${vmStartScripts[*]}" \

     

       101
       101
       +
                 --set testScript "$out/test-script" \

     

       102
       102
       +
                 --set vlans '${toString vlans}' \

     

       103
       103
       +
                 ${lib.escapeShellArgs (lib.concatMap (arg: ["--add-flags" arg]) config.extraDriverArgs)}

     

       104
       104
       +
             '';

     

       105
       105
       +
       

     

       106
       106
       +
       in

     

       107
       107
       +
       {

     

       108
       108
       +
         options = {

     

       109
       109
       +
       

     

       110
       110
       +
           driver = mkOption {

     

       111
       111
       +
             description = "Script that runs the test.";

     

       112
       112
       +
             type = types.package;

     

       113
       113
       +
             defaultText = lib.literalDocBook "set by the test framework";

     

       114
       114
       +
           };

     

       115
       115
       +
       

     

       116
       116
       +
           hostPkgs = mkOption {

     

       117
       117
       +
             description = "Nixpkgs attrset used outside the nodes.";

     

       118
       118
       +
             type = types.raw;

     

       119
       119
       +
             example = lib.literalExpression ''

     

       120
       120
       +
               import nixpkgs { inherit system config overlays; }

     

       121
       121
       +
             '';

     

       122
       122
       +
           };

     

       123
       123
       +
       

     

       124
       124
       +
           qemu.package = mkOption {

     

       125
       125
       +
             description = "Which qemu package to use.";

     

       126
       126
       +
             type = types.package;

     

       127
       127
       +
             default = hostPkgs.qemu_test;

     

       128
       128
       +
             defaultText = "hostPkgs.qemu_test";

     

       129
       129
       +
           };

     

       130
       130
       +
       

     

       131
       131
       +
           enableOCR = mkOption {

     

       132
       132
       +
             description = ''

     

       133
       133
       +
               Whether to enable Optical Character Recognition functionality for

     

       134
       134
       +
               testing graphical programs.

     

       135
       135
       +
             '';

     

       136
       136
       +
             type = types.bool;

     

       137
       137
       +
             default = false;

     

       138
       138
       +
           };

     

       139
       139
       +
       

     

       140
       140
       +
           extraPythonPackages = mkOption {

     

       141
       141
       +
             description = ''

     

       142
       142
       +
               Python packages to add to the test driver.

     

       143
       143
       +
       

     

       144
       144
       +
               The argument is a Python package set, similar to `pkgs.pythonPackages`.

     

       145
       145
       +
             '';

     

       146
       146
       +
             type = types.functionTo (types.listOf types.package);

     

       147
       147
       +
             default = ps: [ ];

     

       148
       148
       +
           };

     

       149
       149
       +
       

     

       150
       150
       +
           extraDriverArgs = mkOption {

     

       151
       151
       +
             description = ''

     

       152
       152
       +
               Extra arguments to pass to the test driver.

     

       153
       153
       +
             '';

     

       154
       154
       +
             type = types.listOf types.str;

     

       155
       155
       +
             default = [];

     

       156
       156
       +
           };

     

       157
       157
       +
       

     

       158
       158
       +
           skipLint = mkOption {

     

       159
       159
       +
             type = types.bool;

     

       160
       160
       +
             default = false;

     

       161
       161
       +
           };

     

       162
       162
       +
       

     

       163
       163
       +
           skipTypeCheck = mkOption {

     

       164
       164
       +
             type = types.bool;

     

       165
       165
       +
             default = false;

     

       166
       166
       +
           };

     

       167
       167
       +
         };

     

       168
       168
       +
       

     

       169
       169
       +
         config = {

     

       170
       170
       +
           _module.args.hostPkgs = config.hostPkgs;

     

       171
       171
       +
       

     

       172
       172
       +
           driver = withChecks driver;

     

       173
       173
       +
       

     

       174
       174
       +
           # make available on the test runner

     

       175
       175
       +
           passthru.driver = config.driver;

     

       176
       176
       +
         };

     

       177
       177
       +
       }

+18

nixos/lib/testing/interactive.nix

···

       1
       1
       +
       { config, lib, moduleType, hostPkgs, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           interactive = mkOption {

     

       8
       8
       +
             description = "All the same options, but configured for interactive use.";

     

       9
       9
       +
             type = moduleType;

     

       10
       10
       +
           };

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         config = {

     

       14
       14
       +
           interactive.qemu.package = hostPkgs.qemu;

     

       15
       15
       +
           interactive.extraDriverArgs = [ "--interactive" ];

     

       16
       16
       +
           passthru.driverInteractive = config.interactive.driver;

     

       17
       17
       +
         };

     

       18
       18
       +
       }

+25

nixos/lib/testing/legacy.nix

···

       1
       1
       +
       { config, options, lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkIf mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         # This needs options.warnings, which we don't have (yet?).

     

       7
       7
       +
         # imports = [

     

       8
       8
       +
         #   (lib.mkRenamedOptionModule [ "machine" ] [ "nodes" "machine" ])

     

       9
       9
       +
         # ];

     

       10
       10
       +
       

     

       11
       11
       +
         options = {

     

       12
       12
       +
           machine = mkOption {

     

       13
       13
       +
             internal = true;

     

       14
       14
       +
             type = types.raw;

     

       15
       15
       +
           };

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         config = {

     

       19
       19
       +
           nodes = mkIf options.machine.isDefined (

     

       20
       20
       +
             lib.warn

     

       21
       21
       +
               "In test `${config.name}': The `machine' attribute in NixOS tests (pkgs.nixosTest / make-test-python.nix / testing-python.nix / makeTest) is deprecated. Please set the equivalent `nodes.machine'."

     

       22
       22
       +
               { inherit (config) machine; }

     

       23
       23
       +
           );

     

       24
       24
       +
         };

     

       25
       25
       +
       }

+12

nixos/lib/testing/meta.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           meta.maintainers = lib.mkOption {

     

       8
       8
       +
             type = types.listOf types.raw;

     

       9
       9
       +
             default = [];

     

       10
       10
       +
           };

     

       11
       11
       +
         };

     

       12
       12
       +
       }

nixos/lib/testing/name.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       {

     

       3
       3
       +
         options.name = lib.mkOption {

     

       4
       4
       +
           description = "The name of the test.";

     

       5
       5
       +
           type = lib.types.str;

     

       6
       6
       +
         };

     

       7
       7
       +
       }

+75

nixos/lib/testing/network.nix

···

       1
       1
       +
       { lib, nodes, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       

     

       6
       6
       +
       let

     

       7
       7
       +
         machines = attrNames nodes;

     

       8
       8
       +
       

     

       9
       9
       +
         machinesNumbered = zipLists machines (range 1 254);

     

       10
       10
       +
       

     

       11
       11
       +
         nodes_ = forEach machinesNumbered (m: nameValuePair m.fst

     

       12
       12
       +
           [

     

       13
       13
       +
             ({ config, nodes, pkgs, ... }:

     

       14
       14
       +
               let

     

       15
       15
       +
                 interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);

     

       16
       16
       +
                 interfaces = forEach interfacesNumbered ({ fst, snd }:

     

       17
       17
       +
                   nameValuePair "eth${toString snd}" {

     

       18
       18
       +
                     ipv4.addresses =

     

       19
       19
       +
                       [{

     

       20
       20
       +
                         address = "192.168.${toString fst}.${toString m.snd}";

     

       21
       21
       +
                         prefixLength = 24;

     

       22
       22
       +
                       }];

     

       23
       23
       +
                   });

     

       24
       24
       +
       

     

       25
       25
       +
                 networkConfig =

     

       26
       26
       +
                   {

     

       27
       27
       +
                     networking.hostName = mkDefault m.fst;

     

       28
       28
       +
       

     

       29
       29
       +
                     networking.interfaces = listToAttrs interfaces;

     

       30
       30
       +
       

     

       31
       31
       +
                     networking.primaryIPAddress =

     

       32
       32
       +
                       optionalString (interfaces != [ ]) (head (head interfaces).value.ipv4.addresses).address;

     

       33
       33
       +
       

     

       34
       34
       +
                     # Put the IP addresses of all VMs in this machine's

     

       35
       35
       +
                     # /etc/hosts file.  If a machine has multiple

     

       36
       36
       +
                     # interfaces, use the IP address corresponding to

     

       37
       37
       +
                     # the first interface (i.e. the first network in its

     

       38
       38
       +
                     # virtualisation.vlans option).

     

       39
       39
       +
                     networking.extraHosts = flip concatMapStrings machines

     

       40
       40
       +
                       (m':

     

       41
       41
       +
                         let config = (getAttr m' nodes).config; in

     

       42
       42
       +
                         optionalString (config.networking.primaryIPAddress != "")

     

       43
       43
       +
                           ("${config.networking.primaryIPAddress} " +

     

       44
       44
       +
                             optionalString (config.networking.domain != null)

     

       45
       45
       +
                               "${config.networking.hostName}.${config.networking.domain} " +

     

       46
       46
       +
                             "${config.networking.hostName}\n"));

     

       47
       47
       +
       

     

       48
       48
       +
                     virtualisation.qemu.options =

     

       49
       49
       +
                       let qemu-common = import ../qemu-common.nix { inherit lib pkgs; };

     

       50
       50
       +
                       in

     

       51
       51
       +
                       flip concatMap interfacesNumbered

     

       52
       52
       +
                         ({ fst, snd }: qemu-common.qemuNICFlags snd fst m.snd);

     

       53
       53
       +
                   };

     

       54
       54
       +
       

     

       55
       55
       +
               in

     

       56
       56
       +
               {

     

       57
       57
       +
                 key = "ip-address";

     

       58
       58
       +
                 config = networkConfig // {

     

       59
       59
       +
                   # Expose the networkConfig items for tests like nixops

     

       60
       60
       +
                   # that need to recreate the network config.

     

       61
       61
       +
                   system.build.networkConfig = networkConfig;

     

       62
       62
       +
                 };

     

       63
       63
       +
               }

     

       64
       64
       +
             )

     

       65
       65
       +
           ]);

     

       66
       66
       +
       

     

       67
       67
       +
         extraNodeConfigs = lib.listToAttrs nodes_;

     

       68
       68
       +
       in

     

       69
       69
       +
       {

     

       70
       70
       +
         config = {

     

       71
       71
       +
           defaults = { config, name, ... }: {

     

       72
       72
       +
             imports = extraNodeConfigs.${name};

     

       73
       73
       +
           };

     

       74
       74
       +
         };

     

       75
       75
       +
       }

+91

nixos/lib/testing/nodes.nix

···

       1
       1
       +
       testModuleArgs@{ config, lib, hostPkgs, nodes, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (lib) mkOption mkForce optional types mapAttrs mkDefault;

     

       5
       5
       +
       

     

       6
       6
       +
         system = hostPkgs.stdenv.hostPlatform.system;

     

       7
       7
       +
       

     

       8
       8
       +
         baseOS =

     

       9
       9
       +
           import ../eval-config.nix {

     

       10
       10
       +
             inherit system;

     

       11
       11
       +
             inherit (config.node) specialArgs;

     

       12
       12
       +
             modules = [ config.defaults ];

     

       13
       13
       +
             baseModules = (import ../../modules/module-list.nix) ++

     

       14
       14
       +
               [

     

       15
       15
       +
                 ../../modules/virtualisation/qemu-vm.nix

     

       16
       16
       +
                 ../../modules/testing/test-instrumentation.nix # !!! should only get added for automated test runs

     

       17
       17
       +
                 { key = "no-manual"; documentation.nixos.enable = false; }

     

       18
       18
       +
                 {

     

       19
       19
       +
                   key = "no-revision";

     

       20
       20
       +
                   # Make the revision metadata constant, in order to avoid needless retesting.

     

       21
       21
       +
                   # The human version (e.g. 21.05-pre) is left as is, because it is useful

     

       22
       22
       +
                   # for external modules that test with e.g. testers.nixosTest and rely on that

     

       23
       23
       +
                   # version number.

     

       24
       24
       +
                   config.system.nixos.revision = mkForce "constant-nixos-revision";

     

       25
       25
       +
                 }

     

       26
       26
       +
                 { key = "nodes"; _module.args.nodes = nodes; }

     

       27
       27
       +
       

     

       28
       28
       +
                 ({ config, ... }:

     

       29
       29
       +
                   {

     

       30
       30
       +
                     virtualisation.qemu.package = testModuleArgs.config.qemu.package;

     

       31
       31
       +
       

     

       32
       32
       +
                     # Ensure we do not use aliases. Ideally this is only set

     

       33
       33
       +
                     # when the test framework is used by Nixpkgs NixOS tests.

     

       34
       34
       +
                     nixpkgs.config.allowAliases = false;

     

       35
       35
       +
                   })

     

       36
       36
       +
               ] ++ optional config.minimal ../../modules/testing/minimal-kernel.nix;

     

       37
       37
       +
           };

     

       38
       38
       +
       

     

       39
       39
       +
       

     

       40
       40
       +
       in

     

       41
       41
       +
       

     

       42
       42
       +
       {

     

       43
       43
       +
       

     

       44
       44
       +
         options = {

     

       45
       45
       +
           node.type = mkOption {

     

       46
       46
       +
             type = types.raw;

     

       47
       47
       +
             default = baseOS.type;

     

       48
       48
       +
             internal = true;

     

       49
       49
       +
           };

     

       50
       50
       +
       

     

       51
       51
       +
           nodes = mkOption {

     

       52
       52
       +
             type = types.lazyAttrsOf config.node.type;

     

       53
       53
       +
           };

     

       54
       54
       +
       

     

       55
       55
       +
           defaults = mkOption {

     

       56
       56
       +
             description = ''

     

       57
       57
       +
               NixOS configuration that is applied to all {option}`nodes`.

     

       58
       58
       +
             '';

     

       59
       59
       +
             type = types.deferredModule;

     

       60
       60
       +
             default = { };

     

       61
       61
       +
           };

     

       62
       62
       +
       

     

       63
       63
       +
           node.specialArgs = mkOption {

     

       64
       64
       +
             type = types.lazyAttrsOf types.raw;

     

       65
       65
       +
             default = { };

     

       66
       66
       +
           };

     

       67
       67
       +
       

     

       68
       68
       +
           minimal = mkOption {

     

       69
       69
       +
             type = types.bool;

     

       70
       70
       +
             default = false;

     

       71
       71
       +
           };

     

       72
       72
       +
       

     

       73
       73
       +
           nodesCompat = mkOption {

     

       74
       74
       +
             internal = true;

     

       75
       75
       +
           };

     

       76
       76
       +
         };

     

       77
       77
       +
       

     

       78
       78
       +
         config = {

     

       79
       79
       +
           _module.args.nodes = config.nodesCompat;

     

       80
       80
       +
           nodesCompat =

     

       81
       81
       +
             mapAttrs

     

       82
       82
       +
               (name: config: config // {

     

       83
       83
       +
                 config = lib.warn

     

       84
       84
       +
                   "Module argument `nodes.${name}.config` is deprecated. Use `nodes.${name}` instead."

     

       85
       85
       +
                   config;

     

       86
       86
       +
               })

     

       87
       87
       +
               config.nodes;

     

       88
       88
       +
       

     

       89
       89
       +
           passthru.nodes = config.nodesCompat;

     

       90
       90
       +
         };

     

       91
       91
       +
       }

+51

nixos/lib/testing/run.nix

···

       1
       1
       +
       { config, hostPkgs, lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           passthru = mkOption {

     

       8
       8
       +
             type = types.lazyAttrsOf types.raw;

     

       9
       9
       +
             description = ''

     

       10
       10
       +
               Attributes to add to the returned derivations,

     

       11
       11
       +
               which are not necessarily part of the build.

     

       12
       12
       +
       

     

       13
       13
       +
               This is a bit like doing `drv // { myAttr = true; }` (which would be lost by `overrideAttrs`).

     

       14
       14
       +
               It does not change the actual derivation, but adds the attribute nonetheless, so that

     

       15
       15
       +
               consumers of what would be `drv` have more information.

     

       16
       16
       +
             '';

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           run = mkOption {

     

       20
       20
       +
             type = types.package;

     

       21
       21
       +
             description = ''

     

       22
       22
       +
               Derivation that runs the test.

     

       23
       23
       +
             '';

     

       24
       24
       +
           };

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         config = {

     

       28
       28
       +
           run = hostPkgs.stdenv.mkDerivation {

     

       29
       29
       +
             name = "vm-test-run-${config.name}";

     

       30
       30
       +
       

     

       31
       31
       +
             requiredSystemFeatures = [ "kvm" "nixos-test" ];

     

       32
       32
       +
       

     

       33
       33
       +
             buildCommand =

     

       34
       34
       +
               ''

     

       35
       35
       +
                 mkdir -p $out

     

       36
       36
       +
       

     

       37
       37
       +
                 # effectively mute the XMLLogger

     

       38
       38
       +
                 export LOGFILE=/dev/null

     

       39
       39
       +
       

     

       40
       40
       +
                 ${config.driver}/bin/nixos-test-driver -o $out

     

       41
       41
       +
               '';

     

       42
       42
       +
       

     

       43
       43
       +
             passthru = config.passthru;

     

       44
       44
       +
       

     

       45
       45
       +
             meta = config.meta;

     

       46
       46
       +
           };

     

       47
       47
       +
       

     

       48
       48
       +
           # useful for inspection (debugging / exploration)

     

       49
       49
       +
           passthru.config = config;

     

       50
       50
       +
         };

     

       51
       51
       +
       }

+78

nixos/lib/testing/testScript.nix

···

       1
       1
       +
       testModuleArgs@{ config, lib, hostPkgs, nodes, moduleType, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
         inherit (types) either str functionTo;

     

       5
       5
       +
       in

     

       6
       6
       +
       {

     

       7
       7
       +
         options = {

     

       8
       8
       +
           testScript = mkOption {

     

       9
       9
       +
             type = either str (functionTo str);

     

       10
       10
       +
           };

     

       11
       11
       +
           testScriptString = mkOption {

     

       12
       12
       +
             type = str;

     

       13
       13
       +
             readOnly = true;

     

       14
       14
       +
             internal = true;

     

       15
       15
       +
           };

     

       16
       16
       +
       

     

       17
       17
       +
           includeTestScriptReferences = mkOption {

     

       18
       18
       +
             type = types.bool;

     

       19
       19
       +
             default = true;

     

       20
       20
       +
             internal = true;

     

       21
       21
       +
           };

     

       22
       22
       +
           withoutTestScriptReferences = mkOption {

     

       23
       23
       +
             type = moduleType;

     

       24
       24
       +
             description = ''

     

       25
       25
       +
               A parallel universe where the testScript is invalid and has no references.

     

       26
       26
       +
             '';

     

       27
       27
       +
           };

     

       28
       28
       +
         };

     

       29
       29
       +
         config = {

     

       30
       30
       +
           withoutTestScriptReferences.includeTestScriptReferences = false;

     

       31
       31
       +
           withoutTestScriptReferences.testScript = lib.mkForce "testscript omitted";

     

       32
       32
       +
       

     

       33
       33
       +
           testScriptString =

     

       34
       34
       +
             if lib.isFunction config.testScript

     

       35
       35
       +
             then

     

       36
       36
       +
               config.testScript

     

       37
       37
       +
                 {

     

       38
       38
       +
                   nodes =

     

       39
       39
       +
                     lib.mapAttrs

     

       40
       40
       +
                       (k: v:

     

       41
       41
       +
                         if v.virtualisation.useNixStoreImage

     

       42
       42
       +
                         then

     

       43
       43
       +
                         # prevent infinite recursion when testScript would

     

       44
       44
       +
                         # reference v's toplevel

     

       45
       45
       +
                           config.withoutTestScriptReferences.nodesCompat.${k}

     

       46
       46
       +
                         else

     

       47
       47
       +
                         # reuse memoized config

     

       48
       48
       +
                           v

     

       49
       49
       +
                       )

     

       50
       50
       +
                       config.nodesCompat;

     

       51
       51
       +
                 }

     

       52
       52
       +
             else config.testScript;

     

       53
       53
       +
       

     

       54
       54
       +
           defaults = { config, name, ... }: {

     

       55
       55
       +
             # Make sure all derivations referenced by the test

     

       56
       56
       +
             # script are available on the nodes. When the store is

     

       57
       57
       +
             # accessed through 9p, this isn't important, since

     

       58
       58
       +
             # everything in the store is available to the guest,

     

       59
       59
       +
             # but when building a root image it is, as all paths

     

       60
       60
       +
             # that should be available to the guest has to be

     

       61
       61
       +
             # copied to the image.

     

       62
       62
       +
             virtualisation.additionalPaths =

     

       63
       63
       +
               lib.optional

     

       64
       64
       +
                 # A testScript may evaluate nodes, which has caused

     

       65
       65
       +
                 # infinite recursions. The demand cycle involves:

     

       66
       66
       +
                 #   testScript -->

     

       67
       67
       +
                 #   nodes -->

     

       68
       68
       +
                 #   toplevel -->

     

       69
       69
       +
                 #   additionalPaths -->

     

       70
       70
       +
                 #   hasContext testScript' -->

     

       71
       71
       +
                 #   testScript (ad infinitum)

     

       72
       72
       +
                 # If we don't need to build an image, we can break this

     

       73
       73
       +
                 # cycle by short-circuiting when useNixStoreImage is false.

     

       74
       74
       +
                 (config.virtualisation.useNixStoreImage && builtins.hasContext testModuleArgs.config.testScriptString && testModuleArgs.config.includeTestScriptReferences)

     

       75
       75
       +
                 (hostPkgs.writeStringReferencesToFile testModuleArgs.config.testScriptString);

     

       76
       76
       +
           };

     

       77
       77
       +
         };

     

       78
       78
       +
       }