commit 3ba45b082e76a29b562ff014cd085f3364579bef · pyrox.dev/nixpkgs

+2

nixos/doc/manual/development/developing-the-test-driver.chapter.md

···

       25
       25
        
       

     

       26
       26
        
       ## Testing changes to the test framework {#sec-test-the-test-framework}

     

       27
       27
        
       

     

       28
       28
       +
       We currently have limited unit tests for the framework itself. You may run these with `nix-build -A nixosTests.nixos-test-driver`.

     

       29
       29
       +
       

     

       28
       30
        
       When making significant changes to the test framework, we run the tests on Hydra, to avoid disrupting the larger NixOS project.

     

       29
       31
        
       

     

       30
       32
        
       For this, we use the `python-test-refactoring` branch in the `NixOS/nixpkgs` repository, and its [corresponding Hydra jobset](https://hydra.nixos.org/jobset/nixos/python-test-refactoring).

+5

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

···

       130
       130
        
       start_all()

     

       131
       131
        
       ```

     

       132
       132
        
       

     

       133
       133
       +
       If the hostname of a node contains characters that can't be used in a

     

       134
       134
       +
       Python variable name, those characters will be replaced with

     

       135
       135
       +
       underscores in the variable name, so `nodes.machine-a` will be exposed

     

       136
       136
       +
       to Python as `machine_a`.

     

       137
       137
       +
       

     

       133
       138
        
       ## Machine objects {#ssec-machine-objects}

     

       134
       139
        
       

     

       135
       140
        
       The following methods are available on machine objects:

+6 -1

nixos/lib/test-driver/test_driver/driver.py

···

       2
       2
        
       from pathlib import Path

     

       3
       3
        
       from typing import Any, Dict, Iterator, List, Union, Optional, Callable, ContextManager

     

       4
       4
        
       import os

     

       5
       5
       +
       import re

     

       5
       6
        
       import tempfile

     

       6
       7
        
       

     

       7
       8
        
       from test_driver.logger import rootlog

     
···

       26
       27
        
                   f"The directory defined by TMPDIR, TEMP, TMP, or CWD: {tmp_dir} is not writeable"

     

       27
       28
        
               )

     

       28
       29
        
           return tmp_dir

     

       30
       30
       +
       

     

       31
       31
       +
       

     

       32
       32
       +
       def pythonize_name(name: str) -> str:

     

       33
       33
       +
           return re.sub(r"^[^A-z_]|[^A-z0-9_]", "_", name)

     

       29
       34
        
       

     

       30
       35
        
       

     

       31
       36
        
       class Driver:

     
···

       113
       118
        
                   polling_condition=self.polling_condition,

     

       114
       119
        
                   Machine=Machine,  # for typing

     

       115
       120
        
               )

     

       116
       116
       -
               machine_symbols = {m.name: m for m in self.machines}

     

       121
       121
       +
               machine_symbols = {pythonize_name(m.name): m for m in self.machines}

     

       117
       122
        
               # If there's exactly one machine, make it available under the name

     

       118
       123
        
               # "machine", even if it's not called that.

     

       119
       124
        
               if len(self.machines) == 1:

+11 -20

nixos/lib/testing/driver.nix

···

       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;

     

       24
       24
       +
         pythonizeName = name:

     

       25
       25
       +
           let

     

       26
       26
       +
             head = lib.substring 0 1 name;

     

       27
       27
       +
             tail = lib.substring 1 (-1) name;

     

       28
       28
       +
           in

     

       29
       29
       +
             (if builtins.match "[A-z_]" head == null then "_" else head) +

     

       30
       30
       +
             lib.stringAsChars (c: if builtins.match "[A-z0-9_]" c == null then "_" else c) tail;

     

       30
       31
        
       

     

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

     

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

     

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

     

       34
       34
       +
         pythonizedNames = map pythonizeName nodeHostNames;

     

       35
       35
       +
         machineNames = map (name: "${name}: Machine;") pythonizedNames;

     

       34
       36
        
       

     

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

     

       37
       37
       +
         withChecks = lib.warnIf config.skipLint "Linting is disabled";

     

       47
       38
        
       

     

       48
       39
        
         driver =

     

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

     
···

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

     

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

     

       89
       80
        
                 PYFLAKES_BUILTINS="$(

     

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

     

       81
       81
       +
                   echo -n ${lib.escapeShellArg (lib.concatStringsSep "," pythonizedNames)},

     

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

     

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

     

       93
       84
        
               ''}

+9 -1

nixos/tests/all-tests.nix

···

       66
       66
        
           ;

     

       67
       67
        
       

     

       68
       68
        
       in {

     

       69
       69
       +
       

     

       70
       70
       +
         # Testing the test driver

     

       71
       71
       +
         nixos-test-driver = {

     

       72
       72
       +
           extra-python-packages = handleTest ./nixos-test-driver/extra-python-packages.nix {};

     

       73
       73
       +
           node-name = runTest ./nixos-test-driver/node-name.nix;

     

       74
       74
       +
         };

     

       75
       75
       +
       

     

       76
       76
       +
         # NixOS vm tests and non-vm unit tests

     

       77
       77
       +
       

     

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

     

       70
       79
        
         aaaaxy = runTest ./aaaaxy.nix;

     

       71
       80
        
         acme = runTest ./acme.nix;

     
···

       220
       229
        
         etcd-cluster = handleTestOn ["x86_64-linux"] ./etcd-cluster.nix {};

     

       221
       230
        
         etebase-server = handleTest ./etebase-server.nix {};

     

       222
       231
        
         etesync-dav = handleTest ./etesync-dav.nix {};

     

       223
       223
       -
         extra-python-packages = handleTest ./extra-python-packages.nix {};

     

       224
       232
        
         evcc = handleTest ./evcc.nix {};

     

       225
       233
        
         fancontrol = handleTest ./fancontrol.nix {};

     

       226
       234
        
         fcitx5 = handleTest ./fcitx5 {};

+1 -1

nixos/tests/extra-python-packages.nix nixos/tests/nixos-test-driver/extra-python-packages.nix

···

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

     

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

     

       2
       2
        
         {

     

       3
       3
        
           name = "extra-python-packages";

     

       4
       4

+33

nixos/tests/nixos-test-driver/node-name.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         name = "nixos-test-driver.node-name";

     

       3
       3
       +
         nodes = {

     

       4
       4
       +
           "ok" = { };

     

       5
       5
       +
       

     

       6
       6
       +
           # Valid node name, but not a great host name.

     

       7
       7
       +
           "one_two" = { };

     

       8
       8
       +
       

     

       9
       9
       +
           # Valid node name, good host name

     

       10
       10
       +
           "a-b" = { };

     

       11
       11
       +
       

     

       12
       12
       +
           # TODO: would be nice to test these eval failures

     

       13
       13
       +
           # Not allowed by lib/testing/network.nix (yet?)

     

       14
       14
       +
           # "foo.bar" = { };

     

       15
       15
       +
           # Not allowed.

     

       16
       16
       +
           # "not ok" = { }; # not ok

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         testScript = ''

     

       20
       20
       +
           start_all()

     

       21
       21
       +
       

     

       22
       22
       +
           with subtest("python vars exist and machines are reachable through test backdoor"):

     

       23
       23
       +
             ok.succeed("true")

     

       24
       24
       +
             one_two.succeed("true")

     

       25
       25
       +
             a_b.succeed("true")

     

       26
       26
       +
       

     

       27
       27
       +
           with subtest("hostname is derived from the node name"):

     

       28
       28
       +
             ok.succeed("hostname | tee /dev/stderr | grep '^ok$'")

     

       29
       29
       +
             one_two.succeed("hostname | tee /dev/stderr | grep '^onetwo$'")

     

       30
       30
       +
             a_b.succeed("hostname | tee /dev/stderr | grep '^a-b$'")

     

       31
       31
       +
       

     

       32
       32
       +
         '';

     

       33
       33
       +
       }