commit 7f0d934f9aa50d69336aec32fc90dada6d2d4459 · pyrox.dev/nixpkgs

doc/stdenv/meta.chapter.md

···

       213
       213
        
       

     

       214
       214
        
       A timeout (in seconds) for building the derivation. If the derivation takes longer than this time to build, it can fail due to breaking the timeout. However, all computers do not have the same computing power, hence some builders may decide to apply a multiplicative factor to this value. When filling this value in, try to keep it approximately consistent with other values already present in `nixpkgs`.

     

       215
       215
        
       

     

       216
       216
       +
       `meta` attributes are not stored in the instantiated derivation.

     

       217
       217
       +
       Therefore, this setting may be lost when the package is used as a dependency.

     

       218
       218
       +
       To be effective, it must be presented directly to an evaluation process that handles the `meta.timeout` attribute.

     

       219
       219
       +
       

     

       216
       220
        
       ### `hydraPlatforms` {#var-meta-hydraPlatforms}

     

       217
       221
        
       

     

       218
       222
        
       The list of Nix platform types for which the Hydra instance at `hydra.nixos.org` will build the package. (Hydra is the Nix-based continuous build system.) It defaults to the value of `meta.platforms`. Thus, the only reason to set `meta.hydraPlatforms` is if you want `hydra.nixos.org` to build the package on a subset of `meta.platforms`, or not at all, e.g.

lib/default.nix

···

       23
       23
        
       

     

       24
       24
        
           # packaging

     

       25
       25
        
           customisation = callLibs ./customisation.nix;

     

       26
       26
       +
           derivations = callLibs ./derivations.nix;

     

       26
       27
        
           maintainers = import ../maintainers/maintainer-list.nix;

     

       27
       28
        
           teams = callLibs ../maintainers/team-list.nix;

     

       28
       29
        
           meta = callLibs ./meta.nix;

     
···

       108
       109
        
           inherit (self.customisation) overrideDerivation makeOverridable

     

       109
       110
        
             callPackageWith callPackagesWith extendDerivation hydraJob

     

       110
       111
        
             makeScope makeScopeWithSplicing;

     

       112
       112
       +
           inherit (self.derivations) lazyDerivation;

     

       111
       113
        
           inherit (self.meta) addMetaAttrs dontDistribute setName updateName

     

       112
       114
        
             appendToName mapDerivationAttrset setPrio lowPrio lowPrioSet hiPrio

     

       113
       115
        
             hiPrioSet getLicenseFromSpdxId getExe;

+101

lib/derivations.nix

···

       1
       1
       +
       { lib }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (lib) throwIfNot;

     

       5
       5
       +
       in

     

       6
       6
       +
       {

     

       7
       7
       +
         /*

     

       8
       8
       +
           Restrict a derivation to a predictable set of attribute names, so

     

       9
       9
       +
           that the returned attrset is not strict in the actual derivation,

     

       10
       10
       +
           saving a lot of computation when the derivation is non-trivial.

     

       11
       11
       +
       

     

       12
       12
       +
           This is useful in situations where a derivation might only be used for its

     

       13
       13
       +
           passthru attributes, improving evaluation performance.

     

       14
       14
       +
       

     

       15
       15
       +
           The returned attribute set is lazy in `derivation`. Specifically, this

     

       16
       16
       +
           means that the derivation will not be evaluated in at least the

     

       17
       17
       +
           situations below.

     

       18
       18
       +
       

     

       19
       19
       +
           For illustration and/or testing, we define derivation such that its

     

       20
       20
       +
           evaluation is very noticable.

     

       21
       21
       +
       

     

       22
       22
       +
               let derivation = throw "This won't be evaluated.";

     

       23
       23
       +
       

     

       24
       24
       +
           In the following expressions, `derivation` will _not_ be evaluated:

     

       25
       25
       +
       

     

       26
       26
       +
               (lazyDerivation { inherit derivation; }).type

     

       27
       27
       +
       

     

       28
       28
       +
               attrNames (lazyDerivation { inherit derivation; })

     

       29
       29
       +
       

     

       30
       30
       +
               (lazyDerivation { inherit derivation; } // { foo = true; }).foo

     

       31
       31
       +
       

     

       32
       32
       +
               (lazyDerivation { inherit derivation; meta.foo = true; }).meta

     

       33
       33
       +
       

     

       34
       34
       +
           In these expressions, it `derivation` _will_ be evaluated:

     

       35
       35
       +
       

     

       36
       36
       +
               "${lazyDerivation { inherit derivation }}"

     

       37
       37
       +
       

     

       38
       38
       +
               (lazyDerivation { inherit derivation }).outPath

     

       39
       39
       +
       

     

       40
       40
       +
               (lazyDerivation { inherit derivation }).meta

     

       41
       41
       +
       

     

       42
       42
       +
           And the following expressions are not valid, because the refer to

     

       43
       43
       +
           implementation details and/or attributes that may not be present on

     

       44
       44
       +
           some derivations:

     

       45
       45
       +
       

     

       46
       46
       +
               (lazyDerivation { inherit derivation }).buildInputs

     

       47
       47
       +
       

     

       48
       48
       +
               (lazyDerivation { inherit derivation }).passthru

     

       49
       49
       +
       

     

       50
       50
       +
               (lazyDerivation { inherit derivation }).pythonPath

     

       51
       51
       +
       

     

       52
       52
       +
         */

     

       53
       53
       +
         lazyDerivation =

     

       54
       54
       +
           args@{

     

       55
       55
       +
             # The derivation to be wrapped.

     

       56
       56
       +
             derivation

     

       57
       57
       +
           , # Optional meta attribute.

     

       58
       58
       +
             #

     

       59
       59
       +
             # While this function is primarily about derivations, it can improve

     

       60
       60
       +
             # the `meta` package attribute, which is usually specified through

     

       61
       61
       +
             # `mkDerivation`.

     

       62
       62
       +
             meta ? null

     

       63
       63
       +
           , # Optional extra values to add to the returned attrset.

     

       64
       64
       +
             #

     

       65
       65
       +
             # This can be used for adding package attributes, such as `tests`.

     

       66
       66
       +
             passthru ? { }

     

       67
       67
       +
           }:

     

       68
       68
       +
           let

     

       69
       69
       +
             # These checks are strict in `drv` and some `drv` attributes, but the

     

       70
       70
       +
             # attrset spine returned by lazyDerivation does not depend on it.

     

       71
       71
       +
             # Instead, the individual derivation attributes do depend on it.

     

       72
       72
       +
             checked =

     

       73
       73
       +
               throwIfNot (derivation.type or null == "derivation")

     

       74
       74
       +
                 "lazySimpleDerivation: input must be a derivation."

     

       75
       75
       +
                 throwIfNot

     

       76
       76
       +
                 (derivation.outputs == [ "out" ])

     

       77
       77
       +
                 # Supporting multiple outputs should be a matter of inheriting more attrs.

     

       78
       78
       +
                 "The derivation ${derivation.name or "<unknown>"} has multiple outputs. This is not supported by lazySimpleDerivation yet. Support could be added, and be useful as long as the set of outputs is known in advance, without evaluating the actual derivation."

     

       79
       79
       +
                 derivation;

     

       80
       80
       +
           in

     

       81
       81
       +
           {

     

       82
       82
       +
             # Hardcoded `type`

     

       83
       83
       +
             #

     

       84
       84
       +
             # `lazyDerivation` requires its `derivation` argument to be a derivation,

     

       85
       85
       +
             # so if it is not, that is a programming error by the caller and not

     

       86
       86
       +
             # something that `lazyDerivation` consumers should be able to correct

     

       87
       87
       +
             # for after the fact.

     

       88
       88
       +
             # So, to improve laziness, we assume correctness here and check it only

     

       89
       89
       +
             # when actual derivation values are accessed later.

     

       90
       90
       +
             type = "derivation";

     

       91
       91
       +
       

     

       92
       92
       +
             # A fixed set of derivation values, so that `lazyDerivation` can return

     

       93
       93
       +
             # its attrset before evaluating `derivation`.

     

       94
       94
       +
             # This must only list attributes that are available on _all_ derivations.

     

       95
       95
       +
             inherit (checked) outputs out outPath outputName drvPath name system;

     

       96
       96
       +
       

     

       97
       97
       +
             # The meta attribute can either be taken from the derivation, or if the

     

       98
       98
       +
             # `lazyDerivation` caller knew a shortcut, be taken from there.

     

       99
       99
       +
             meta = args.meta or checked.meta;

     

       100
       100
       +
           } // passthru;

     

       101
       101
       +
       }

+2 -1

lib/modules.nix

···

       440
       440
        
                 config = addFreeformType (addMeta (m.config or {}));

     

       441
       441
        
               }

     

       442
       442
        
           else

     

       443
       443
       +
             # shorthand syntax

     

       443
       444
        
             lib.throwIfNot (isAttrs m) "module ${file} (${key}) does not look like a module."

     

       444
       445
        
             { _file = toString m._file or file;

     

       445
       446
        
               key = toString m.key or key;

     

       446
       447
        
               disabledModules = m.disabledModules or [];

     

       447
       448
        
               imports = m.require or [] ++ m.imports or [];

     

       448
       449
        
               options = {};

     

       449
       449
       -
               config = addFreeformType (addMeta (removeAttrs m ["_file" "key" "disabledModules" "require" "imports" "freeformType"]));

     

       450
       450
       +
               config = addFreeformType (removeAttrs m ["_file" "key" "disabledModules" "require" "imports" "freeformType"]);

     

       450
       451
        
             };

     

       451
       452
        
       

     

       452
       453
        
         applyModuleArgsIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then

+53

lib/tests/misc.nix

···

       1207
       1207
        
           expected = true;

     

       1208
       1208
        
         };

     

       1209
       1209
        
       

     

       1210
       1210
       +
         # lazyDerivation

     

       1211
       1211
       +
       

     

       1212
       1212
       +
         testLazyDerivationIsLazyInDerivationForAttrNames = {

     

       1213
       1213
       +
           expr = attrNames (lazyDerivation {

     

       1214
       1214
       +
             derivation = throw "not lazy enough";

     

       1215
       1215
       +
           });

     

       1216
       1216
       +
           # It's ok to add attribute names here when lazyDerivation is improved

     

       1217
       1217
       +
           # in accordance with its inline comments.

     

       1218
       1218
       +
           expected = [ "drvPath" "meta" "name" "out" "outPath" "outputName" "outputs" "system" "type" ];

     

       1219
       1219
       +
         };

     

       1220
       1220
       +
       

     

       1221
       1221
       +
         testLazyDerivationIsLazyInDerivationForPassthruAttr = {

     

       1222
       1222
       +
           expr = (lazyDerivation {

     

       1223
       1223
       +
             derivation = throw "not lazy enough";

     

       1224
       1224
       +
             passthru.tests = "whatever is in tests";

     

       1225
       1225
       +
           }).tests;

     

       1226
       1226
       +
           expected = "whatever is in tests";

     

       1227
       1227
       +
         };

     

       1228
       1228
       +
       

     

       1229
       1229
       +
         testLazyDerivationIsLazyInDerivationForPassthruAttr2 = {

     

       1230
       1230
       +
           # passthru.tests is not a special case. It works for any attr.

     

       1231
       1231
       +
           expr = (lazyDerivation {

     

       1232
       1232
       +
             derivation = throw "not lazy enough";

     

       1233
       1233
       +
             passthru.foo = "whatever is in foo";

     

       1234
       1234
       +
           }).foo;

     

       1235
       1235
       +
           expected = "whatever is in foo";

     

       1236
       1236
       +
         };

     

       1237
       1237
       +
       

     

       1238
       1238
       +
         testLazyDerivationIsLazyInDerivationForMeta = {

     

       1239
       1239
       +
           expr = (lazyDerivation {

     

       1240
       1240
       +
             derivation = throw "not lazy enough";

     

       1241
       1241
       +
             meta = "whatever is in meta";

     

       1242
       1242
       +
           }).meta;

     

       1243
       1243
       +
           expected = "whatever is in meta";

     

       1244
       1244
       +
         };

     

       1245
       1245
       +
       

     

       1246
       1246
       +
         testLazyDerivationReturnsDerivationAttrs = let

     

       1247
       1247
       +
           derivation = {

     

       1248
       1248
       +
             type = "derivation";

     

       1249
       1249
       +
             outputs = ["out"];

     

       1250
       1250
       +
             out = "test out";

     

       1251
       1251
       +
             outPath = "test outPath";

     

       1252
       1252
       +
             outputName = "out";

     

       1253
       1253
       +
             drvPath = "test drvPath";

     

       1254
       1254
       +
             name = "test name";

     

       1255
       1255
       +
             system = "test system";

     

       1256
       1256
       +
             meta = "test meta";

     

       1257
       1257
       +
           };

     

       1258
       1258
       +
         in {

     

       1259
       1259
       +
           expr = lazyDerivation { inherit derivation; };

     

       1260
       1260
       +
           expected = derivation;

     

       1261
       1261
       +
         };

     

       1262
       1262
       +
       

     

       1210
       1263
        
         testTypeDescriptionInt = {

     

       1211
       1264
        
           expr = (with types; int).description;

     

       1212
       1265
        
           expected = "signed integer";

lib/tests/modules.sh

···

       58
       58
        
           fi

     

       59
       59
        
       }

     

       60
       60
        
       

     

       61
       61
       +
       # Shorthand meta attribute does not duplicate the config

     

       62
       62
       +
       checkConfigOutput '^"one two"$' config.result ./shorthand-meta.nix

     

       63
       63
       +
       

     

       61
       64
        
       # Check boolean option.

     

       62
       65
        
       checkConfigOutput '^false$' config.enable ./declare-enable.nix

     

       63
       66
        
       checkConfigError 'The option .* does not exist. Definition values:\n\s*- In .*: true' config.enable ./define-enable.nix

+19

lib/tests/modules/shorthand-meta.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         imports = [

     

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

     

       8
       8
       +
             options = {

     

       9
       9
       +
               meta.foo = mkOption {

     

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

     

       11
       11
       +
               };

     

       12
       12
       +
               result = mkOption { default = lib.concatStringsSep " " config.meta.foo; };

     

       13
       13
       +
             };

     

       14
       14
       +
           })

     

       15
       15
       +
           {

     

       16
       16
       +
             meta.foo = [ "one" "two" ];

     

       17
       17
       +
           }

     

       18
       18
       +
         ];

     

       19
       19
       +
       }

+30

nixos/doc/manual/default.nix

···

       13
       13
        
       with pkgs;

     

       14
       14
        
       

     

       15
       15
        
       let

     

       16
       16
       +
         inherit (lib) hasPrefix removePrefix;

     

       17
       17
       +
       

     

       16
       18
        
         lib = pkgs.lib;

     

       17
       19
        
       

     

       18
       20
        
         docbook_xsl_ns = pkgs.docbook-xsl-ns.override {

     
···

       36
       38
        
           };

     

       37
       39
        
         };

     

       38
       40
        
       

     

       41
       41
       +
         nixos-lib = import ../../lib { };

     

       42
       42
       +
       

     

       43
       43
       +
         testOptionsDoc = let

     

       44
       44
       +
             eval = nixos-lib.evalTest {

     

       45
       45
       +
               # Avoid evaluating a NixOS config prototype.

     

       46
       46
       +
               config.node.type = lib.types.deferredModule;

     

       47
       47
       +
               options._module.args = lib.mkOption { internal = true; };

     

       48
       48
       +
             };

     

       49
       49
       +
           in buildPackages.nixosOptionsDoc {

     

       50
       50
       +
             inherit (eval) options;

     

       51
       51
       +
             inherit (revision);

     

       52
       52
       +
             transformOptions = opt: opt // {

     

       53
       53
       +
               # Clean up declaration sites to not refer to the NixOS source tree.

     

       54
       54
       +
               declarations =

     

       55
       55
       +
                 map

     

       56
       56
       +
                   (decl:

     

       57
       57
       +
                     if hasPrefix (toString ../../..) (toString decl)

     

       58
       58
       +
                     then

     

       59
       59
       +
                       let subpath = removePrefix "/" (removePrefix (toString ../../..) (toString decl));

     

       60
       60
       +
                       in { url = "https://github.com/NixOS/nixpkgs/blob/master/${subpath}"; name = subpath; }

     

       61
       61
       +
                     else decl)

     

       62
       62
       +
                   opt.declarations;

     

       63
       63
       +
             };

     

       64
       64
       +
             documentType = "none";

     

       65
       65
       +
             variablelistId = "test-options-list";

     

       66
       66
       +
           };

     

       67
       67
       +
       

     

       39
       68
        
         sources = lib.sourceFilesBySuffices ./. [".xml"];

     

       40
       69
        
       

     

       41
       70
        
         modulesDoc = builtins.toFile "modules.xml" ''

     
···

       50
       79
        
           mkdir $out

     

       51
       80
        
           ln -s ${modulesDoc} $out/modules.xml

     

       52
       81
        
           ln -s ${optionsDoc.optionsDocBook} $out/options-db.xml

     

       82
       82
       +
           ln -s ${testOptionsDoc.optionsDocBook} $out/test-options-db.xml

     

       53
       83
        
           printf "%s" "${version}" > $out/version

     

       54
       84
        
         '';

     

       55
       85

+14

nixos/doc/manual/development/running-nixos-tests-interactively.section.md

···

       24
       24
        
       you to inspect the state of the VMs after the test (e.g. to debug the

     

       25
       25
        
       test script).

     

       26
       26
        
       

     

       27
       27
       +
       ## Reuse VM state {#sec-nixos-test-reuse-vm-state}

     

       28
       28
       +
       

     

       27
       29
        
       You can re-use the VM states coming from a previous run by setting the

     

       28
       30
        
       `--keep-vm-state` flag.

     

       29
       31
        
       

     
···

       33
       35
        
       

     

       34
       36
        
       The machine state is stored in the `$TMPDIR/vm-state-machinename`

     

       35
       37
        
       directory.

     

       38
       38
       +
       

     

       39
       39
       +
       ## Interactive-only test configuration {#sec-nixos-test-interactive-configuration}

     

       40
       40
       +
       

     

       41
       41
       +
       The `.driverInteractive` attribute combines the regular test configuration with

     

       42
       42
       +
       definitions from the [`interactive` submodule](#opt-interactive). This gives you

     

       43
       43
       +
       a more usable, graphical, but slightly different configuration.

     

       44
       44
       +
       

     

       45
       45
       +
       You can add your own interactive-only test configuration by adding extra

     

       46
       46
       +
       configuration to the [`interactive` submodule](#opt-interactive).

     

       47
       47
       +
       

     

       48
       48
       +
       To interactively run only the regular configuration, build the `<test>.driver` attribute

     

       49
       49
       +
       instead, and call it with the flag `result/bin/nixos-test-driver --interactive`.

+3 -14

nixos/doc/manual/development/running-nixos-tests.section.md

···

       2
       2
        
       

     

       3
       3
        
       You can run tests using `nix-build`. For example, to run the test

     

       4
       4
        
       [`login.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix),

     

       5
       5
       -
       you just do:

     

       5
       5
       +
       you do:

     

       6
       6
        
       

     

       7
       7
        
       ```ShellSession

     

       8
       8
       -
       $ nix-build '<nixpkgs/nixos/tests/login.nix>'

     

       9
       9
       -
       ```

     

       10
       10
       -
       

     

       11
       11
       -
       or, if you don't want to rely on `NIX_PATH`:

     

       12
       12
       -
       

     

       13
       13
       -
       ```ShellSession

     

       14
       14
       -
       $ cd /my/nixpkgs/nixos/tests

     

       15
       15
       -
       $ nix-build login.nix

     

       16
       16
       -
       …

     

       17
       17
       -
       running the VM test script

     

       18
       18
       -
       machine: QEMU running (pid 8841)

     

       19
       19
       -
       …

     

       20
       20
       -
       6 out of 6 tests succeeded

     

       8
       8
       +
       $ cd /my/git/clone/of/nixpkgs

     

       9
       9
       +
       $ nix-build -A nixosTests.login

     

       21
       10
        
       ```

     

       22
       11
        
       

     

       23
       12
        
       After building/downloading all required dependencies, this will perform

+68 -11

nixos/doc/manual/development/writing-nixos-tests.section.md

···

       1
       1
        
       # Writing Tests {#sec-writing-nixos-tests}

     

       2
       2
        
       

     

       3
       3
       -
       A NixOS test is a Nix expression that has the following structure:

     

       3
       3
       +
       A NixOS test is a module that has the following structure:

     

       4
       4
        
       

     

       5
       5
        
       ```nix

     

       6
       6
       -
       import ./make-test-python.nix {

     

       6
       6
       +
       {

     

       7
       7
        
       

     

       8
       8
        
         # One or more machines:

     

       9
       9
        
         nodes =

     
···

       21
       21
        
       }

     

       22
       22
        
       ```

     

       23
       23
        
       

     

       24
       24
       -
       The attribute `testScript` is a bit of Python code that executes the

     

       24
       24
       +
       We refer to the whole test above as a test module, whereas the values

     

       25
       25
       +
       in [`nodes.<name>`](#opt-nodes) are NixOS modules themselves.

     

       26
       26
       +
       

     

       27
       27
       +
       The option [`testScript`](#opt-testScript) is a piece of Python code that executes the

     

       25
       28
        
       test (described below). During the test, it will start one or more

     

       26
       29
        
       virtual machines, the configuration of which is described by

     

       27
       27
       -
       the attribute `nodes`.

     

       30
       30
       +
       the option [`nodes`](#opt-nodes).

     

       28
       31
        
       

     

       29
       32
        
       An example of a single-node test is

     

       30
       33
        
       [`login.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix).

     
···

       34
       37
        
       [`nfs/simple.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nfs/simple.nix).

     

       35
       38
        
       It uses two client nodes to test correct locking across server crashes.

     

       36
       39
        
       

     

       37
       37
       -
       There are a few special NixOS configuration options for test VMs:

     

       40
       40
       +
       ## Calling a test {#sec-calling-nixos-tests}

     

       41
       41
       +
       

     

       42
       42
       +
       Tests are invoked differently depending on whether the test is part of NixOS or lives in a different project.

     

       43
       43
       +
       

     

       44
       44
       +
       ### Testing within NixOS {#sec-call-nixos-test-in-nixos}

     

       45
       45
       +
       

     

       46
       46
       +
       Tests that are part of NixOS are added to [`nixos/tests/all-tests.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/all-tests.nix).

     

       47
       47
       +
       

     

       48
       48
       +
       ```nix

     

       49
       49
       +
         hostname = runTest ./hostname.nix;

     

       50
       50
       +
       ```

     

       51
       51
       +
       

     

       52
       52
       +
       Overrides can be added by defining an anonymous module in `all-tests.nix`.

     

       53
       53
       +
       

     

       54
       54
       +
       ```nix

     

       55
       55
       +
         hostname = runTest {

     

       56
       56
       +
           imports = [ ./hostname.nix ];

     

       57
       57
       +
           defaults.networking.firewall.enable = false;

     

       58
       58
       +
         };

     

       59
       59
       +
       ```

     

       60
       60
       +
       

     

       61
       61
       +
       You can run a test with attribute name `hostname` in `nixos/tests/all-tests.nix` by invoking:

     

       62
       62
       +
       

     

       63
       63
       +
       ```shell

     

       64
       64
       +
       cd /my/git/clone/of/nixpkgs

     

       65
       65
       +
       nix-build -A nixosTests.hostname

     

       66
       66
       +
       ```

     

       67
       67
       +
       

     

       68
       68
       +
       ### Testing outside the NixOS project {#sec-call-nixos-test-outside-nixos}

     

       69
       69
       +
       

     

       70
       70
       +
       Outside the `nixpkgs` repository, you can instantiate the test by first importing the NixOS library,

     

       71
       71
       +
       

     

       72
       72
       +
       ```nix

     

       73
       73
       +
       let nixos-lib = import (nixpkgs + "/nixos/lib") { };

     

       74
       74
       +
       in

     

       75
       75
       +
       

     

       76
       76
       +
       nixos-lib.runTest {

     

       77
       77
       +
         imports = [ ./test.nix ];

     

       78
       78
       +
         hostPkgs = pkgs;  # the Nixpkgs package set used outside the VMs

     

       79
       79
       +
         defaults.services.foo.package = mypkg;

     

       80
       80
       +
       }

     

       81
       81
       +
       ```

     

       82
       82
       +
       

     

       83
       83
       +
       `runTest` returns a derivation that runs the test.

     

       84
       84
       +
       

     

       85
       85
       +
       ## Configuring the nodes {#sec-nixos-test-nodes}

     

       86
       86
       +
       

     

       87
       87
       +
       There are a few special NixOS options for test VMs:

     

       38
       88
        
       

     

       39
       89
        
       `virtualisation.memorySize`

     

       40
       90
        
       

     
···

       121
       171
        
           least one will be returned.

     

       122
       172
        
       

     

       123
       173
        
           ::: {.note}

     

       124
       124
       -
           This requires passing `enableOCR` to the test attribute set.

     

       174
       174
       +
           This requires [`enableOCR`](#opt-enableOCR) to be set to `true`.

     

       125
       175
        
           :::

     

       126
       176
        
       

     

       127
       177
        
       `get_screen_text`

     
···

       130
       180
        
           machine\'s screen using optical character recognition.

     

       131
       181
        
       

     

       132
       182
        
           ::: {.note}

     

       133
       133
       -
           This requires passing `enableOCR` to the test attribute set.

     

       183
       183
       +
           This requires [`enableOCR`](#opt-enableOCR) to be set to `true`.

     

       134
       184
        
           :::

     

       135
       185
        
       

     

       136
       186
        
       `send_monitor_command`

     
···

       241
       291
        
           `get_screen_text` and `get_screen_text_variants`).

     

       242
       292
        
       

     

       243
       293
        
           ::: {.note}

     

       244
       244
       -
           This requires passing `enableOCR` to the test attribute set.

     

       294
       294
       +
           This requires [`enableOCR`](#opt-enableOCR) to be set to `true`.

     

       245
       295
        
           :::

     

       246
       296
        
       

     

       247
       297
        
       `wait_for_console_text`

     
···

       304
       354
        
       (this shouldn\'t be commited though):

     

       305
       355
        
       

     

       306
       356
        
       ```nix

     

       307
       307
       -
       import ./make-test-python.nix {

     

       357
       357
       +
       {

     

       308
       358
        
         skipLint = true;

     

       309
       359
        
         nodes.machine =

     

       310
       360
        
           { config, pkgs, ... }:

     
···

       336
       386
        
       way:

     

       337
       387
        
       

     

       338
       388
        
       ```nix

     

       339
       339
       -
       import ./make-test-python.nix {

     

       389
       389
       +
       {

     

       340
       390
        
         skipTypeCheck = true;

     

       341
       391
        
         nodes.machine =

     

       342
       392
        
           { config, pkgs, ... }:

     
···

       400
       450
        
       `numpy` like this:

     

       401
       451
        
       

     

       402
       452
        
       ```nix

     

       403
       403
       -
       import ./make-test-python.nix

     

       404
       453
        
       {

     

       405
       454
        
         extraPythonPackages = p: [ p.numpy ];

     

       406
       455
        
       

     
···

       417
       466
        
       ```

     

       418
       467
        
       

     

       419
       468
        
       In that case, `numpy` is chosen from the generic `python3Packages`.

     

       469
       469
       +
       

     

       470
       470
       +
       ## Test Options Reference {#sec-test-options-reference}

     

       471
       471
       +
       

     

       472
       472
       +
       The following options can be used when writing tests.

     

       473
       473
       +
       

     

       474
       474
       +
       ```{=docbook}

     

       475
       475
       +
       <xi:include href="../../generated/test-options-db.xml" xpointer="test-options-list"/>

     

       476
       476
       +
       ```

+34 -9

nixos/doc/manual/from_md/development/running-nixos-tests-interactively.section.xml

···

       25
       25
        
           completion. This allows you to inspect the state of the VMs after

     

       26
       26
        
           the test (e.g. to debug the test script).

     

       27
       27
        
         </para>

     

       28
       28
       -
         <para>

     

       29
       29
       -
           You can re-use the VM states coming from a previous run by setting

     

       30
       30
       -
           the <literal>--keep-vm-state</literal> flag.

     

       31
       31
       -
         </para>

     

       32
       32
       -
         <programlisting>

     

       28
       28
       +
         <section xml:id="sec-nixos-test-reuse-vm-state">

     

       29
       29
       +
           <title>Reuse VM state</title>

     

       30
       30
       +
           <para>

     

       31
       31
       +
             You can re-use the VM states coming from a previous run by setting

     

       32
       32
       +
             the <literal>--keep-vm-state</literal> flag.

     

       33
       33
       +
           </para>

     

       34
       34
       +
           <programlisting>

     

       33
       35
        
       $ ./result/bin/nixos-test-driver --keep-vm-state

     

       34
       36
        
       </programlisting>

     

       35
       35
       -
         <para>

     

       36
       36
       -
           The machine state is stored in the

     

       37
       37
       -
           <literal>$TMPDIR/vm-state-machinename</literal> directory.

     

       38
       38
       -
         </para>

     

       37
       37
       +
           <para>

     

       38
       38
       +
             The machine state is stored in the

     

       39
       39
       +
             <literal>$TMPDIR/vm-state-machinename</literal> directory.

     

       40
       40
       +
           </para>

     

       41
       41
       +
         </section>

     

       42
       42
       +
         <section xml:id="sec-nixos-test-interactive-configuration">

     

       43
       43
       +
           <title>Interactive-only test configuration</title>

     

       44
       44
       +
           <para>

     

       45
       45
       +
             The <literal>.driverInteractive</literal> attribute combines the

     

       46
       46
       +
             regular test configuration with definitions from the

     

       47
       47
       +
             <link linkend="opt-interactive"><literal>interactive</literal>

     

       48
       48
       +
             submodule</link>. This gives you a more usable, graphical, but

     

       49
       49
       +
             slightly different configuration.

     

       50
       50
       +
           </para>

     

       51
       51
       +
           <para>

     

       52
       52
       +
             You can add your own interactive-only test configuration by adding

     

       53
       53
       +
             extra configuration to the

     

       54
       54
       +
             <link linkend="opt-interactive"><literal>interactive</literal>

     

       55
       55
       +
             submodule</link>.

     

       56
       56
       +
           </para>

     

       57
       57
       +
           <para>

     

       58
       58
       +
             To interactively run only the regular configuration, build the

     

       59
       59
       +
             <literal>&lt;test&gt;.driver</literal> attribute instead, and call

     

       60
       60
       +
             it with the flag

     

       61
       61
       +
             <literal>result/bin/nixos-test-driver --interactive</literal>.

     

       62
       62
       +
           </para>

     

       63
       63
       +
         </section>

     

       39
       64
        
       </section>

+3 -14

nixos/doc/manual/from_md/development/running-nixos-tests.section.xml

···

       4
       4
        
           You can run tests using <literal>nix-build</literal>. For example,

     

       5
       5
        
           to run the test

     

       6
       6
        
           <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix"><literal>login.nix</literal></link>,

     

       7
       7
       -
           you just do:

     

       7
       7
       +
           you do:

     

       8
       8
        
         </para>

     

       9
       9
        
         <programlisting>

     

       10
       10
       -
       $ nix-build '&lt;nixpkgs/nixos/tests/login.nix&gt;'

     

       11
       11
       -
       </programlisting>

     

       12
       12
       -
         <para>

     

       13
       13
       -
           or, if you don’t want to rely on <literal>NIX_PATH</literal>:

     

       14
       14
       -
         </para>

     

       15
       15
       -
         <programlisting>

     

       16
       16
       -
       $ cd /my/nixpkgs/nixos/tests

     

       17
       17
       -
       $ nix-build login.nix

     

       18
       18
       -
       …

     

       19
       19
       -
       running the VM test script

     

       20
       20
       -
       machine: QEMU running (pid 8841)

     

       21
       21
       -
       …

     

       22
       22
       -
       6 out of 6 tests succeeded

     

       10
       10
       +
       $ cd /my/git/clone/of/nixpkgs

     

       11
       11
       +
       $ nix-build -A nixosTests.login

     

       23
       12
        
       </programlisting>

     

       24
       13
        
         <para>

     

       25
       14
        
           After building/downloading all required dependencies, this will

+158 -81

nixos/doc/manual/from_md/development/writing-nixos-tests.section.xml

···

       1
       1
       -
       <section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-writing-nixos-tests">

     

       1
       1
       +
       <section xmlns="http://docbook.org/ns/docbook"  xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude" xml:id="sec-writing-nixos-tests">

     

       2
       2
        
         <title>Writing Tests</title>

     

       3
       3
        
         <para>

     

       4
       4
       -
           A NixOS test is a Nix expression that has the following structure:

     

       4
       4
       +
           A NixOS test is a module that has the following structure:

     

       5
       5
        
         </para>

     

       6
       6
        
         <programlisting language="bash">

     

       7
       7
       -
       import ./make-test-python.nix {

     

       7
       7
       +
       {

     

       8
       8
        
       

     

       9
       9
        
         # One or more machines:

     

       10
       10
        
         nodes =

     
···

       22
       22
        
       }

     

       23
       23
        
       </programlisting>

     

       24
       24
        
         <para>

     

       25
       25
       -
           The attribute <literal>testScript</literal> is a bit of Python code

     

       26
       26
       -
           that executes the test (described below). During the test, it will

     

       27
       27
       -
           start one or more virtual machines, the configuration of which is

     

       28
       28
       -
           described by the attribute <literal>nodes</literal>.

     

       25
       25
       +
           We refer to the whole test above as a test module, whereas the

     

       26
       26
       +
           values in

     

       27
       27
       +
           <link linkend="opt-nodes"><literal>nodes.&lt;name&gt;</literal></link>

     

       28
       28
       +
           are NixOS modules themselves.

     

       29
       29
       +
         </para>

     

       30
       30
       +
         <para>

     

       31
       31
       +
           The option

     

       32
       32
       +
           <link linkend="opt-testScript"><literal>testScript</literal></link>

     

       33
       33
       +
           is a piece of Python code that executes the test (described below).

     

       34
       34
       +
           During the test, it will start one or more virtual machines, the

     

       35
       35
       +
           configuration of which is described by the option

     

       36
       36
       +
           <link linkend="opt-nodes"><literal>nodes</literal></link>.

     

       29
       37
        
         </para>

     

       30
       38
        
         <para>

     

       31
       39
        
           An example of a single-node test is

     
···

       38
       46
        
           It uses two client nodes to test correct locking across server

     

       39
       47
        
           crashes.

     

       40
       48
        
         </para>

     

       41
       41
       -
         <para>

     

       42
       42
       -
           There are a few special NixOS configuration options for test VMs:

     

       43
       43
       -
         </para>

     

       44
       44
       -
         <variablelist>

     

       45
       45
       -
           <varlistentry>

     

       46
       46
       -
             <term>

     

       47
       47
       -
               <literal>virtualisation.memorySize</literal>

     

       48
       48
       -
             </term>

     

       49
       49
       -
             <listitem>

     

       50
       50
       -
               <para>

     

       51
       51
       -
                 The memory of the VM in megabytes.

     

       52
       52
       -
               </para>

     

       53
       53
       -
             </listitem>

     

       54
       54
       -
           </varlistentry>

     

       55
       55
       -
           <varlistentry>

     

       56
       56
       -
             <term>

     

       57
       57
       -
               <literal>virtualisation.vlans</literal>

     

       58
       58
       -
             </term>

     

       59
       59
       -
             <listitem>

     

       60
       60
       -
               <para>

     

       61
       61
       -
                 The virtual networks to which the VM is connected. See

     

       62
       62
       -
                 <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nat.nix"><literal>nat.nix</literal></link>

     

       63
       63
       -
                 for an example.

     

       64
       64
       -
               </para>

     

       65
       65
       -
             </listitem>

     

       66
       66
       -
           </varlistentry>

     

       67
       67
       -
           <varlistentry>

     

       68
       68
       -
             <term>

     

       69
       69
       -
               <literal>virtualisation.writableStore</literal>

     

       70
       70
       -
             </term>

     

       71
       71
       -
             <listitem>

     

       72
       72
       -
               <para>

     

       73
       73
       -
                 By default, the Nix store in the VM is not writable. If you

     

       74
       74
       -
                 enable this option, a writable union file system is mounted on

     

       75
       75
       -
                 top of the Nix store to make it appear writable. This is

     

       76
       76
       -
                 necessary for tests that run Nix operations that modify the

     

       77
       77
       -
                 store.

     

       78
       78
       -
               </para>

     

       79
       79
       -
             </listitem>

     

       80
       80
       -
           </varlistentry>

     

       81
       81
       -
         </variablelist>

     

       82
       82
       -
         <para>

     

       83
       83
       -
           For more options, see the module

     

       84
       84
       -
           <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/virtualisation/qemu-vm.nix"><literal>qemu-vm.nix</literal></link>.

     

       85
       85
       -
         </para>

     

       86
       86
       -
         <para>

     

       87
       87
       -
           The test script is a sequence of Python statements that perform

     

       88
       88
       -
           various actions, such as starting VMs, executing commands in the

     

       89
       89
       -
           VMs, and so on. Each virtual machine is represented as an object

     

       90
       90
       -
           stored in the variable <literal>name</literal> if this is also the

     

       91
       91
       -
           identifier of the machine in the declarative config. If you

     

       92
       92
       -
           specified a node <literal>nodes.machine</literal>, the following

     

       93
       93
       -
           example starts the machine, waits until it has finished booting,

     

       94
       94
       -
           then executes a command and checks that the output is more-or-less

     

       95
       95
       -
           correct:

     

       96
       96
       -
         </para>

     

       97
       97
       -
         <programlisting language="python">

     

       49
       49
       +
         <section xml:id="sec-calling-nixos-tests">

     

       50
       50
       +
           <title>Calling a test</title>

     

       51
       51
       +
           <para>

     

       52
       52
       +
             Tests are invoked differently depending on whether the test is

     

       53
       53
       +
             part of NixOS or lives in a different project.

     

       54
       54
       +
           </para>

     

       55
       55
       +
           <section xml:id="sec-call-nixos-test-in-nixos">

     

       56
       56
       +
             <title>Testing within NixOS</title>

     

       57
       57
       +
             <para>

     

       58
       58
       +
               Tests that are part of NixOS are added to

     

       59
       59
       +
               <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/all-tests.nix"><literal>nixos/tests/all-tests.nix</literal></link>.

     

       60
       60
       +
             </para>

     

       61
       61
       +
             <programlisting language="bash">

     

       62
       62
       +
         hostname = runTest ./hostname.nix;

     

       63
       63
       +
       </programlisting>

     

       64
       64
       +
             <para>

     

       65
       65
       +
               Overrides can be added by defining an anonymous module in

     

       66
       66
       +
               <literal>all-tests.nix</literal>.

     

       67
       67
       +
             </para>

     

       68
       68
       +
             <programlisting language="bash">

     

       69
       69
       +
         hostname = runTest {

     

       70
       70
       +
           imports = [ ./hostname.nix ];

     

       71
       71
       +
           defaults.networking.firewall.enable = false;

     

       72
       72
       +
         };

     

       73
       73
       +
       </programlisting>

     

       74
       74
       +
             <para>

     

       75
       75
       +
               You can run a test with attribute name

     

       76
       76
       +
               <literal>hostname</literal> in

     

       77
       77
       +
               <literal>nixos/tests/all-tests.nix</literal> by invoking:

     

       78
       78
       +
             </para>

     

       79
       79
       +
             <programlisting>

     

       80
       80
       +
       cd /my/git/clone/of/nixpkgs

     

       81
       81
       +
       nix-build -A nixosTests.hostname

     

       82
       82
       +
       </programlisting>

     

       83
       83
       +
           </section>

     

       84
       84
       +
           <section xml:id="sec-call-nixos-test-outside-nixos">

     

       85
       85
       +
             <title>Testing outside the NixOS project</title>

     

       86
       86
       +
             <para>

     

       87
       87
       +
               Outside the <literal>nixpkgs</literal> repository, you can

     

       88
       88
       +
               instantiate the test by first importing the NixOS library,

     

       89
       89
       +
             </para>

     

       90
       90
       +
             <programlisting language="bash">

     

       91
       91
       +
       let nixos-lib = import (nixpkgs + &quot;/nixos/lib&quot;) { };

     

       92
       92
       +
       in

     

       93
       93
       +
       

     

       94
       94
       +
       nixos-lib.runTest {

     

       95
       95
       +
         imports = [ ./test.nix ];

     

       96
       96
       +
         hostPkgs = pkgs;  # the Nixpkgs package set used outside the VMs

     

       97
       97
       +
         defaults.services.foo.package = mypkg;

     

       98
       98
       +
       }

     

       99
       99
       +
       </programlisting>

     

       100
       100
       +
             <para>

     

       101
       101
       +
               <literal>runTest</literal> returns a derivation that runs the

     

       102
       102
       +
               test.

     

       103
       103
       +
             </para>

     

       104
       104
       +
           </section>

     

       105
       105
       +
         </section>

     

       106
       106
       +
         <section xml:id="sec-nixos-test-nodes">

     

       107
       107
       +
           <title>Configuring the nodes</title>

     

       108
       108
       +
           <para>

     

       109
       109
       +
             There are a few special NixOS options for test VMs:

     

       110
       110
       +
           </para>

     

       111
       111
       +
           <variablelist>

     

       112
       112
       +
             <varlistentry>

     

       113
       113
       +
               <term>

     

       114
       114
       +
                 <literal>virtualisation.memorySize</literal>

     

       115
       115
       +
               </term>

     

       116
       116
       +
               <listitem>

     

       117
       117
       +
                 <para>

     

       118
       118
       +
                   The memory of the VM in megabytes.

     

       119
       119
       +
                 </para>

     

       120
       120
       +
               </listitem>

     

       121
       121
       +
             </varlistentry>

     

       122
       122
       +
             <varlistentry>

     

       123
       123
       +
               <term>

     

       124
       124
       +
                 <literal>virtualisation.vlans</literal>

     

       125
       125
       +
               </term>

     

       126
       126
       +
               <listitem>

     

       127
       127
       +
                 <para>

     

       128
       128
       +
                   The virtual networks to which the VM is connected. See

     

       129
       129
       +
                   <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nat.nix"><literal>nat.nix</literal></link>

     

       130
       130
       +
                   for an example.

     

       131
       131
       +
                 </para>

     

       132
       132
       +
               </listitem>

     

       133
       133
       +
             </varlistentry>

     

       134
       134
       +
             <varlistentry>

     

       135
       135
       +
               <term>

     

       136
       136
       +
                 <literal>virtualisation.writableStore</literal>

     

       137
       137
       +
               </term>

     

       138
       138
       +
               <listitem>

     

       139
       139
       +
                 <para>

     

       140
       140
       +
                   By default, the Nix store in the VM is not writable. If you

     

       141
       141
       +
                   enable this option, a writable union file system is mounted

     

       142
       142
       +
                   on top of the Nix store to make it appear writable. This is

     

       143
       143
       +
                   necessary for tests that run Nix operations that modify the

     

       144
       144
       +
                   store.

     

       145
       145
       +
                 </para>

     

       146
       146
       +
               </listitem>

     

       147
       147
       +
             </varlistentry>

     

       148
       148
       +
           </variablelist>

     

       149
       149
       +
           <para>

     

       150
       150
       +
             For more options, see the module

     

       151
       151
       +
             <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/virtualisation/qemu-vm.nix"><literal>qemu-vm.nix</literal></link>.

     

       152
       152
       +
           </para>

     

       153
       153
       +
           <para>

     

       154
       154
       +
             The test script is a sequence of Python statements that perform

     

       155
       155
       +
             various actions, such as starting VMs, executing commands in the

     

       156
       156
       +
             VMs, and so on. Each virtual machine is represented as an object

     

       157
       157
       +
             stored in the variable <literal>name</literal> if this is also the

     

       158
       158
       +
             identifier of the machine in the declarative config. If you

     

       159
       159
       +
             specified a node <literal>nodes.machine</literal>, the following

     

       160
       160
       +
             example starts the machine, waits until it has finished booting,

     

       161
       161
       +
             then executes a command and checks that the output is more-or-less

     

       162
       162
       +
             correct:

     

       163
       163
       +
           </para>

     

       164
       164
       +
           <programlisting language="python">

     

       98
       165
        
       machine.start()

     

       99
       166
        
       machine.wait_for_unit(&quot;default.target&quot;)

     

       100
       167
        
       if not &quot;Linux&quot; in machine.succeed(&quot;uname&quot;):

     

       101
       168
        
         raise Exception(&quot;Wrong OS&quot;)

     

       102
       169
        
       </programlisting>

     

       103
       103
       -
         <para>

     

       104
       104
       -
           The first line is technically unnecessary; machines are implicitly

     

       105
       105
       -
           started when you first execute an action on them (such as

     

       106
       106
       -
           <literal>wait_for_unit</literal> or <literal>succeed</literal>). If

     

       107
       107
       -
           you have multiple machines, you can speed up the test by starting

     

       108
       108
       -
           them in parallel:

     

       109
       109
       -
         </para>

     

       110
       110
       -
         <programlisting language="python">

     

       170
       170
       +
           <para>

     

       171
       171
       +
             The first line is technically unnecessary; machines are implicitly

     

       172
       172
       +
             started when you first execute an action on them (such as

     

       173
       173
       +
             <literal>wait_for_unit</literal> or <literal>succeed</literal>).

     

       174
       174
       +
             If you have multiple machines, you can speed up the test by

     

       175
       175
       +
             starting them in parallel:

     

       176
       176
       +
           </para>

     

       177
       177
       +
           <programlisting language="python">

     

       111
       178
        
       start_all()

     

       112
       179
        
       </programlisting>

     

       180
       180
       +
         </section>

     

       113
       181
        
         <section xml:id="ssec-machine-objects">

     

       114
       182
        
           <title>Machine objects</title>

     

       115
       183
        
           <para>

     
···

       194
       262
        
                 </para>

     

       195
       263
        
                 <note>

     

       196
       264
        
                   <para>

     

       197
       197
       -
                     This requires passing <literal>enableOCR</literal> to the

     

       198
       198
       -
                     test attribute set.

     

       265
       265
       +
                     This requires

     

       266
       266
       +
                     <link linkend="opt-enableOCR"><literal>enableOCR</literal></link>

     

       267
       267
       +
                     to be set to <literal>true</literal>.

     

       199
       268
        
                   </para>

     

       200
       269
        
                 </note>

     

       201
       270
        
               </listitem>

     
···

       211
       280
        
                 </para>

     

       212
       281
        
                 <note>

     

       213
       282
        
                   <para>

     

       214
       214
       -
                     This requires passing <literal>enableOCR</literal> to the

     

       215
       215
       -
                     test attribute set.

     

       283
       283
       +
                     This requires

     

       284
       284
       +
                     <link linkend="opt-enableOCR"><literal>enableOCR</literal></link>

     

       285
       285
       +
                     to be set to <literal>true</literal>.

     

       216
       286
        
                   </para>

     

       217
       287
        
                 </note>

     

       218
       288
        
               </listitem>

     
···

       451
       521
        
                 </para>

     

       452
       522
        
                 <note>

     

       453
       523
        
                   <para>

     

       454
       454
       -
                     This requires passing <literal>enableOCR</literal> to the

     

       455
       455
       -
                     test attribute set.

     

       524
       524
       +
                     This requires

     

       525
       525
       +
                     <link linkend="opt-enableOCR"><literal>enableOCR</literal></link>

     

       526
       526
       +
                     to be set to <literal>true</literal>.

     

       456
       527
        
                   </para>

     

       457
       528
        
                 </note>

     

       458
       529
        
               </listitem>

     
···

       563
       634
        
             code-linters (this shouldn't be commited though):

     

       564
       635
        
           </para>

     

       565
       636
        
           <programlisting language="bash">

     

       566
       566
       -
       import ./make-test-python.nix {

     

       637
       637
       +
       {

     

       567
       638
        
         skipLint = true;

     

       568
       639
        
         nodes.machine =

     

       569
       640
        
           { config, pkgs, ... }:

     
···

       595
       666
        
             the following way:

     

       596
       667
        
           </para>

     

       597
       668
        
           <programlisting language="bash">

     

       598
       598
       -
       import ./make-test-python.nix {

     

       669
       669
       +
       {

     

       599
       670
        
         skipTypeCheck = true;

     

       600
       671
        
         nodes.machine =

     

       601
       672
        
           { config, pkgs, ... }:

     
···

       669
       740
        
             <literal>numpy</literal> like this:

     

       670
       741
        
           </para>

     

       671
       742
        
           <programlisting language="bash">

     

       672
       672
       -
       import ./make-test-python.nix

     

       673
       743
        
       {

     

       674
       744
        
         extraPythonPackages = p: [ p.numpy ];

     

       675
       745
        
       

     
···

       688
       758
        
             In that case, <literal>numpy</literal> is chosen from the generic

     

       689
       759
        
             <literal>python3Packages</literal>.

     

       690
       760
        
           </para>

     

       761
       761
       +
         </section>

     

       762
       762
       +
         <section xml:id="sec-test-options-reference">

     

       763
       763
       +
           <title>Test Options Reference</title>

     

       764
       764
       +
           <para>

     

       765
       765
       +
             The following options can be used when writing tests.

     

       766
       766
       +
           </para>

     

       767
       767
       +
           <xi:include href="../../generated/test-options-db.xml" xpointer="test-options-list"/>

     

       691
       768
        
         </section>

     

       692
       769
        
       </section>

-113

nixos/lib/build-vms.nix

···

       1
       1
       -
       { system

     

       2
       2
       -
       , # Use a minimal kernel?

     

       3
       3
       -
         minimal ? false

     

       4
       4
       -
       , # Ignored

     

       5
       5
       -
         config ? null

     

       6
       6
       -
       , # Nixpkgs, for qemu, lib and more

     

       7
       7
       -
         pkgs, lib

     

       8
       8
       -
       , # !!! See comment about args in lib/modules.nix

     

       9
       9
       -
         specialArgs ? {}

     

       10
       10
       -
       , # NixOS configuration to add to the VMs

     

       11
       11
       -
         extraConfigurations ? []

     

       12
       12
       -
       }:

     

       13
       13
       -
       

     

       14
       14
       -
       with lib;

     

       15
       15
       -
       

     

       16
       16
       -
       rec {

     

       17
       17
       -
       

     

       18
       18
       -
         inherit pkgs;

     

       19
       19
       -
       

     

       20
       20
       -
         # Build a virtual network from an attribute set `{ machine1 =

     

       21
       21
       -
         # config1; ... machineN = configN; }', where `machineX' is the

     

       22
       22
       -
         # hostname and `configX' is a NixOS system configuration.  Each

     

       23
       23
       -
         # machine is given an arbitrary IP address in the virtual network.

     

       24
       24
       -
         buildVirtualNetwork =

     

       25
       25
       -
           nodes: let nodesOut = mapAttrs (n: buildVM nodesOut) (assignIPAddresses nodes); in nodesOut;

     

       26
       26
       -
       

     

       27
       27
       -
       

     

       28
       28
       -
         buildVM =

     

       29
       29
       -
           nodes: configurations:

     

       30
       30
       -
       

     

       31
       31
       -
           import ./eval-config.nix {

     

       32
       32
       -
             inherit system specialArgs;

     

       33
       33
       -
             modules = configurations ++ extraConfigurations;

     

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

     

       35
       35
       -
               [ ../modules/virtualisation/qemu-vm.nix

     

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

     

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

     

       38
       38
       -
                 { key = "no-revision";

     

       39
       39
       -
                   # Make the revision metadata constant, in order to avoid needless retesting.

     

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

     

       41
       41
       -
                   # for external modules that test with e.g. testers.nixosTest and rely on that

     

       42
       42
       -
                   # version number.

     

       43
       43
       -
                   config.system.nixos.revision = mkForce "constant-nixos-revision";

     

       44
       44
       -
                 }

     

       45
       45
       -
                 { key = "nodes"; _module.args.nodes = nodes; }

     

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

     

       47
       47
       -
           };

     

       48
       48
       -
       

     

       49
       49
       -
       

     

       50
       50
       -
         # Given an attribute set { machine1 = config1; ... machineN =

     

       51
       51
       -
         # configN; }, sequentially assign IP addresses in the 192.168.1.0/24

     

       52
       52
       -
         # range to each machine, and set the hostname to the attribute name.

     

       53
       53
       -
         assignIPAddresses = nodes:

     

       54
       54
       -
       

     

       55
       55
       -
           let

     

       56
       56
       -
       

     

       57
       57
       -
             machines = attrNames nodes;

     

       58
       58
       -
       

     

       59
       59
       -
             machinesNumbered = zipLists machines (range 1 254);

     

       60
       60
       -
       

     

       61
       61
       -
             nodes_ = forEach machinesNumbered (m: nameValuePair m.fst

     

       62
       62
       -
               [ ( { config, nodes, ... }:

     

       63
       63
       -
                   let

     

       64
       64
       -
                     interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);

     

       65
       65
       -
                     interfaces = forEach interfacesNumbered ({ fst, snd }:

     

       66
       66
       -
                       nameValuePair "eth${toString snd}" { ipv4.addresses =

     

       67
       67
       -
                         [ { address = "192.168.${toString fst}.${toString m.snd}";

     

       68
       68
       -
                             prefixLength = 24;

     

       69
       69
       -
                         } ];

     

       70
       70
       -
                       });

     

       71
       71
       -
       

     

       72
       72
       -
                     networkConfig =

     

       73
       73
       -
                       { networking.hostName = mkDefault m.fst;

     

       74
       74
       -
       

     

       75
       75
       -
                         networking.interfaces = listToAttrs interfaces;

     

       76
       76
       -
       

     

       77
       77
       -
                         networking.primaryIPAddress =

     

       78
       78
       -
                           optionalString (interfaces != []) (head (head interfaces).value.ipv4.addresses).address;

     

       79
       79
       -
       

     

       80
       80
       -
                         # Put the IP addresses of all VMs in this machine's

     

       81
       81
       -
                         # /etc/hosts file.  If a machine has multiple

     

       82
       82
       -
                         # interfaces, use the IP address corresponding to

     

       83
       83
       -
                         # the first interface (i.e. the first network in its

     

       84
       84
       -
                         # virtualisation.vlans option).

     

       85
       85
       -
                         networking.extraHosts = flip concatMapStrings machines

     

       86
       86
       -
                           (m': let config = (getAttr m' nodes).config; in

     

       87
       87
       -
                             optionalString (config.networking.primaryIPAddress != "")

     

       88
       88
       -
                               ("${config.networking.primaryIPAddress} " +

     

       89
       89
       -
                                optionalString (config.networking.domain != null)

     

       90
       90
       -
                                  "${config.networking.hostName}.${config.networking.domain} " +

     

       91
       91
       -
                                "${config.networking.hostName}\n"));

     

       92
       92
       -
       

     

       93
       93
       -
                         virtualisation.qemu.options =

     

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

     

       95
       95
       -
                           in flip concatMap interfacesNumbered

     

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

     

       97
       97
       -
                       };

     

       98
       98
       -
       

     

       99
       99
       -
                     in

     

       100
       100
       -
                       { key = "ip-address";

     

       101
       101
       -
                         config = networkConfig // {

     

       102
       102
       -
                           # Expose the networkConfig items for tests like nixops

     

       103
       103
       -
                           # that need to recreate the network config.

     

       104
       104
       -
                           system.build.networkConfig = networkConfig;

     

       105
       105
       -
                         };

     

       106
       106
       -
                       }

     

       107
       107
       -
                 )

     

       108
       108
       -
                 (getAttr m.fst nodes)

     

       109
       109
       -
               ] );

     

       110
       110
       -
       

     

       111
       111
       -
           in listToAttrs nodes_;

     

       112
       112
       -
       

     

       113
       113
       -
       }

nixos/lib/default.nix

···

       21
       21
        
         seqAttrsIf = cond: a: lib.mapAttrs (_: v: seqIf cond a v);

     

       22
       22
        
       

     

       23
       23
        
         eval-config-minimal = import ./eval-config-minimal.nix { inherit lib; };

     

       24
       24
       +
       

     

       25
       25
       +
         testing-lib = import ./testing/default.nix { inherit lib; };

     

       24
       26
        
       in

     

       25
       27
        
       /*

     

       26
       28
        
         This attribute set appears as lib.nixos in the flake, or can be imported

     
···

       30
       32
        
         inherit (seqAttrsIf (!featureFlags?minimalModules) minimalModulesWarning eval-config-minimal)

     

       31
       33
        
           evalModules

     

       32
       34
        
           ;

     

       35
       35
       +
       

     

       36
       36
       +
         inherit (testing-lib)

     

       37
       37
       +
           evalTest

     

       38
       38
       +
           runTest

     

       39
       39
       +
           ;

     

       40
       40
       +
       

     

       33
       41
        
       }

nixos/lib/eval-config.nix

···

       17
       17
        
         # be set modularly anyway.

     

       18
       18
        
         pkgs ? null

     

       19
       19
        
       , # !!! what do we gain by making this configurable?

     

       20
       20
       +
         #     we can add modules that are included in specialisations, regardless

     

       21
       21
       +
         #     of inheritParentConfig.

     

       20
       22
        
         baseModules ? import ../modules/module-list.nix

     

       21
       23
        
       , # !!! See comment about args in lib/modules.nix

     

       22
       24
        
         extraArgs ? {}

+21 -229

nixos/lib/testing-python.nix

···

       12
       12
        
       

     

       13
       13
        
       with pkgs;

     

       14
       14
        
       

     

       15
       15
       +
       let

     

       16
       16
       +
         nixos-lib = import ./default.nix { inherit (pkgs) lib; };

     

       17
       17
       +
       in

     

       18
       18
       +
       

     

       15
       19
        
       rec {

     

       16
       20
        
       

     

       17
       21
        
         inherit pkgs;

     

       18
       22
        
       

     

       19
       19
       -
         # Run an automated test suite in the given virtual network.

     

       20
       20
       -
         runTests = { driver, driverInteractive, pos }:

     

       21
       21
       -
           stdenv.mkDerivation {

     

       22
       22
       -
             name = "vm-test-run-${driver.testName}";

     

       23
       23
       -
       

     

       24
       24
       -
             requiredSystemFeatures = [ "kvm" "nixos-test" ];

     

       25
       25
       -
       

     

       26
       26
       -
             buildCommand =

     

       27
       27
       -
               ''

     

       28
       28
       -
                 mkdir -p $out

     

       29
       29
       -
       

     

       30
       30
       -
                 # effectively mute the XMLLogger

     

       31
       31
       -
                 export LOGFILE=/dev/null

     

       32
       32
       -
       

     

       33
       33
       -
                 ${driver}/bin/nixos-test-driver -o $out

     

       34
       34
       -
               '';

     

       35
       35
       -
       

     

       36
       36
       -
             passthru = driver.passthru // {

     

       37
       37
       -
               inherit driver driverInteractive;

     

       38
       38
       -
             };

     

       23
       23
       +
         evalTest = module: nixos-lib.evalTest { imports = [ extraTestModule module ]; };

     

       24
       24
       +
         runTest = module: nixos-lib.runTest { imports = [ extraTestModule module ]; };

     

       39
       25
        
       

     

       40
       40
       -
             inherit pos; # for better debugging

     

       26
       26
       +
         extraTestModule = {

     

       27
       27
       +
           config = {

     

       28
       28
       +
             hostPkgs = pkgs;

     

       41
       29
        
           };

     

       42
       42
       -
       

     

       43
       43
       -
         # Generate convenience wrappers for running the test driver

     

       44
       44
       -
         # has vlans, vms and test script defaulted through env variables

     

       45
       45
       -
         # also instantiates test script with nodes, if it's a function (contract)

     

       46
       46
       -
         setupDriverForTest = {

     

       47
       47
       -
             testScript

     

       48
       48
       -
           , testName

     

       49
       49
       -
           , nodes

     

       50
       50
       -
           , qemu_pkg ? pkgs.qemu_test

     

       51
       51
       -
           , enableOCR ? false

     

       52
       52
       -
           , skipLint ? false

     

       53
       53
       -
           , skipTypeCheck ? false

     

       54
       54
       -
           , passthru ? {}

     

       55
       55
       -
           , interactive ? false

     

       56
       56
       -
           , extraPythonPackages ? (_ :[])

     

       57
       57
       -
         }:

     

       58
       58
       -
           let

     

       59
       59
       -
             # Reifies and correctly wraps the python test driver for

     

       60
       60
       -
             # the respective qemu version and with or without ocr support

     

       61
       61
       -
             testDriver = pkgs.callPackage ./test-driver {

     

       62
       62
       -
               inherit enableOCR extraPythonPackages;

     

       63
       63
       -
               qemu_pkg = qemu_test;

     

       64
       64
       -
               imagemagick_light = imagemagick_light.override { inherit libtiff; };

     

       65
       65
       -
               tesseract4 = tesseract4.override { enableLanguages = [ "eng" ]; };

     

       66
       66
       -
             };

     

       67
       67
       -
       

     

       68
       68
       -
       

     

       69
       69
       -
             testDriverName =

     

       70
       70
       -
               let

     

       71
       71
       -
                 # A standard store path to the vm monitor is built like this:

     

       72
       72
       -
                 #   /tmp/nix-build-vm-test-run-$name.drv-0/vm-state-machine/monitor

     

       73
       73
       -
                 # The max filename length of a unix domain socket is 108 bytes.

     

       74
       74
       -
                 # This means $name can at most be 50 bytes long.

     

       75
       75
       -
                 maxTestNameLen = 50;

     

       76
       76
       -
                 testNameLen = builtins.stringLength testName;

     

       77
       77
       -
               in with builtins;

     

       78
       78
       -
                 if testNameLen > maxTestNameLen then

     

       79
       79
       -
                   abort

     

       80
       80
       -
                     ("The name of the test '${testName}' must not be longer than ${toString maxTestNameLen} " +

     

       81
       81
       -
                       "it's currently ${toString testNameLen} characters long.")

     

       82
       82
       -
                 else

     

       83
       83
       -
                   "nixos-test-driver-${testName}";

     

       84
       84
       -
       

     

       85
       85
       -
             vlans = map (m: m.config.virtualisation.vlans) (lib.attrValues nodes);

     

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

     

       87
       87
       -
       

     

       88
       88
       -
             nodeHostNames = let

     

       89
       89
       -
               nodesList = map (c: c.config.system.name) (lib.attrValues nodes);

     

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

     

       91
       91
       -
       

     

       92
       92
       -
             # TODO: This is an implementation error and needs fixing

     

       93
       93
       -
             # the testing famework cannot legitimately restrict hostnames further

     

       94
       94
       -
             # beyond RFC1035

     

       95
       95
       -
             invalidNodeNames = lib.filter

     

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

     

       97
       97
       -
               nodeHostNames;

     

       98
       98
       -
       

     

       99
       99
       -
             testScript' =

     

       100
       100
       -
               # Call the test script with the computed nodes.

     

       101
       101
       -
               if lib.isFunction testScript

     

       102
       102
       -
               then testScript { inherit nodes; }

     

       103
       103
       -
               else testScript;

     

       104
       104
       -
       

     

       105
       105
       -
             uniqueVlans = lib.unique (builtins.concatLists vlans);

     

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

     

       107
       107
       -
             machineNames = map (name: "${name}: Machine;") nodeHostNames;

     

       108
       108
       -
           in

     

       109
       109
       -
           if lib.length invalidNodeNames > 0 then

     

       110
       110
       -
             throw ''

     

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

     

       112
       112
       -
               All machines are referenced as python variables in the testing framework which will break the

     

       113
       113
       -
               script when special characters are used.

     

       114
       114
       -
       

     

       115
       115
       -
               This is an IMPLEMENTATION ERROR and needs to be fixed. Meanwhile,

     

       116
       116
       -
               please stick to alphanumeric chars and underscores as separation.

     

       117
       117
       -
             ''

     

       118
       118
       -
           else lib.warnIf skipLint "Linting is disabled" (runCommand testDriverName

     

       119
       119
       -
             {

     

       120
       120
       -
               inherit testName;

     

       121
       121
       -
               nativeBuildInputs = [ makeWrapper mypy ];

     

       122
       122
       -
               buildInputs = [ testDriver ];

     

       123
       123
       -
               testScript = testScript';

     

       124
       124
       -
               preferLocalBuild = true;

     

       125
       125
       -
               passthru = passthru // {

     

       126
       126
       -
                 inherit nodes;

     

       127
       127
       -
               };

     

       128
       128
       -
               meta.mainProgram = "nixos-test-driver";

     

       129
       129
       -
             }

     

       130
       130
       -
             ''

     

       131
       131
       -
               mkdir -p $out/bin

     

       132
       132
       -
       

     

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

     

       134
       134
       -
       

     

       135
       135
       -
               ${lib.optionalString (!skipTypeCheck) ''

     

       136
       136
       -
                 # prepend type hints so the test script can be type checked with mypy

     

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

     

       138
       138
       -
                 echo "${builtins.toString machineNames}" >> testScriptWithTypes

     

       139
       139
       -
                 echo "${builtins.toString vlanNames}" >> testScriptWithTypes

     

       140
       140
       -
                 echo -n "$testScript" >> testScriptWithTypes

     

       141
       141
       -
       

     

       142
       142
       -
                 mypy  --no-implicit-optional \

     

       143
       143
       -
                       --pretty \

     

       144
       144
       -
                       --no-color-output \

     

       145
       145
       -
                       testScriptWithTypes

     

       146
       146
       -
               ''}

     

       147
       147
       -
       

     

       148
       148
       -
               echo -n "$testScript" >> $out/test-script

     

       149
       149
       -
       

     

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

     

       151
       151
       -
       

     

       152
       152
       -
               ${testDriver}/bin/generate-driver-symbols

     

       153
       153
       -
               ${lib.optionalString (!skipLint) ''

     

       154
       154
       -
                 PYFLAKES_BUILTINS="$(

     

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

     

       156
       156
       -
                   < ${lib.escapeShellArg "driver-symbols"}

     

       157
       157
       -
                 )" ${python3Packages.pyflakes}/bin/pyflakes $out/test-script

     

       158
       158
       -
               ''}

     

       159
       159
       -
       

     

       160
       160
       -
               # set defaults through environment

     

       161
       161
       -
               # see: ./test-driver/test-driver.py argparse implementation

     

       162
       162
       -
               wrapProgram $out/bin/nixos-test-driver \

     

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

     

       164
       164
       -
                 --set testScript "$out/test-script" \

     

       165
       165
       -
                 --set vlans '${toString vlans}' \

     

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

     

       167
       167
       -
             '');

     

       30
       30
       +
         };

     

       168
       31
        
       

     

       169
       32
        
         # Make a full-blown test

     

       170
       33
        
         makeTest =

     
···

       184
       47
        
                 then builtins.unsafeGetAttrPos "description" meta

     

       185
       48
        
                 else builtins.unsafeGetAttrPos "testScript" t)

     

       186
       49
        
           , extraPythonPackages ? (_ : [])

     

       50
       50
       +
           , interactive ? {}

     

       187
       51
        
           } @ t:

     

       188
       188
       -
           let

     

       189
       189
       -
             mkNodes = qemu_pkg:

     

       190
       190
       -
               let

     

       191
       191
       -
                 testScript' =

     

       192
       192
       -
                   # Call the test script with the computed nodes.

     

       193
       193
       -
                   if lib.isFunction testScript

     

       194
       194
       -
                   then testScript { nodes = mkNodes qemu_pkg; }

     

       195
       195
       -
                   else testScript;

     

       196
       196
       -
       

     

       197
       197
       -
                 build-vms = import ./build-vms.nix {

     

       198
       198
       -
                   inherit system lib pkgs minimal specialArgs;

     

       199
       199
       -
                   extraConfigurations = extraConfigurations ++ [(

     

       200
       200
       -
                     { config, ... }:

     

       201
       201
       -
                     {

     

       202
       202
       -
                       virtualisation.qemu.package = qemu_pkg;

     

       203
       203
       -
       

     

       204
       204
       -
                       # Make sure all derivations referenced by the test

     

       205
       205
       -
                       # script are available on the nodes. When the store is

     

       206
       206
       -
                       # accessed through 9p, this isn't important, since

     

       207
       207
       -
                       # everything in the store is available to the guest,

     

       208
       208
       -
                       # but when building a root image it is, as all paths

     

       209
       209
       -
                       # that should be available to the guest has to be

     

       210
       210
       -
                       # copied to the image.

     

       211
       211
       -
                       virtualisation.additionalPaths =

     

       212
       212
       -
                         lib.optional

     

       213
       213
       -
                           # A testScript may evaluate nodes, which has caused

     

       214
       214
       -
                           # infinite recursions. The demand cycle involves:

     

       215
       215
       -
                           #   testScript -->

     

       216
       216
       -
                           #   nodes -->

     

       217
       217
       -
                           #   toplevel -->

     

       218
       218
       -
                           #   additionalPaths -->

     

       219
       219
       -
                           #   hasContext testScript' -->

     

       220
       220
       -
                           #   testScript (ad infinitum)

     

       221
       221
       -
                           # If we don't need to build an image, we can break this

     

       222
       222
       -
                           # cycle by short-circuiting when useNixStoreImage is false.

     

       223
       223
       -
                           (config.virtualisation.useNixStoreImage && builtins.hasContext testScript')

     

       224
       224
       -
                           (pkgs.writeStringReferencesToFile testScript');

     

       225
       225
       -
       

     

       226
       226
       -
                       # Ensure we do not use aliases. Ideally this is only set

     

       227
       227
       -
                       # when the test framework is used by Nixpkgs NixOS tests.

     

       228
       228
       -
                       nixpkgs.config.allowAliases = false;

     

       229
       229
       -
                     }

     

       230
       230
       -
                   )];

     

       231
       231
       -
                 };

     

       232
       232
       -
               in

     

       233
       233
       -
                 lib.warnIf (t?machine) "In test `${name}': The `machine' attribute in NixOS tests (pkgs.nixosTest / make-test-python.nix / testing-python.nix / makeTest) is deprecated. Please use the equivalent `nodes.machine'."

     

       234
       234
       -
                 build-vms.buildVirtualNetwork (

     

       235
       235
       -
                     nodes // lib.optionalAttrs (machine != null) { inherit machine; }

     

       236
       236
       -
                 );

     

       237
       237
       -
       

     

       238
       238
       -
             driver = setupDriverForTest {

     

       239
       239
       -
               inherit testScript enableOCR skipTypeCheck skipLint passthru extraPythonPackages;

     

       240
       240
       -
               testName = name;

     

       241
       241
       -
               qemu_pkg = pkgs.qemu_test;

     

       242
       242
       -
               nodes = mkNodes pkgs.qemu_test;

     

       52
       52
       +
             runTest {

     

       53
       53
       +
               imports = [

     

       54
       54
       +
                 { _file = "makeTest parameters"; config = t; }

     

       55
       55
       +
                 {

     

       56
       56
       +
                   defaults = {

     

       57
       57
       +
                     _file = "makeTest: extraConfigurations";

     

       58
       58
       +
                     imports = extraConfigurations;

     

       59
       59
       +
                   };

     

       60
       60
       +
                 }

     

       61
       61
       +
               ];

     

       243
       62
        
             };

     

       244
       244
       -
             driverInteractive = setupDriverForTest {

     

       245
       245
       -
               inherit testScript enableOCR skipTypeCheck skipLint passthru extraPythonPackages;

     

       246
       246
       -
               testName = name;

     

       247
       247
       -
               qemu_pkg = pkgs.qemu;

     

       248
       248
       -
               nodes = mkNodes pkgs.qemu;

     

       249
       249
       -
               interactive = true;

     

       250
       250
       -
             };

     

       251
       251
       -
       

     

       252
       252
       -
             test = lib.addMetaAttrs meta (runTests { inherit driver pos driverInteractive; });

     

       253
       253
       -
       

     

       254
       254
       -
           in

     

       255
       255
       -
             test // {

     

       256
       256
       -
               inherit test driver driverInteractive;

     

       257
       257
       -
               inherit (driver) nodes;

     

       258
       258
       -
             };

     

       259
       259
       -
       

     

       260
       260
       -
         abortForFunction = functionName: abort ''The ${functionName} function was

     

       261
       261
       -
           removed because it is not an essential part of the NixOS testing

     

       262
       262
       -
           infrastructure. It had no usage in NixOS or Nixpkgs and it had no designated

     

       263
       263
       -
           maintainer. You are free to reintroduce it by documenting it in the manual

     

       264
       264
       -
           and adding yourself as maintainer. It was removed in

     

       265
       265
       -
           https://github.com/NixOS/nixpkgs/pull/137013

     

       266
       266
       -
         '';

     

       267
       267
       -
       

     

       268
       268
       -
         runInMachine = abortForFunction "runInMachine";

     

       269
       269
       -
       

     

       270
       270
       -
         runInMachineWithX = abortForFunction "runInMachineWithX";

     

       271
       63
        
       

     

       272
       64
        
         simpleTest = as: (makeTest as).test;

     

       273
       65

+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
       +
       }

+24

nixos/lib/testing/default.nix

···

       1
       1
       +
       { lib }:

     

       2
       2
       +
       let

     

       3
       3
       +
       

     

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

     

       5
       5
       +
         runTest = module: (evalTest module).config.result;

     

       6
       6
       +
       

     

       7
       7
       +
         testModules = [

     

       8
       8
       +
           ./call-test.nix

     

       9
       9
       +
           ./driver.nix

     

       10
       10
       +
           ./interactive.nix

     

       11
       11
       +
           ./legacy.nix

     

       12
       12
       +
           ./meta.nix

     

       13
       13
       +
           ./name.nix

     

       14
       14
       +
           ./network.nix

     

       15
       15
       +
           ./nodes.nix

     

       16
       16
       +
           ./pkgs.nix

     

       17
       17
       +
           ./run.nix

     

       18
       18
       +
           ./testScript.nix

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
       in

     

       22
       22
       +
       {

     

       23
       23
       +
         inherit evalTest runTest testModules;

     

       24
       24
       +
       }

+188

nixos/lib/testing/driver.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types literalMD mdDoc;

     

       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
       +
               buildInputs = [ testDriver ];

     

       56
       56
       +
               testScript = config.testScriptString;

     

       57
       57
       +
               preferLocalBuild = true;

     

       58
       58
       +
               passthru = config.passthru;

     

       59
       59
       +
               meta = config.meta // {

     

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

     

       61
       61
       +
               };

     

       62
       62
       +
             }

     

       63
       63
       +
             ''

     

       64
       64
       +
               mkdir -p $out/bin

     

       65
       65
       +
       

     

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

     

       67
       67
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       74
       74
       +
       

     

       75
       75
       +
                 cat -n testScriptWithTypes

     

       76
       76
       +
       

     

       77
       77
       +
                 mypy  --no-implicit-optional \

     

       78
       78
       +
                       --pretty \

     

       79
       79
       +
                       --no-color-output \

     

       80
       80
       +
                       testScriptWithTypes

     

       81
       81
       +
               ''}

     

       82
       82
       +
       

     

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

     

       84
       84
       +
       

     

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

     

       86
       86
       +
       

     

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

     

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

     

       89
       89
       +
                 PYFLAKES_BUILTINS="$(

     

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

     

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

     

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

     

       93
       93
       +
               ''}

     

       94
       94
       +
       

     

       95
       95
       +
               # set defaults through environment

     

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

     

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

     

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

     

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

     

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

     

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

     

       102
       102
       +
             '';

     

       103
       103
       +
       

     

       104
       104
       +
       in

     

       105
       105
       +
       {

     

       106
       106
       +
         options = {

     

       107
       107
       +
       

     

       108
       108
       +
           driver = mkOption {

     

       109
       109
       +
             description = mdDoc "Package containing a script that runs the test.";

     

       110
       110
       +
             type = types.package;

     

       111
       111
       +
             defaultText = literalMD "set by the test framework";

     

       112
       112
       +
           };

     

       113
       113
       +
       

     

       114
       114
       +
           hostPkgs = mkOption {

     

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

     

       116
       116
       +
             type = types.raw;

     

       117
       117
       +
             example = lib.literalExpression ''

     

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

     

       119
       119
       +
             '';

     

       120
       120
       +
           };

     

       121
       121
       +
       

     

       122
       122
       +
           qemu.package = mkOption {

     

       123
       123
       +
             description = mdDoc "Which qemu package to use for the virtualisation of [{option}`nodes`](#opt-nodes).";

     

       124
       124
       +
             type = types.package;

     

       125
       125
       +
             default = hostPkgs.qemu_test;

     

       126
       126
       +
             defaultText = "hostPkgs.qemu_test";

     

       127
       127
       +
           };

     

       128
       128
       +
       

     

       129
       129
       +
           enableOCR = mkOption {

     

       130
       130
       +
             description = mdDoc ''

     

       131
       131
       +
               Whether to enable Optical Character Recognition functionality for

     

       132
       132
       +
               testing graphical programs. See [Machine objects](`ssec-machine-objects`).

     

       133
       133
       +
             '';

     

       134
       134
       +
             type = types.bool;

     

       135
       135
       +
             default = false;

     

       136
       136
       +
           };

     

       137
       137
       +
       

     

       138
       138
       +
           extraPythonPackages = mkOption {

     

       139
       139
       +
             description = mdDoc ''

     

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

     

       141
       141
       +
       

     

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

     

       143
       143
       +
             '';

     

       144
       144
       +
             example = lib.literalExpression ''

     

       145
       145
       +
               p: [ p.numpy ]

     

       146
       146
       +
             '';

     

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

     

       148
       148
       +
             default = ps: [ ];

     

       149
       149
       +
           };

     

       150
       150
       +
       

     

       151
       151
       +
           extraDriverArgs = mkOption {

     

       152
       152
       +
             description = mdDoc ''

     

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

     

       154
       154
       +
       

     

       155
       155
       +
               They become part of [{option}`driver`](#opt-driver) via `wrapProgram`.

     

       156
       156
       +
             '';

     

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

     

       158
       158
       +
             default = [];

     

       159
       159
       +
           };

     

       160
       160
       +
       

     

       161
       161
       +
           skipLint = mkOption {

     

       162
       162
       +
             type = types.bool;

     

       163
       163
       +
             default = false;

     

       164
       164
       +
             description = mdDoc ''

     

       165
       165
       +
               Do not run the linters. This may speed up your iteration cycle, but it is not something you should commit.

     

       166
       166
       +
             '';

     

       167
       167
       +
           };

     

       168
       168
       +
       

     

       169
       169
       +
           skipTypeCheck = mkOption {

     

       170
       170
       +
             type = types.bool;

     

       171
       171
       +
             default = false;

     

       172
       172
       +
             description = mdDoc ''

     

       173
       173
       +
               Disable type checking. This must not be enabled for new NixOS tests.

     

       174
       174
       +
       

     

       175
       175
       +
               This may speed up your iteration cycle, unless you're working on the [{option}`testScript`](#opt-testScript).

     

       176
       176
       +
             '';

     

       177
       177
       +
           };

     

       178
       178
       +
         };

     

       179
       179
       +
       

     

       180
       180
       +
         config = {

     

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

     

       182
       182
       +
       

     

       183
       183
       +
           driver = withChecks driver;

     

       184
       184
       +
       

     

       185
       185
       +
           # make available on the test runner

     

       186
       186
       +
           passthru.driver = config.driver;

     

       187
       187
       +
         };

     

       188
       188
       +
       }

+45

nixos/lib/testing/interactive.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types mdDoc;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           interactive = mkOption {

     

       8
       8
       +
             description = mdDoc ''

     

       9
       9
       +
               Tests [can be run interactively](#sec-running-nixos-tests-interactively)

     

       10
       10
       +
               using the program in the test derivation's `.driverInteractive` attribute.

     

       11
       11
       +
       

     

       12
       12
       +
               When they are, the configuration will include anything set in this submodule.

     

       13
       13
       +
       

     

       14
       14
       +
               You can set any top-level test option here.

     

       15
       15
       +
       

     

       16
       16
       +
               Example test module:

     

       17
       17
       +
       

     

       18
       18
       +
               ```nix

     

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

     

       20
       20
       +
       

     

       21
       21
       +
                 nodes.rabbitmq = {

     

       22
       22
       +
                   services.rabbitmq.enable = true;

     

       23
       23
       +
                 };

     

       24
       24
       +
       

     

       25
       25
       +
                 # When running interactively ...

     

       26
       26
       +
                 interactive.nodes.rabbitmq = {

     

       27
       27
       +
                   # ... enable the web ui.

     

       28
       28
       +
                   services.rabbitmq.managementPlugin.enable = true;

     

       29
       29
       +
                 };

     

       30
       30
       +
               }

     

       31
       31
       +
               ```

     

       32
       32
       +
       

     

       33
       33
       +
               For details, see the section about [running tests interactively](#sec-running-nixos-tests-interactively).

     

       34
       34
       +
             '';

     

       35
       35
       +
             type = moduleType;

     

       36
       36
       +
             visible = "shallow";

     

       37
       37
       +
           };

     

       38
       38
       +
         };

     

       39
       39
       +
       

     

       40
       40
       +
         config = {

     

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

     

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

     

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

     

       44
       44
       +
         };

     

       45
       45
       +
       }

+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
       +
       }

+42

nixos/lib/testing/meta.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption mdDoc;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           meta = lib.mkOption {

     

       8
       8
       +
             description = mdDoc ''

     

       9
       9
       +
               The [`meta`](https://nixos.org/manual/nixpkgs/stable/#chap-meta) attributes that will be set on the returned derivations.

     

       10
       10
       +
       

     

       11
       11
       +
               Not all [`meta`](https://nixos.org/manual/nixpkgs/stable/#chap-meta) attributes are supported, but more can be added as desired.

     

       12
       12
       +
             '';

     

       13
       13
       +
             apply = lib.filterAttrs (k: v: v != null);

     

       14
       14
       +
             type = types.submodule {

     

       15
       15
       +
               options = {

     

       16
       16
       +
                 maintainers = lib.mkOption {

     

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

     

       18
       18
       +
                   default = [];

     

       19
       19
       +
                   description = mdDoc ''

     

       20
       20
       +
                     The [list of maintainers](https://nixos.org/manual/nixpkgs/stable/#var-meta-maintainers) for this test.

     

       21
       21
       +
                   '';

     

       22
       22
       +
                 };

     

       23
       23
       +
                 timeout = lib.mkOption {

     

       24
       24
       +
                   type = types.nullOr types.int;

     

       25
       25
       +
                   default = null; # NOTE: null values are filtered out by `meta`.

     

       26
       26
       +
                   description = mdDoc ''

     

       27
       27
       +
                     The [{option}`test`](#opt-test)'s [`meta.timeout`](https://nixos.org/manual/nixpkgs/stable/#var-meta-timeout) in seconds.

     

       28
       28
       +
                   '';

     

       29
       29
       +
                 };

     

       30
       30
       +
                 broken = lib.mkOption {

     

       31
       31
       +
                   type = types.bool;

     

       32
       32
       +
                   default = false;

     

       33
       33
       +
                   description = mdDoc ''

     

       34
       34
       +
                     Sets the [`meta.broken`](https://nixos.org/manual/nixpkgs/stable/#var-meta-broken) attribute on the [{option}`test`](#opt-test) derivation.

     

       35
       35
       +
                   '';

     

       36
       36
       +
                 };

     

       37
       37
       +
               };

     

       38
       38
       +
             };

     

       39
       39
       +
             default = {};

     

       40
       40
       +
           };

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+14

nixos/lib/testing/name.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types mdDoc;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.name = mkOption {

     

       7
       7
       +
           description = mdDoc ''

     

       8
       8
       +
             The name of the test.

     

       9
       9
       +
       

     

       10
       10
       +
             This is used in the derivation names of the [{option}`driver`](#opt-driver) and [{option}`test`](#opt-test) runner.

     

       11
       11
       +
           '';

     

       12
       12
       +
           type = types.str;

     

       13
       13
       +
         };

     

       14
       14
       +
       }

+117

nixos/lib/testing/network.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (lib)

     

       5
       5
       +
           attrNames concatMap concatMapStrings flip forEach head

     

       6
       6
       +
           listToAttrs mkDefault mkOption nameValuePair optionalString

     

       7
       7
       +
           range types zipListsWith zipLists

     

       8
       8
       +
           mdDoc

     

       9
       9
       +
           ;

     

       10
       10
       +
       

     

       11
       11
       +
         nodeNumbers =

     

       12
       12
       +
           listToAttrs

     

       13
       13
       +
             (zipListsWith

     

       14
       14
       +
               nameValuePair

     

       15
       15
       +
               (attrNames nodes)

     

       16
       16
       +
               (range 1 254)

     

       17
       17
       +
             );

     

       18
       18
       +
       

     

       19
       19
       +
         networkModule = { config, nodes, pkgs, ... }:

     

       20
       20
       +
           let

     

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

     

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

     

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

     

       24
       24
       +
                 ipv4.addresses =

     

       25
       25
       +
                   [{

     

       26
       26
       +
                     address = "192.168.${toString fst}.${toString config.virtualisation.test.nodeNumber}";

     

       27
       27
       +
                     prefixLength = 24;

     

       28
       28
       +
                   }];

     

       29
       29
       +
               });

     

       30
       30
       +
       

     

       31
       31
       +
             networkConfig =

     

       32
       32
       +
               {

     

       33
       33
       +
                 networking.hostName = mkDefault config.virtualisation.test.nodeName;

     

       34
       34
       +
       

     

       35
       35
       +
                 networking.interfaces = listToAttrs interfaces;

     

       36
       36
       +
       

     

       37
       37
       +
                 networking.primaryIPAddress =

     

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

     

       39
       39
       +
       

     

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

     

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

     

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

     

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

     

       44
       44
       +
                 # virtualisation.vlans option).

     

       45
       45
       +
                 networking.extraHosts = flip concatMapStrings (attrNames nodes)

     

       46
       46
       +
                   (m':

     

       47
       47
       +
                     let config = nodes.${m'}; in

     

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

     

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

     

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

     

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

     

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

     

       53
       53
       +
       

     

       54
       54
       +
                 virtualisation.qemu.options =

     

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

     

       56
       56
       +
                   in

     

       57
       57
       +
                   flip concatMap interfacesNumbered

     

       58
       58
       +
                     ({ fst, snd }: qemu-common.qemuNICFlags snd fst config.virtualisation.test.nodeNumber);

     

       59
       59
       +
               };

     

       60
       60
       +
       

     

       61
       61
       +
           in

     

       62
       62
       +
           {

     

       63
       63
       +
             key = "ip-address";

     

       64
       64
       +
             config = networkConfig // {

     

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

     

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

     

       67
       67
       +
               system.build.networkConfig = networkConfig;

     

       68
       68
       +
             };

     

       69
       69
       +
           };

     

       70
       70
       +
       

     

       71
       71
       +
         nodeNumberModule = (regular@{ config, name, ... }: {

     

       72
       72
       +
           options = {

     

       73
       73
       +
             virtualisation.test.nodeName = mkOption {

     

       74
       74
       +
               internal = true;

     

       75
       75
       +
               default = name;

     

       76
       76
       +
               # We need to force this in specilisations, otherwise it'd be

     

       77
       77
       +
               # readOnly = true;

     

       78
       78
       +
               description = mdDoc ''

     

       79
       79
       +
                 The `name` in `nodes.<name>`; stable across `specialisations`.

     

       80
       80
       +
               '';

     

       81
       81
       +
             };

     

       82
       82
       +
             virtualisation.test.nodeNumber = mkOption {

     

       83
       83
       +
               internal = true;

     

       84
       84
       +
               type = types.int;

     

       85
       85
       +
               readOnly = true;

     

       86
       86
       +
               default = nodeNumbers.${config.virtualisation.test.nodeName};

     

       87
       87
       +
               description = mdDoc ''

     

       88
       88
       +
                 A unique number assigned for each node in `nodes`.

     

       89
       89
       +
               '';

     

       90
       90
       +
             };

     

       91
       91
       +
       

     

       92
       92
       +
             # specialisations override the `name` module argument,

     

       93
       93
       +
             # so we push the real `virtualisation.test.nodeName`.

     

       94
       94
       +
             specialisation = mkOption {

     

       95
       95
       +
               type = types.attrsOf (types.submodule {

     

       96
       96
       +
                 options.configuration = mkOption {

     

       97
       97
       +
                   type = types.submoduleWith {

     

       98
       98
       +
                     modules = [

     

       99
       99
       +
                       {

     

       100
       100
       +
                         config.virtualisation.test.nodeName =

     

       101
       101
       +
                           # assert regular.config.virtualisation.test.nodeName != "configuration";

     

       102
       102
       +
                           regular.config.virtualisation.test.nodeName;

     

       103
       103
       +
                       }

     

       104
       104
       +
                     ];

     

       105
       105
       +
                   };

     

       106
       106
       +
                 };

     

       107
       107
       +
               });

     

       108
       108
       +
             };

     

       109
       109
       +
           };

     

       110
       110
       +
         });

     

       111
       111
       +
       

     

       112
       112
       +
       in

     

       113
       113
       +
       {

     

       114
       114
       +
         config = {

     

       115
       115
       +
           extraBaseModules = { imports = [ networkModule nodeNumberModule ]; };

     

       116
       116
       +
         };

     

       117
       117
       +
       }

+23

nixos/lib/testing/nixos-test-base.nix

···

       1
       1
       +
       # A module containing the base imports and overrides that

     

       2
       2
       +
       # are always applied in NixOS VM tests, unconditionally,

     

       3
       3
       +
       # even in `inheritParentConfig = false` specialisations.

     

       4
       4
       +
       { lib, ... }:

     

       5
       5
       +
       let

     

       6
       6
       +
         inherit (lib) mkForce;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         imports = [

     

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

     

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

     

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

     

       13
       13
       +
           {

     

       14
       14
       +
             key = "no-revision";

     

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

     

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

     

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

     

       18
       18
       +
             # version number.

     

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

     

       20
       20
       +
           }

     

       21
       21
       +
       

     

       22
       22
       +
         ];

     

       23
       23
       +
       }

+112

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 mdDoc;

     

       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
       +
                 ./nixos-test-base.nix

     

       16
       16
       +
                 { key = "nodes"; _module.args.nodes = config.nodesCompat; }

     

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

     

       18
       18
       +
                   {

     

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

     

       20
       20
       +
       

     

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

     

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

     

       23
       23
       +
                     nixpkgs.config.allowAliases = false;

     

       24
       24
       +
                   })

     

       25
       25
       +
                 testModuleArgs.config.extraBaseModules

     

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

     

       27
       27
       +
           };

     

       28
       28
       +
       

     

       29
       29
       +
       

     

       30
       30
       +
       in

     

       31
       31
       +
       

     

       32
       32
       +
       {

     

       33
       33
       +
       

     

       34
       34
       +
         options = {

     

       35
       35
       +
           node.type = mkOption {

     

       36
       36
       +
             type = types.raw;

     

       37
       37
       +
             default = baseOS.type;

     

       38
       38
       +
             internal = true;

     

       39
       39
       +
           };

     

       40
       40
       +
       

     

       41
       41
       +
           nodes = mkOption {

     

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

     

       43
       43
       +
             visible = "shallow";

     

       44
       44
       +
             description = mdDoc ''

     

       45
       45
       +
               An attribute set of NixOS configuration modules.

     

       46
       46
       +
       

     

       47
       47
       +
               The configurations are augmented by the [`defaults`](#opt-defaults) option.

     

       48
       48
       +
       

     

       49
       49
       +
               They are assigned network addresses according to the `nixos/lib/testing/network.nix` module.

     

       50
       50
       +
       

     

       51
       51
       +
               A few special options are available, that aren't in a plain NixOS configuration. See [Configuring the nodes](#sec-nixos-test-nodes)

     

       52
       52
       +
             '';

     

       53
       53
       +
           };

     

       54
       54
       +
       

     

       55
       55
       +
           defaults = mkOption {

     

       56
       56
       +
             description = mdDoc ''

     

       57
       57
       +
               NixOS configuration that is applied to all [{option}`nodes`](#opt-nodes).

     

       58
       58
       +
             '';

     

       59
       59
       +
             type = types.deferredModule;

     

       60
       60
       +
             default = { };

     

       61
       61
       +
           };

     

       62
       62
       +
       

     

       63
       63
       +
           extraBaseModules = mkOption {

     

       64
       64
       +
             description = mdDoc ''

     

       65
       65
       +
               NixOS configuration that, like [{option}`defaults`](#opt-defaults), is applied to all [{option}`nodes`](#opt-nodes) and can not be undone with [`specialisation.<name>.inheritParentConfig`](https://search.nixos.org/options?show=specialisation.%3Cname%3E.inheritParentConfig&from=0&size=50&sort=relevance&type=packages&query=specialisation).

     

       66
       66
       +
             '';

     

       67
       67
       +
             type = types.deferredModule;

     

       68
       68
       +
             default = { };

     

       69
       69
       +
           };

     

       70
       70
       +
       

     

       71
       71
       +
           node.specialArgs = mkOption {

     

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

     

       73
       73
       +
             default = { };

     

       74
       74
       +
             description = mdDoc ''

     

       75
       75
       +
               An attribute set of arbitrary values that will be made available as module arguments during the resolution of module `imports`.

     

       76
       76
       +
       

     

       77
       77
       +
               Note that it is not possible to override these from within the NixOS configurations. If you argument is not relevant to `imports`, consider setting {option}`defaults._module.args.<name>` instead.

     

       78
       78
       +
             '';

     

       79
       79
       +
           };

     

       80
       80
       +
       

     

       81
       81
       +
           minimal = mkOption {

     

       82
       82
       +
             type = types.bool;

     

       83
       83
       +
             default = false;

     

       84
       84
       +
             description = mdDoc ''

     

       85
       85
       +
               Enable to configure all [{option}`nodes`](#opt-nodes) to run with a minimal kernel.

     

       86
       86
       +
             '';

     

       87
       87
       +
           };

     

       88
       88
       +
       

     

       89
       89
       +
           nodesCompat = mkOption {

     

       90
       90
       +
             internal = true;

     

       91
       91
       +
             description = mdDoc ''

     

       92
       92
       +
               Basically `_module.args.nodes`, but with backcompat and warnings added.

     

       93
       93
       +
       

     

       94
       94
       +
               This will go away.

     

       95
       95
       +
             '';

     

       96
       96
       +
           };

     

       97
       97
       +
         };

     

       98
       98
       +
       

     

       99
       99
       +
         config = {

     

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

     

       101
       101
       +
           nodesCompat =

     

       102
       102
       +
             mapAttrs

     

       103
       103
       +
               (name: config: config // {

     

       104
       104
       +
                 config = lib.warn

     

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

     

       106
       106
       +
                   config;

     

       107
       107
       +
               })

     

       108
       108
       +
               config.nodes;

     

       109
       109
       +
       

     

       110
       110
       +
           passthru.nodes = config.nodesCompat;

     

       111
       111
       +
         };

     

       112
       112
       +
       }

+11

nixos/lib/testing/pkgs.nix

···

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

     

       2
       2
       +
       {

     

       3
       3
       +
         config = {

     

       4
       4
       +
           # default pkgs for use in VMs

     

       5
       5
       +
           _module.args.pkgs = hostPkgs;

     

       6
       6
       +
       

     

       7
       7
       +
           defaults = {

     

       8
       8
       +
             # TODO: a module to set a shared pkgs, if options.nixpkgs.* is untouched by user (highestPrio) */

     

       9
       9
       +
           };

     

       10
       10
       +
         };

     

       11
       11
       +
       }

+57

nixos/lib/testing/run.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) types mkOption mdDoc;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options = {

     

       7
       7
       +
           passthru = mkOption {

     

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

     

       9
       9
       +
             description = mdDoc ''

     

       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
       +
           test = mkOption {

     

       20
       20
       +
             type = types.package;

     

       21
       21
       +
             # TODO: can the interactive driver be configured to access the network?

     

       22
       22
       +
             description = mdDoc ''

     

       23
       23
       +
               Derivation that runs the test as its "build" process.

     

       24
       24
       +
       

     

       25
       25
       +
               This implies that NixOS tests run isolated from the network, making them

     

       26
       26
       +
               more dependable.

     

       27
       27
       +
             '';

     

       28
       28
       +
           };

     

       29
       29
       +
         };

     

       30
       30
       +
       

     

       31
       31
       +
         config = {

     

       32
       32
       +
           test = lib.lazyDerivation { # lazyDerivation improves performance when only passthru items and/or meta are used.

     

       33
       33
       +
             derivation = hostPkgs.stdenv.mkDerivation {

     

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

     

       35
       35
       +
       

     

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

     

       37
       37
       +
       

     

       38
       38
       +
               buildCommand = ''

     

       39
       39
       +
                 mkdir -p $out

     

       40
       40
       +
       

     

       41
       41
       +
                 # effectively mute the XMLLogger

     

       42
       42
       +
                 export LOGFILE=/dev/null

     

       43
       43
       +
       

     

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

     

       45
       45
       +
               '';

     

       46
       46
       +
       

     

       47
       47
       +
               passthru = config.passthru;

     

       48
       48
       +
       

     

       49
       49
       +
               meta = config.meta;

     

       50
       50
       +
             };

     

       51
       51
       +
             inherit (config) passthru meta;

     

       52
       52
       +
           };

     

       53
       53
       +
       

     

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

     

       55
       55
       +
           passthru.config = config;

     

       56
       56
       +
         };

     

       57
       57
       +
       }

+84

nixos/lib/testing/testScript.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types mdDoc;

     

       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
       +
             description = ''

     

       11
       11
       +
               A series of python declarations and statements that you write to perform

     

       12
       12
       +
               the test.

     

       13
       13
       +
             '';

     

       14
       14
       +
           };

     

       15
       15
       +
           testScriptString = mkOption {

     

       16
       16
       +
             type = str;

     

       17
       17
       +
             readOnly = true;

     

       18
       18
       +
             internal = true;

     

       19
       19
       +
           };

     

       20
       20
       +
       

     

       21
       21
       +
           includeTestScriptReferences = mkOption {

     

       22
       22
       +
             type = types.bool;

     

       23
       23
       +
             default = true;

     

       24
       24
       +
             internal = true;

     

       25
       25
       +
           };

     

       26
       26
       +
           withoutTestScriptReferences = mkOption {

     

       27
       27
       +
             type = moduleType;

     

       28
       28
       +
             description = mdDoc ''

     

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

     

       30
       30
       +
             '';

     

       31
       31
       +
             internal = true;

     

       32
       32
       +
             visible = false;

     

       33
       33
       +
           };

     

       34
       34
       +
         };

     

       35
       35
       +
         config = {

     

       36
       36
       +
           withoutTestScriptReferences.includeTestScriptReferences = false;

     

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

     

       38
       38
       +
       

     

       39
       39
       +
           testScriptString =

     

       40
       40
       +
             if lib.isFunction config.testScript

     

       41
       41
       +
             then

     

       42
       42
       +
               config.testScript

     

       43
       43
       +
                 {

     

       44
       44
       +
                   nodes =

     

       45
       45
       +
                     lib.mapAttrs

     

       46
       46
       +
                       (k: v:

     

       47
       47
       +
                         if v.virtualisation.useNixStoreImage

     

       48
       48
       +
                         then

     

       49
       49
       +
                         # prevent infinite recursion when testScript would

     

       50
       50
       +
                         # reference v's toplevel

     

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

     

       52
       52
       +
                         else

     

       53
       53
       +
                         # reuse memoized config

     

       54
       54
       +
                           v

     

       55
       55
       +
                       )

     

       56
       56
       +
                       config.nodesCompat;

     

       57
       57
       +
                 }

     

       58
       58
       +
             else config.testScript;

     

       59
       59
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       67
       67
       +
             # copied to the image.

     

       68
       68
       +
             virtualisation.additionalPaths =

     

       69
       69
       +
               lib.optional

     

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

     

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

     

       72
       72
       +
                 #   testScript -->

     

       73
       73
       +
                 #   nodes -->

     

       74
       74
       +
                 #   toplevel -->

     

       75
       75
       +
                 #   additionalPaths -->

     

       76
       76
       +
                 #   hasContext testScript' -->

     

       77
       77
       +
                 #   testScript (ad infinitum)

     

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

     

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

     

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

     

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

     

       82
       82
       +
           };

     

       83
       83
       +
         };

     

       84
       84
       +
       }

+1 -1

nixos/modules/installer/tools/nixos-build-vms/build-vms.nix

···

       15
       15
        
           inherit system pkgs;

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         interactiveDriver = (testing.makeTest { inherit nodes; testScript = "start_all(); join_all();"; }).driverInteractive;

     

       18
       18
       +
         interactiveDriver = (testing.makeTest { inherit nodes; name = "network"; testScript = "start_all(); join_all();"; }).driverInteractive;

     

       19
       19
        
       in

     

       20
       20
        
       

     

       21
       21

+4 -4

nixos/release.nix

···

       22
       22
        
           import ./tests/all-tests.nix {

     

       23
       23
        
             inherit system;

     

       24
       24
        
             pkgs = import ./.. { inherit system; };

     

       25
       25
       -
             callTest = t: {

     

       26
       26
       -
               ${system} = hydraJob t.test;

     

       25
       25
       +
             callTest = config: {

     

       26
       26
       +
               ${system} = hydraJob config.test;

     

       27
       27
        
             };

     

       28
       28
        
           } // {

     

       29
       29
        
             # for typechecking of the scripts and evaluation of

     
···

       32
       32
        
               import ./tests/all-tests.nix {

     

       33
       33
        
               inherit system;

     

       34
       34
        
               pkgs = import ./.. { inherit system; };

     

       35
       35
       -
               callTest = t: {

     

       36
       36
       -
                 ${system} = hydraJob t.test.driver;

     

       35
       35
       +
               callTest = config: {

     

       36
       36
       +
                 ${system} = hydraJob config.driver;

     

       37
       37
        
               };

     

       38
       38
        
             };

     

       39
       39
        
           };

+4 -4

nixos/tests/3proxy.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ pkgs, ...} : {

     

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

     

       2
       2
        
         name = "3proxy";

     

       3
       3
       -
         meta = with pkgs.lib.maintainers; {

     

       3
       3
       +
         meta = with lib.maintainers; {

     

       4
       4
        
           maintainers = [ misuzu ];

     

       5
       5
        
         };

     

       6
       6
        
       

     
···

       92
       92
        
             networking.firewall.allowedTCPPorts = [ 3128 9999 ];

     

       93
       93
        
           };

     

       94
       94
        
       

     

       95
       95
       -
           peer3 = { lib, ... }: {

     

       95
       95
       +
           peer3 = { lib, pkgs, ... }: {

     

       96
       96
        
             networking.useDHCP = false;

     

       97
       97
        
             networking.interfaces.eth1 = {

     

       98
       98
        
               ipv4.addresses = [

     
···

       186
       186
        
               "${pkgs.wget}/bin/wget -e use_proxy=yes -e http_proxy=http://192.168.0.4:3128 -S -O /dev/null http://127.0.0.1:9999"

     

       187
       187
        
           )

     

       188
       188
        
         '';

     

       189
       189
       -
       })

     

       189
       189
       +
       }

+7 -7

nixos/tests/acme.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ pkgs, lib, ... }: let

     

       1
       1
       +
       { pkgs, lib, ... }: let

     

       2
       2
        
         commonConfig = ./common/acme/client;

     

       3
       3
        
       

     

       4
       4
       -
         dnsServerIP = nodes: nodes.dnsserver.config.networking.primaryIPAddress;

     

       4
       4
       +
         dnsServerIP = nodes: nodes.dnsserver.networking.primaryIPAddress;

     

       5
       5
        
       

     

       6
       6
        
         dnsScript = nodes: let

     

       7
       7
        
           dnsAddress = dnsServerIP nodes;

     
···

       153
       153
        
               description = "Pebble ACME challenge test server";

     

       154
       154
        
               wantedBy = [ "network.target" ];

     

       155
       155
        
               serviceConfig = {

     

       156
       156
       -
                 ExecStart = "${pkgs.pebble}/bin/pebble-challtestsrv -dns01 ':53' -defaultIPv6 '' -defaultIPv4 '${nodes.webserver.config.networking.primaryIPAddress}'";

     

       156
       156
       +
                 ExecStart = "${pkgs.pebble}/bin/pebble-challtestsrv -dns01 ':53' -defaultIPv6 '' -defaultIPv4 '${nodes.webserver.networking.primaryIPAddress}'";

     

       157
       157
        
                 # Required to bind on privileged ports.

     

       158
       158
        
                 AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];

     

       159
       159
        
               };

     
···

       175
       175
        
             specialisation = {

     

       176
       176
        
               # First derivation used to test general ACME features

     

       177
       177
        
               general.configuration = { ... }: let

     

       178
       178
       -
                 caDomain = nodes.acme.config.test-support.acme.caDomain;

     

       178
       178
       +
                 caDomain = nodes.acme.test-support.acme.caDomain;

     

       179
       179
        
                 email = config.security.acme.defaults.email;

     

       180
       180
        
                 # Exit 99 to make it easier to track if this is the reason a renew failed

     

       181
       181
        
                 accountCreateTester = ''

     
···

       316
       316
        
       

     

       317
       317
        
         testScript = { nodes, ... }:

     

       318
       318
        
           let

     

       319
       319
       -
             caDomain = nodes.acme.config.test-support.acme.caDomain;

     

       319
       319
       +
             caDomain = nodes.acme.test-support.acme.caDomain;

     

       320
       320
        
             newServerSystem = nodes.webserver.config.system.build.toplevel;

     

       321
       321
        
             switchToNewServer = "${newServerSystem}/bin/switch-to-configuration test";

     

       322
       322
        
           in

     
···

       438
       438
        
             client.wait_for_unit("default.target")

     

       439
       439
        
       

     

       440
       440
        
             client.succeed(

     

       441
       441
       -
                 'curl --data \'{"host": "${caDomain}", "addresses": ["${nodes.acme.config.networking.primaryIPAddress}"]}\' http://${dnsServerIP nodes}:8055/add-a'

     

       441
       441
       +
                 'curl --data \'{"host": "${caDomain}", "addresses": ["${nodes.acme.networking.primaryIPAddress}"]}\' http://${dnsServerIP nodes}:8055/add-a'

     

       442
       442
        
             )

     

       443
       443
        
       

     

       444
       444
        
             acme.wait_for_unit("network-online.target")

     
···

       594
       594
        
                     wait_for_server()

     

       595
       595
        
                     check_connection_key_bits(client, test_domain, "384")

     

       596
       596
        
           '';

     

       597
       597
       -
       })

     

       597
       597
       +
       }

+1 -1

nixos/tests/adguardhome.nix

···

       1
       1
       -
       import ./make-test-python.nix {

     

       1
       1
       +
       {

     

       2
       2
        
         name = "adguardhome";

     

       3
       3
        
       

     

       4
       4
        
         nodes = {

+2 -2

nixos/tests/aesmd.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ pkgs, lib, ... }: {

     

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

     

       2
       2
        
         name = "aesmd";

     

       3
       3
        
         meta = {

     

       4
       4
        
           maintainers = with lib.maintainers; [ veehaitch ];

     
···

       59
       59
        
       

     

       60
       60
        
             assert aesmd_config == "whitelist url = http://nixos.org\nproxy type = direct\ndefault quoting type = ecdsa_256\n", "aesmd.conf differs"

     

       61
       61
        
         '';

     

       62
       62
       -
       })

     

       62
       62
       +
       }

+47 -9

nixos/tests/all-tests.nix

···

       1
       1
       -
       { system, pkgs, callTest }:

     

       1
       1
       +
       { system,

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
       

     

       4
       4
       +
         # Projects the test configuration into a the desired value; usually

     

       5
       5
       +
         # the test runner: `config: config.test`.

     

       6
       6
       +
         callTest,

     

       7
       7
       +
       

     

       8
       8
       +
       }:

     

       2
       9
        
       # The return value of this function will be an attrset with arbitrary depth and

     

       3
       10
        
       # the `anything` returned by callTest at its test leafs.

     

       4
       11
        
       # The tests not supported by `system` will be replaced with `{}`, so that

     
···

       11
       18
        
       

     

       12
       19
        
       let

     

       13
       20
        
         discoverTests = val:

     

       14
       14
       -
           if !isAttrs val then val

     

       15
       15
       -
           else if hasAttr "test" val then callTest val

     

       16
       16
       -
           else mapAttrs (n: s: discoverTests s) val;

     

       21
       21
       +
           if isAttrs val

     

       22
       22
       +
           then

     

       23
       23
       +
             if hasAttr "test" val then callTest val

     

       24
       24
       +
             else mapAttrs (n: s: discoverTests s) val

     

       25
       25
       +
           else if isFunction val

     

       26
       26
       +
             then

     

       27
       27
       +
               # Tests based on make-test-python.nix will return the second lambda

     

       28
       28
       +
               # in that file, which are then forwarded to the test definition

     

       29
       29
       +
               # following the `import make-test-python.nix` expression

     

       30
       30
       +
               # (if it is a function).

     

       31
       31
       +
               discoverTests (val { inherit system pkgs; })

     

       32
       32
       +
             else val;

     

       17
       33
        
         handleTest = path: args:

     

       18
       34
        
           discoverTests (import path ({ inherit system pkgs; } // args));

     

       19
       35
        
         handleTestOn = systems: path: args:

     
···

       27
       43
        
         };

     

       28
       44
        
         evalMinimalConfig = module: nixosLib.evalModules { modules = [ module ]; };

     

       29
       45
        
       

     

       46
       46
       +
         inherit

     

       47
       47
       +
           (rec {

     

       48
       48
       +
             doRunTest = arg: (import ../lib/testing-python.nix { inherit system pkgs; }).runTest {

     

       49
       49
       +
               imports = [ arg { inherit callTest; } ];

     

       50
       50
       +
             };

     

       51
       51
       +
             findTests = tree:

     

       52
       52
       +
               if tree?recurseForDerivations && tree.recurseForDerivations

     

       53
       53
       +
               then

     

       54
       54
       +
                 mapAttrs

     

       55
       55
       +
                   (k: findTests)

     

       56
       56
       +
                   (builtins.removeAttrs tree ["recurseForDerivations"])

     

       57
       57
       +
               else callTest tree;

     

       58
       58
       +
       

     

       59
       59
       +
             runTest = arg: let r = doRunTest arg; in findTests r;

     

       60
       60
       +
             runTestOn = systems: arg:

     

       61
       61
       +
               if elem system systems then runTest arg

     

       62
       62
       +
               else {};

     

       63
       63
       +
           })

     

       64
       64
       +
           runTest

     

       65
       65
       +
           runTestOn

     

       66
       66
       +
           ;

     

       67
       67
       +
       

     

       30
       68
        
       in {

     

       31
       31
       -
         _3proxy = handleTest ./3proxy.nix {};

     

       32
       32
       -
         acme = handleTest ./acme.nix {};

     

       33
       33
       -
         adguardhome = handleTest ./adguardhome.nix {};

     

       34
       34
       -
         aesmd = handleTest ./aesmd.nix {};

     

       35
       35
       -
         agate = handleTest ./web-servers/agate.nix {};

     

       69
       69
       +
         _3proxy = runTest ./3proxy.nix;

     

       70
       70
       +
         acme = runTest ./acme.nix;

     

       71
       71
       +
         adguardhome = runTest ./adguardhome.nix;

     

       72
       72
       +
         aesmd = runTest ./aesmd.nix;

     

       73
       73
       +
         agate = runTest ./web-servers/agate.nix;

     

       36
       74
        
         agda = handleTest ./agda.nix {};

     

       37
       75
        
         airsonic = handleTest ./airsonic.nix {};

     

       38
       76
        
         allTerminfo = handleTest ./all-terminfo.nix {};

+2 -2

nixos/tests/common/acme/client/default.nix

···

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

     

       2
       2
        
       let

     

       3
       3
       -
         caCert = nodes.acme.config.test-support.acme.caCert;

     

       4
       4
       -
         caDomain = nodes.acme.config.test-support.acme.caDomain;

     

       3
       3
       +
         caCert = nodes.acme.test-support.acme.caCert;

     

       4
       4
       +
         caDomain = nodes.acme.test-support.acme.caDomain;

     

       5
       5
        
       

     

       6
       6
        
       in {

     

       7
       7
        
         security.acme = {

+3 -3

nixos/tests/common/acme/server/default.nix

···

       18
       18
        
       #

     

       19
       19
        
       #   example = { nodes, ... }: {

     

       20
       20
        
       #     networking.nameservers = [

     

       21
       21
       -
       #       nodes.acme.config.networking.primaryIPAddress

     

       21
       21
       +
       #       nodes.acme.networking.primaryIPAddress

     

       22
       22
        
       #     ];

     

       23
       23
        
       #     security.pki.certificateFiles = [

     

       24
       24
       -
       #       nodes.acme.config.test-support.acme.caCert

     

       24
       24
       +
       #       nodes.acme.test-support.acme.caCert

     

       25
       25
        
       #     ];

     

       26
       26
        
       #   };

     

       27
       27
        
       # }

     
···

       36
       36
        
       #   acme = { nodes, lib, ... }: {

     

       37
       37
        
       #     imports = [ ./common/acme/server ];

     

       38
       38
        
       #     networking.nameservers = lib.mkForce [

     

       39
       39
       -
       #       nodes.myresolver.config.networking.primaryIPAddress

     

       39
       39
       +
       #       nodes.myresolver.networking.primaryIPAddress

     

       40
       40
        
       #     ];

     

       41
       41
        
       #   };

     

       42
       42
        
       #

nixos/tests/corerad.nix

···

       1
       1
        
       import ./make-test-python.nix (

     

       2
       2
        
         {

     

       3
       3
       +
           name = "corerad";

     

       3
       4
        
           nodes = {

     

       4
       5
        
             router = {config, pkgs, ...}: {

     

       5
       6
        
               config = {

+1 -1

nixos/tests/cri-o.nix

···

       1
       1
        
       # This test runs CRI-O and verifies via critest

     

       2
       2
        
       import ./make-test-python.nix ({ pkgs, ... }: {

     

       3
       3
        
         name = "cri-o";

     

       4
       4
       -
         meta.maintainers = with pkgs.lib.maintainers; teams.podman.members;

     

       4
       4
       +
         meta.maintainers = with pkgs.lib; teams.podman.members;

     

       5
       5
        
       

     

       6
       6
        
         nodes = {

     

       7
       7
        
           crio = {

nixos/tests/ghostunnel.nix

···

       1
       1
        
       import ./make-test-python.nix ({ pkgs, ... }: {

     

       2
       2
       +
         name = "ghostunnel";

     

       2
       3
        
         nodes = {

     

       3
       4
        
           backend = { pkgs, ... }: {

     

       4
       5
        
             services.nginx.enable = true;

+1 -1

nixos/tests/installed-tests/default.nix

···

       40
       40
        
                 name = tested.name;

     

       41
       41
        
       

     

       42
       42
        
                 meta = {

     

       43
       43
       -
                   maintainers = tested.meta.maintainers;

     

       43
       43
       +
                   maintainers = tested.meta.maintainers or [];

     

       44
       44
        
                 };

     

       45
       45
        
       

     

       46
       46
        
                 nodes.machine = { ... }: {

+10

nixos/tests/installer.nix

···

       324
       324
        
                   desktop-file-utils

     

       325
       325
        
                   docbook5

     

       326
       326
        
                   docbook_xsl_ns

     

       327
       327
       +
                   (docbook-xsl-ns.override {

     

       328
       328
       +
                     withManOptDedupPatch = true;

     

       329
       329
       +
                   })

     

       327
       330
        
                   kmod.dev

     

       328
       331
        
                   libarchive.dev

     

       329
       332
        
                   libxml2.bin

     
···

       333
       336
        
                   perlPackages.ListCompare

     

       334
       337
        
                   perlPackages.XMLLibXML

     

       335
       338
        
                   python3Minimal

     

       339
       339
       +
                   # make-options-doc/default.nix

     

       340
       340
       +
                   (let

     

       341
       341
       +
                       self = (pkgs.python3Minimal.override {

     

       342
       342
       +
                         inherit self;

     

       343
       343
       +
                         includeSiteCustomize = true;

     

       344
       344
       +
                       });

     

       345
       345
       +
                     in self.withPackages (p: [ p.mistune ]))

     

       336
       346
        
                   shared-mime-info

     

       337
       347
        
                   sudo

     

       338
       348
        
                   texinfo

nixos/tests/lorri/default.nix

···

       1
       1
        
       import ../make-test-python.nix {

     

       2
       2
       +
         name = "lorri";

     

       3
       3
       +
       

     

       2
       4
        
         nodes.machine = { pkgs, ... }: {

     

       3
       5
        
           imports = [ ../../modules/profiles/minimal.nix ];

     

       4
       6
        
           environment.systemPackages = [ pkgs.lorri ];

nixos/tests/matomo.nix

···

       7
       7
        
       let

     

       8
       8
        
         matomoTest = package:

     

       9
       9
        
         makeTest {

     

       10
       10
       +
           name = "matomo";

     

       11
       11
       +
       

     

       10
       12
        
           nodes.machine = { config, pkgs, ... }: {

     

       11
       13
        
             services.matomo = {

     

       12
       14
        
               package = package;

nixos/tests/matrix/conduit.nix

···

       3
       3
        
           name = "conduit";

     

       4
       4
        
         in

     

       5
       5
        
         {

     

       6
       6
       +
           name = "matrix-conduit";

     

       7
       7
       +
       

     

       6
       8
        
           nodes = {

     

       7
       9
        
             conduit = args: {

     

       8
       10
        
               services.matrix-conduit = {

nixos/tests/nixops/default.nix

···

       19
       19
        
         });

     

       20
       20
        
       

     

       21
       21
        
         testLegacyNetwork = { nixopsPkg }: pkgs.nixosTest ({

     

       22
       22
       +
           name = "nixops-legacy-network";

     

       22
       23
        
           nodes = {

     

       23
       24
        
             deployer = { config, lib, nodes, pkgs, ... }: {

     

       24
       25
        
               imports = [ ../../modules/installer/cd-dvd/channel.nix ];

nixos/tests/pam/pam-file-contents.nix

···

       2
       2
        
         name = "pam";

     

       3
       3
        
       in

     

       4
       4
        
       import ../make-test-python.nix ({ pkgs, ... }: {

     

       5
       5
       +
         name = "pam-file-contents";

     

       5
       6
        
       

     

       6
       7
        
         nodes.machine = { ... }: {

     

       7
       8
        
           imports = [ ../../modules/profiles/minimal.nix ];

nixos/tests/pppd.nix

···

       5
       5
        
             mode = "0640";

     

       6
       6
        
           };

     

       7
       7
        
         in {

     

       8
       8
       +
           name = "pppd";

     

       9
       9
       +
       

     

       8
       10
        
           nodes = {

     

       9
       11
        
             server = {config, pkgs, ...}: {

     

       10
       12
        
               config = {

nixos/tests/thelounge.nix

···

       1
       1
        
       import ./make-test-python.nix {

     

       2
       2
       +
         name = "thelounge";

     

       3
       3
       +
       

     

       2
       4
        
         nodes = {

     

       3
       5
        
           private = { config, pkgs, ... }: {

     

       4
       6
        
             services.thelounge = {

+22 -24

nixos/tests/web-servers/agate.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
         {

     

       4
       4
       -
           name = "agate";

     

       5
       5
       -
           meta = with lib.maintainers; { maintainers = [ jk ]; };

     

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

     

       2
       2
       +
       {

     

       3
       3
       +
         name = "agate";

     

       4
       4
       +
         meta = with lib.maintainers; { maintainers = [ jk ]; };

     

       6
       5
        
       

     

       7
       7
       -
           nodes = {

     

       8
       8
       -
             geminiserver = { pkgs, ... }: {

     

       9
       9
       -
               services.agate = {

     

       10
       10
       -
                 enable = true;

     

       11
       11
       -
                 hostnames = [ "localhost" ];

     

       12
       12
       -
                 contentDir = pkgs.writeTextDir "index.gmi" ''

     

       13
       13
       -
                   # Hello NixOS!

     

       14
       14
       -
                 '';

     

       15
       15
       -
               };

     

       6
       6
       +
         nodes = {

     

       7
       7
       +
           geminiserver = { pkgs, ... }: {

     

       8
       8
       +
             services.agate = {

     

       9
       9
       +
               enable = true;

     

       10
       10
       +
               hostnames = [ "localhost" ];

     

       11
       11
       +
               contentDir = pkgs.writeTextDir "index.gmi" ''

     

       12
       12
       +
                 # Hello NixOS!

     

       13
       13
       +
               '';

     

       16
       14
        
             };

     

       17
       15
        
           };

     

       16
       16
       +
         };

     

       18
       17
        
       

     

       19
       19
       -
           testScript = { nodes, ... }: ''

     

       20
       20
       -
             geminiserver.wait_for_unit("agate")

     

       21
       21
       -
             geminiserver.wait_for_open_port(1965)

     

       18
       18
       +
         testScript = { nodes, ... }: ''

     

       19
       19
       +
           geminiserver.wait_for_unit("agate")

     

       20
       20
       +
           geminiserver.wait_for_open_port(1965)

     

       22
       21
        
       

     

       23
       23
       -
             with subtest("check is serving over gemini"):

     

       24
       24
       -
               response = geminiserver.succeed("${pkgs.gmni}/bin/gmni -j once -i -N gemini://localhost:1965")

     

       25
       25
       -
               print(response)

     

       26
       26
       -
               assert "Hello NixOS!" in response

     

       27
       27
       -
           '';

     

       28
       28
       -
         }

     

       29
       29
       -
       )

     

       22
       22
       +
           with subtest("check is serving over gemini"):

     

       23
       23
       +
             response = geminiserver.succeed("${pkgs.gmni}/bin/gmni -j once -i -N gemini://localhost:1965")

     

       24
       24
       +
             print(response)

     

       25
       25
       +
             assert "Hello NixOS!" in response

     

       26
       26
       +
         '';

     

       27
       27
       +
       }

nixos/tests/zrepl.nix

···

       1
       1
        
       import ./make-test-python.nix (

     

       2
       2
        
         {

     

       3
       3
       +
           name = "zrepl";

     

       4
       4
       +
       

     

       3
       5
        
           nodes.host = {config, pkgs, ...}: {

     

       4
       6
        
             config = {

     

       5
       7
        
               # Prerequisites for ZFS and tests.

+2 -2

pkgs/top-level/all-packages.nix

···

       140
       140
        
         nixosTests = import ../../nixos/tests/all-tests.nix {

     

       141
       141
        
           inherit pkgs;

     

       142
       142
        
           system = stdenv.hostPlatform.system;

     

       143
       143
       -
           callTest = t: t.test;

     

       143
       143
       +
           callTest = config: config.test;

     

       144
       144
        
         } // {

     

       145
       145
        
           # for typechecking of the scripts and evaluation of

     

       146
       146
        
           # the nodes, without running VMs.

     

       147
       147
        
           allDrivers = import ../../nixos/tests/all-tests.nix {

     

       148
       148
        
             inherit pkgs;

     

       149
       149
        
             system = stdenv.hostPlatform.system;

     

       150
       150
       -
             callTest = t: t.test.driver;

     

       150
       150
       +
             callTest = config: config.test.driver;

     

       151
       151
        
           };

     

       152
       152
        
         };

     

       153
       153