commit de3e423178d6263ded7cf55d98778c829034ae34 · pyrox.dev/nixpkgs

+13

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

···

       332
       332
        
           '';

     

       333
       333
        
       ```

     

       334
       334
        
       

     

       335
       335
       +
       Similarly, the type checking of test scripts can be disabled in the following

     

       336
       336
       +
       way:

     

       337
       337
       +
       

     

       338
       338
       +
       ```nix

     

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

     

       340
       340
       +
         skipTypeCheck = true;

     

       341
       341
       +
         nodes.machine =

     

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

     

       343
       343
       +
           { configuration…

     

       344
       344
       +
           };

     

       345
       345
       +
       }

     

       346
       346
       +
       ```

     

       347
       347
       +
       

     

       335
       348
        
       ## Failing tests early {#ssec-failing-tests-early}

     

       336
       349
        
       

     

       337
       350
        
       To fail tests early when certain invariables are no longer met (instead of waiting for the build to time out), the decorator `polling_condition` is provided. For example, if we are testing a program `foo` that should not quit after being started, we might write the following:

+13

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

···

       590
       590
        
             # fmt: on

     

       591
       591
        
           '';

     

       592
       592
        
       </programlisting>

     

       593
       593
       +
           <para>

     

       594
       594
       +
             Similarly, the type checking of test scripts can be disabled in

     

       595
       595
       +
             the following way:

     

       596
       596
       +
           </para>

     

       597
       597
       +
           <programlisting language="bash">

     

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

     

       599
       599
       +
         skipTypeCheck = true;

     

       600
       600
       +
         nodes.machine =

     

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

     

       602
       602
       +
           { configuration…

     

       603
       603
       +
           };

     

       604
       604
       +
       }

     

       605
       605
       +
       </programlisting>

     

       593
       606
        
         </section>

     

       594
       607
        
         <section xml:id="ssec-failing-tests-early">

     

       595
       608
        
           <title>Failing tests early</title>

+2

nixos/lib/test-driver/default.nix

···

       25
       25
        
         checkPhase = ''

     

       26
       26
        
           mypy --disallow-untyped-defs \

     

       27
       27
        
                 --no-implicit-optional \

     

       28
       28
       +
                 --pretty \

     

       29
       29
       +
                 --no-color-output \

     

       28
       30
        
                 --ignore-missing-imports ${src}/test_driver

     

       29
       31
        
           pylint --errors-only --enable=unused-import ${src}/test_driver

     

       30
       32
        
           black --check --diff ${src}/test_driver

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

This is a binary file and will not be displayed.

+42

nixos/lib/test-script-prepend.py

···

       1
       1
       +
       # This file contains type hints that can be prepended to Nix test scripts so they can be type

     

       2
       2
       +
       # checked.

     

       3
       3
       +
       

     

       4
       4
       +
       from test_driver.driver import Driver

     

       5
       5
       +
       from test_driver.vlan import VLan

     

       6
       6
       +
       from test_driver.machine import Machine

     

       7
       7
       +
       from test_driver.logger import Logger

     

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

     

       9
       9
       +
       from typing_extensions import Protocol

     

       10
       10
       +
       from pathlib import Path

     

       11
       11
       +
       

     

       12
       12
       +
       

     

       13
       13
       +
       class RetryProtocol(Protocol):

     

       14
       14
       +
           def __call__(self, fn: Callable, timeout: int = 900) -> None:

     

       15
       15
       +
               raise Exception("This is just type information for the Nix test driver")

     

       16
       16
       +
       

     

       17
       17
       +
       

     

       18
       18
       +
       class PollingConditionProtocol(Protocol):

     

       19
       19
       +
           def __call__(

     

       20
       20
       +
               self,

     

       21
       21
       +
               fun_: Optional[Callable] = None,

     

       22
       22
       +
               *,

     

       23
       23
       +
               seconds_interval: float = 2.0,

     

       24
       24
       +
               description: Optional[str] = None,

     

       25
       25
       +
           ) -> Union[Callable[[Callable], ContextManager], ContextManager]:

     

       26
       26
       +
               raise Exception("This is just type information for the Nix test driver")

     

       27
       27
       +
       

     

       28
       28
       +
       

     

       29
       29
       +
       start_all: Callable[[], None]

     

       30
       30
       +
       subtest: Callable[[str], ContextManager[None]]

     

       31
       31
       +
       retry: RetryProtocol

     

       32
       32
       +
       test_script: Callable[[], None]

     

       33
       33
       +
       machines: List[Machine]

     

       34
       34
       +
       vlans: List[VLan]

     

       35
       35
       +
       driver: Driver

     

       36
       36
       +
       log: Logger

     

       37
       37
       +
       create_machine: Callable[[Dict[str, Any]], Machine]

     

       38
       38
       +
       run_tests: Callable[[], None]

     

       39
       39
       +
       join_all: Callable[[], None]

     

       40
       40
       +
       serial_stdout_off: Callable[[], None]

     

       41
       41
       +
       serial_stdout_on: Callable[[], None]

     

       42
       42
       +
       polling_condition: PollingConditionProtocol

+28 -5

nixos/lib/testing-python.nix

···

       50
       50
        
           , qemu_pkg ? pkgs.qemu_test

     

       51
       51
        
           , enableOCR ? false

     

       52
       52
        
           , skipLint ? false

     

       53
       53
       +
           , skipTypeCheck ? false

     

       53
       54
        
           , passthru ? {}

     

       54
       55
        
           , interactive ? false

     

       55
       56
        
         }:

     
···

       85
       86
        
       

     

       86
       87
        
             nodeHostNames = let

     

       87
       88
        
               nodesList = map (c: c.config.system.name) (lib.attrValues nodes);

     

       88
       88
       -
             in nodesList ++ lib.optional (lib.length nodesList == 1) "machine";

     

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

     

       89
       90
        
       

     

       90
       91
        
             # TODO: This is an implementation error and needs fixing

     

       91
       92
        
             # the testing famework cannot legitimately restrict hostnames further

     
···

       100
       101
        
               then testScript { inherit nodes; }

     

       101
       102
        
               else testScript;

     

       102
       103
        
       

     

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

     

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

     

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

     

       103
       107
        
           in

     

       104
       108
        
           if lib.length invalidNodeNames > 0 then

     

       105
       109
        
             throw ''

     
···

       113
       117
        
           else lib.warnIf skipLint "Linting is disabled" (runCommand testDriverName

     

       114
       118
        
             {

     

       115
       119
        
               inherit testName;

     

       116
       116
       -
               nativeBuildInputs = [ makeWrapper ];

     

       120
       120
       +
               nativeBuildInputs = [ makeWrapper mypy ];

     

       117
       121
        
               testScript = testScript';

     

       118
       122
        
               preferLocalBuild = true;

     

       119
       123
        
               passthru = passthru // {

     
···

       125
       129
        
               mkdir -p $out/bin

     

       126
       130
        
       

     

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

     

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

     

       132
       132
       +
       

     

       133
       133
       +
               ${lib.optionalString (!skipTypeCheck) ''

     

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

     

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

     

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

     

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

     

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

     

       139
       139
       +
       

     

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

     

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

     

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

     

       143
       143
       +
                       --pretty \

     

       144
       144
       +
                       --no-color-output \

     

       145
       145
       +
                       testScriptWithTypes

     

       146
       146
       +
                 unset PYTHONPATH

     

       147
       147
       +
               ''}

     

       148
       148
       +
       

     

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

     

       150
       150
       +
       

     

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

     

       130
       152
        
       

     

       131
       153
        
               ${testDriver}/bin/generate-driver-symbols

     
···

       152
       174
        
           , testScript

     

       153
       175
        
           , enableOCR ? false

     

       154
       176
        
           , name ? "unnamed"

     

       177
       177
       +
           , skipTypeCheck ? false

     

       155
       178
        
             # Skip linting (mainly intended for faster dev cycles)

     

       156
       179
        
           , skipLint ? false

     

       157
       180
        
           , passthru ? {}

     
···

       213
       236
        
                 );

     

       214
       237
        
       

     

       215
       238
        
             driver = setupDriverForTest {

     

       216
       216
       -
               inherit testScript enableOCR skipLint passthru;

     

       239
       239
       +
               inherit testScript enableOCR skipTypeCheck skipLint passthru;

     

       217
       240
        
               testName = name;

     

       218
       241
        
               qemu_pkg = pkgs.qemu_test;

     

       219
       242
        
               nodes = mkNodes pkgs.qemu_test;

     

       220
       243
        
             };

     

       221
       244
        
             driverInteractive = setupDriverForTest {

     

       222
       222
       -
               inherit testScript enableOCR skipLint passthru;

     

       245
       245
       +
               inherit testScript enableOCR skipTypeCheck skipLint passthru;

     

       223
       246
        
               testName = name;

     

       224
       247
        
               qemu_pkg = pkgs.qemu;

     

       225
       248
        
               nodes = mkNodes pkgs.qemu;