commit ce5a33e62bea14024af8bfad23b54c8848a89d9e · pyrox.dev/nixpkgs

+3 -2

lib/default.nix

···

       68
       68
        
             bitNot boolToString mergeAttrs flip mapNullable inNixShell isFloat min max

     

       69
       69
        
             importJSON importTOML warn warnIf throwIfNot checkListOfEnum

     

       70
       70
        
             info showWarnings nixpkgsVersion version isInOldestRelease

     

       71
       71
       -
             mod compare splitByAndCompare functionArgs setFunctionArgs isFunction

     

       71
       71
       +
             mod compare splitByAndCompare

     

       72
       72
       +
             functionArgs setFunctionArgs isFunction toFunction

     

       72
       73
        
             toHexString toBaseDigits;

     

       73
       74
        
           inherit (self.fixedPoints) fix fix' converge extends composeExtensions

     

       74
       75
        
             composeManyExtensions makeExtensible makeExtensibleWithCustomName;

     
···

       113
       114
        
             commitIdFromGitRepo cleanSourceWith pathHasContext

     

       114
       115
        
             canCleanSource pathIsRegularFile pathIsGitRepo;

     

       115
       116
        
           inherit (self.modules) evalModules setDefaultModuleLocation

     

       116
       116
       -
             unifyModuleSyntax applyIfFunction mergeModules

     

       117
       117
       +
             unifyModuleSyntax applyModuleArgsIfFunction mergeModules

     

       117
       118
        
             mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions

     

       118
       119
        
             pushDownProperties dischargeProperties filterOverrides

     

       119
       120
        
             sortProperties fixupOptionType mkIf mkAssert mkMerge mkOverride

+3 -3

lib/modules.nix

···

       282
       282
        
             # Like unifyModuleSyntax, but also imports paths and calls functions if necessary

     

       283
       283
        
             loadModule = args: fallbackFile: fallbackKey: m:

     

       284
       284
        
               if isFunction m || isAttrs m then

     

       285
       285
       -
                 unifyModuleSyntax fallbackFile fallbackKey (applyIfFunction fallbackKey m args)

     

       285
       285
       +
                 unifyModuleSyntax fallbackFile fallbackKey (applyModuleArgsIfFunction fallbackKey m args)

     

       286
       286
        
               else if isList m then

     

       287
       287
        
                 let defs = [{ file = fallbackFile; value = m; }]; in

     

       288
       288
        
                 throw "Module imports can't be nested lists. Perhaps you meant to remove one level of lists? Definitions: ${showDefs defs}"

     

       289
       289
       -
               else unifyModuleSyntax (toString m) (toString m) (applyIfFunction (toString m) (import m) args);

     

       289
       289
       +
               else unifyModuleSyntax (toString m) (toString m) (applyModuleArgsIfFunction (toString m) (import m) args);

     

       290
       290
        
       

     

       291
       291
        
             /*

     

       292
       292
        
             Collects all modules recursively into the form

     
···

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

     

       384
       384
        
             };

     

       385
       385
        
       

     

       386
       386
       -
         applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then

     

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

     

       387
       387
        
           let

     

       388
       388
        
             # Module arguments are resolved in a strict manner when attribute set

     

       389
       389
        
             # deconstruction is used.  As the arguments are now defined with the

+19

lib/trivial.nix

···

       441
       441
        
         isFunction = f: builtins.isFunction f ||

     

       442
       442
        
           (f ? __functor && isFunction (f.__functor f));

     

       443
       443
        
       

     

       444
       444
       +
         /*

     

       445
       445
       +
           Turns any non-callable values into constant functions.

     

       446
       446
       +
           Returns callable values as is.

     

       447
       447
       +
       

     

       448
       448
       +
           Example:

     

       449
       449
       +
       

     

       450
       450
       +
             nix-repl> lib.toFunction 1 2

     

       451
       451
       +
             1

     

       452
       452
       +
       

     

       453
       453
       +
             nix-repl> lib.toFunction (x: x + 1) 2

     

       454
       454
       +
             3

     

       455
       455
       +
         */

     

       456
       456
       +
         toFunction =

     

       457
       457
       +
           # Any value

     

       458
       458
       +
           v:

     

       459
       459
       +
           if isFunction v

     

       460
       460
       +
           then v

     

       461
       461
       +
           else k: v;

     

       462
       462
       +
       

     

       444
       463
        
         /* Convert the given positive integer to a string of its hexadecimal

     

       445
       464
        
            representation. For example:

     

       446
       465

+14 -16

nixos/lib/testing-python.nix

···

       146
       146
        
       

     

       147
       147
        
         # Make a full-blown test

     

       148
       148
        
         makeTest =

     

       149
       149
       -
           { testScript

     

       149
       149
       +
           { machine ? null

     

       150
       150
       +
           , nodes ? {}

     

       151
       151
       +
           , testScript

     

       150
       152
        
           , enableOCR ? false

     

       151
       153
        
           , name ? "unnamed"

     

       152
       154
        
             # Skip linting (mainly intended for faster dev cycles)

     

       153
       155
        
           , skipLint ? false

     

       154
       156
        
           , passthru ? {}

     

       157
       157
       +
           , meta ? {}

     

       155
       158
        
           , # For meta.position

     

       156
       159
        
             pos ? # position used in error messages and for meta.position

     

       157
       157
       -
               (if t.meta.description or null != null

     

       158
       158
       -
                 then builtins.unsafeGetAttrPos "description" t.meta

     

       160
       160
       +
               (if meta.description or null != null

     

       161
       161
       +
                 then builtins.unsafeGetAttrPos "description" meta

     

       159
       162
        
                 else builtins.unsafeGetAttrPos "testScript" t)

     

       160
       160
       -
           , ...

     

       161
       163
        
           } @ t:

     

       162
       164
        
           let

     

       163
       163
       -
             nodes = qemu_pkg:

     

       165
       165
       +
             mkNodes = qemu_pkg:

     

       164
       166
        
               let

     

       165
       167
        
                 testScript' =

     

       166
       168
        
                   # Call the test script with the computed nodes.

     

       167
       169
        
                   if lib.isFunction testScript

     

       168
       168
       -
                   then testScript { nodes = nodes qemu_pkg; }

     

       170
       170
       +
                   then testScript { nodes = mkNodes qemu_pkg; }

     

       169
       171
        
                   else testScript;

     

       170
       172
        
       

     

       171
       173
        
                 build-vms = import ./build-vms.nix {

     
···

       205
       207
        
                 };

     

       206
       208
        
               in

     

       207
       209
        
                 build-vms.buildVirtualNetwork (

     

       208
       208
       -
                     t.nodes or (if t ? machine then { machine = t.machine; } else { })

     

       210
       210
       +
                     nodes // lib.optionalAttrs (machine != null) { inherit machine; }

     

       209
       211
        
                 );

     

       210
       212
        
       

     

       211
       213
        
             driver = setupDriverForTest {

     

       212
       214
        
               inherit testScript enableOCR skipLint passthru;

     

       213
       215
        
               testName = name;

     

       214
       216
        
               qemu_pkg = pkgs.qemu_test;

     

       215
       215
       -
               nodes = nodes pkgs.qemu_test;

     

       217
       217
       +
               nodes = mkNodes pkgs.qemu_test;

     

       216
       218
        
             };

     

       217
       219
        
             driverInteractive = setupDriverForTest {

     

       218
       220
        
               inherit testScript enableOCR skipLint passthru;

     

       219
       221
        
               testName = name;

     

       220
       222
        
               qemu_pkg = pkgs.qemu;

     

       221
       221
       -
               nodes = nodes pkgs.qemu;

     

       223
       223
       +
               nodes = mkNodes pkgs.qemu;

     

       222
       224
        
               interactive = true;

     

       223
       225
        
             };

     

       224
       226
        
       

     

       225
       225
       -
             test =

     

       226
       226
       -
               let

     

       227
       227
       -
                 passMeta = drv: drv // lib.optionalAttrs (t ? meta) {

     

       228
       228
       -
                   meta = (drv.meta or { }) // t.meta;

     

       229
       229
       -
                 };

     

       230
       230
       -
               in passMeta (runTests { inherit driver pos driverInteractive; });

     

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

     

       231
       228
        
       

     

       232
       229
        
           in

     

       233
       230
        
             test // {

     

       234
       234
       -
               inherit test driver driverInteractive nodes;

     

       231
       231
       +
               inherit test driver driverInteractive;

     

       232
       232
       +
               inherit (driver) nodes;

     

       235
       233
        
             };

     

       236
       234
        
       

     

       237
       235
        
         abortForFunction = functionName: abort ''The ${functionName} function was

+1 -1

nixos/modules/installer/tools/tools.nix

···

       117
       117
        
           '';

     

       118
       118
        
         };

     

       119
       119
        
       

     

       120
       120
       -
         config = lib.mkIf (!config.system.disableInstallerTools) {

     

       120
       120
       +
         config = lib.mkIf (config.nix.enable && !config.system.disableInstallerTools) {

     

       121
       121
        
       

     

       122
       122
        
           system.nixos-generate-config.configuration = mkDefault ''

     

       123
       123
        
             # Edit this configuration file to define what should be installed on

+7 -1

nixos/modules/services/misc/nix-gc.nix

···

       81
       81
        
         ###### implementation

     

       82
       82
        
       

     

       83
       83
        
         config = {

     

       84
       84
       +
           assertions = [

     

       85
       85
       +
             {

     

       86
       86
       +
               assertion = cfg.automatic -> config.nix.enable;

     

       87
       87
       +
               message = ''nix.gc.automatic requires nix.enable'';

     

       88
       88
       +
             }

     

       89
       89
       +
           ];

     

       84
       90
        
       

     

       85
       85
       -
           systemd.services.nix-gc = {

     

       91
       91
       +
           systemd.services.nix-gc = lib.mkIf config.nix.enable {

     

       86
       92
        
             description = "Nix Garbage Collector";

     

       87
       93
        
             script = "exec ${config.nix.package.out}/bin/nix-collect-garbage ${cfg.options}";

     

       88
       94
        
             startAt = optional cfg.automatic cfg.dates;

+7 -1

nixos/modules/services/misc/nix-optimise.nix

···

       37
       37
        
         ###### implementation

     

       38
       38
        
       

     

       39
       39
        
         config = {

     

       40
       40
       +
           assertions = [

     

       41
       41
       +
             {

     

       42
       42
       +
               assertion = cfg.automatic -> config.nix.enable;

     

       43
       43
       +
               message = ''nix.optimise.automatic requires nix.enable'';

     

       44
       44
       +
             }

     

       45
       45
       +
           ];

     

       40
       46
        
       

     

       41
       41
       -
           systemd.services.nix-optimise =

     

       47
       47
       +
           systemd.services.nix-optimise = lib.mkIf config.nix.enable

     

       42
       48
        
             { description = "Nix Store Optimiser";

     

       43
       49
        
               # No point this if the nix daemon (and thus the nix store) is outside

     

       44
       50
        
               unitConfig.ConditionPathIsReadWrite = "/nix/var/nix/daemon-socket";

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       796
       796
        
           # allow `system.build.toplevel' to be included.  (If we had a direct

     

       797
       797
        
           # reference to ${regInfo} here, then we would get a cyclic

     

       798
       798
        
           # dependency.)

     

       799
       799
       -
           boot.postBootCommands =

     

       799
       799
       +
           boot.postBootCommands = lib.mkIf config.nix.enable

     

       800
       800
        
             ''

     

       801
       801
        
               if [[ "$(cat /proc/cmdline)" =~ regInfo=([^ ]*) ]]; then

     

       802
       802
        
                 ${config.nix.package.out}/bin/nix-store --load-db < ''${BASH_REMATCH[1]}

-1

nixos/tests/boot.nix

···

       38
       38
        
             } // extraConfig);

     

       39
       39
        
           in

     

       40
       40
        
             makeTest {

     

       41
       41
       -
               inherit iso;

     

       42
       41
        
               name = "boot-" + name;

     

       43
       42
        
               nodes = { };

     

       44
       43
        
               testScript =

+3 -3

nixos/tests/caddy.nix

···

       7
       7
        
         nodes = {

     

       8
       8
        
           webserver = { pkgs, lib, ... }: {

     

       9
       9
        
             services.caddy.enable = true;

     

       10
       10
       -
             services.caddy.config = ''

     

       10
       10
       +
             services.caddy.extraConfig = ''

     

       11
       11
        
               http://localhost {

     

       12
       12
        
                 encode gzip

     

       13
       13
        
       

     
···

       22
       22
        
             '';

     

       23
       23
        
       

     

       24
       24
        
             specialisation.etag.configuration = {

     

       25
       25
       -
               services.caddy.config = lib.mkForce ''

     

       25
       25
       +
               services.caddy.extraConfig = lib.mkForce ''

     

       26
       26
        
                 http://localhost {

     

       27
       27
        
                   encode gzip

     

       28
       28
        
       

     
···

       38
       38
        
             };

     

       39
       39
        
       

     

       40
       40
        
             specialisation.config-reload.configuration = {

     

       41
       41
       -
               services.caddy.config = ''

     

       41
       41
       +
               services.caddy.extraConfig = ''

     

       42
       42
        
                 http://localhost:8080 {

     

       43
       43
        
                 }

     

       44
       44
        
               '';

+1 -1

nixos/tests/ceph-multi-node.nix

···

       48
       48
        
             sudo

     

       49
       49
        
             ceph

     

       50
       50
        
             xfsprogs

     

       51
       51
       -
             netcat-openbsd

     

       51
       51
       +
             libressl.nc

     

       52
       52
        
           ];

     

       53
       53
        
       

     

       54
       54
        
           boot.kernelModules = [ "xfs" ];

+20 -18

nixos/tests/chromium.nix

···

       15
       15
        
       with import ../lib/testing-python.nix { inherit system pkgs; };

     

       16
       16
        
       with pkgs.lib;

     

       17
       17
        
       

     

       18
       18
       -
       mapAttrs (channel: chromiumPkg: makeTest rec {

     

       19
       19
       -
         name = "chromium-${channel}";

     

       20
       20
       -
         meta = {

     

       21
       21
       -
           maintainers = with maintainers; [ aszlig primeos ];

     

       22
       22
       -
           # https://github.com/NixOS/hydra/issues/591#issuecomment-435125621

     

       23
       23
       -
           inherit (chromiumPkg.meta) timeout;

     

       24
       24
       -
         };

     

       25
       25
       -
       

     

       26
       26
       -
         enableOCR = true;

     

       27
       27
       -
       

     

       18
       18
       +
       let

     

       28
       19
        
         user = "alice";

     

       29
       29
       -
       

     

       30
       30
       -
         machine.imports = [ ./common/user-account.nix ./common/x11.nix ];

     

       31
       31
       -
         machine.virtualisation.memorySize = 2047;

     

       32
       32
       -
         machine.test-support.displayManager.auto.user = user;

     

       33
       33
       -
         machine.environment = {

     

       34
       34
       -
           systemPackages = [ chromiumPkg ];

     

       35
       35
       -
           variables."XAUTHORITY" = "/home/alice/.Xauthority";

     

       36
       36
       -
         };

     

       37
       20
        
       

     

       38
       21
        
         startupHTML = pkgs.writeText "chromium-startup.html" ''

     

       39
       22
        
           <!DOCTYPE html>

     
···

       50
       33
        
           </body>

     

       51
       34
        
           </html>

     

       52
       35
        
         '';

     

       36
       36
       +
       in

     

       37
       37
       +
       

     

       38
       38
       +
       mapAttrs (channel: chromiumPkg: makeTest {

     

       39
       39
       +
         name = "chromium-${channel}";

     

       40
       40
       +
         meta = {

     

       41
       41
       +
           maintainers = with maintainers; [ aszlig primeos ];

     

       42
       42
       +
           # https://github.com/NixOS/hydra/issues/591#issuecomment-435125621

     

       43
       43
       +
           inherit (chromiumPkg.meta) timeout;

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
         enableOCR = true;

     

       47
       47
       +
       

     

       48
       48
       +
         machine.imports = [ ./common/user-account.nix ./common/x11.nix ];

     

       49
       49
       +
         machine.virtualisation.memorySize = 2047;

     

       50
       50
       +
         machine.test-support.displayManager.auto.user = user;

     

       51
       51
       +
         machine.environment = {

     

       52
       52
       +
           systemPackages = [ chromiumPkg ];

     

       53
       53
       +
           variables."XAUTHORITY" = "/home/alice/.Xauthority";

     

       54
       54
       +
         };

     

       53
       55
        
       

     

       54
       56
        
         testScript = let

     

       55
       57
        
           xdo = name: text: let

+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
       -
         maintainers = with pkgs.lib.maintainers; teams.podman.members;

     

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

     

       5
       5
        
       

     

       6
       6
        
         nodes = {

     

       7
       7
        
           crio = {

+1 -1

nixos/tests/gitolite-fcgiwrap.nix

···

       20
       20
        
               nodes = {

     

       21
       21
        
       

     

       22
       22
        
                 server =

     

       23
       23
       -
                   { ... }:

     

       23
       23
       +
                   { config, ... }:

     

       24
       24
        
                     {

     

       25
       25
        
                       networking.firewall.allowedTCPPorts = [ 80 ];

     

       26
       26

+2 -2

nixos/tests/jitsi-meet.nix

···

       21
       21
        
               forceSSL = true;

     

       22
       22
        
             };

     

       23
       23
        
       

     

       24
       24
       -
             security.acme.email = "me@example.org";

     

       25
       24
        
             security.acme.acceptTerms = true;

     

       26
       26
       -
             security.acme.server = "https://example.com"; # self-signed only

     

       25
       25
       +
             security.acme.defaults.email = "me@example.org";

     

       26
       26
       +
             security.acme.defaults.server = "https://example.com"; # self-signed only

     

       27
       27
        
           };

     

       28
       28
        
         };

     

       29
       29

+3 -3

nixos/tests/misc.nix

···

       1
       1
        
       # Miscellaneous small tests that don't warrant their own VM run.

     

       2
       2
        
       

     

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

     

       3
       3
       +
       import ./make-test-python.nix ({ pkgs, ...} : let

     

       4
       4
       +
         foo = pkgs.writeText "foo" "Hello World";

     

       5
       5
       +
       in {

     

       4
       6
        
         name = "misc";

     

       5
       7
        
         meta = with pkgs.lib.maintainers; {

     

       6
       8
        
           maintainers = [ eelco ];

     

       7
       9
        
         };

     

       8
       8
       -
       

     

       9
       9
       -
         foo = pkgs.writeText "foo" "Hello World";

     

       10
       10
        
       

     

       11
       11
        
         machine =

     

       12
       12
        
           { lib, ... }:

-6

nixos/tests/rstudio-server.nix

···

       14
       14
        
             };

     

       15
       15
        
           };

     

       16
       16
        
       

     

       17
       17
       -
           users.testuser = {

     

       18
       18
       -
             uid = 1000;

     

       19
       19
       -
             group = "testgroup";

     

       20
       20
       -
           };

     

       21
       21
       -
           groups.testgroup.gid = 1000;

     

       22
       22
       -
       

     

       23
       17
        
           testScript = ''

     

       24
       18
        
             machine.wait_for_unit("rstudio-server.service")

     

       25
       19
        
             machine.succeed("curl -f -vvv -s http://127.0.0.1:8787")

+2 -2

nixos/tests/step-ca.nix

···

       42
       42
        
       

     

       43
       43
        
               caclient =

     

       44
       44
        
                 { config, pkgs, ... }: {

     

       45
       45
       -
                   security.acme.server = "https://caserver:8443/acme/acme/directory";

     

       46
       46
       -
                   security.acme.email = "root@example.org";

     

       45
       45
       +
                   security.acme.defaults.server = "https://caserver:8443/acme/acme/directory";

     

       46
       46
       +
                   security.acme.defaults.email = "root@example.org";

     

       47
       47
        
                   security.acme.acceptTerms = true;

     

       48
       48
        
       

     

       49
       49
        
                   security.pki.certificateFiles = [ "${test-certificates}/root_ca.crt" ];

+10 -15

nixos/tests/tor.nix

···

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

     

       2
       2
        
       

     

       3
       3
       -
       rec {

     

       3
       3
       +
       {

     

       4
       4
        
         name = "tor";

     

       5
       5
        
         meta.maintainers = with maintainers; [ joachifm ];

     

       6
       6
        
       

     

       7
       7
       -
         common =

     

       8
       8
       -
           { ... }:

     

       9
       9
       -
           { boot.kernelParams = [ "audit=0" "apparmor=0" "quiet" ];

     

       10
       10
       -
             networking.firewall.enable = false;

     

       11
       11
       -
             networking.useDHCP = false;

     

       12
       12
       -
           };

     

       7
       7
       +
         nodes.client = { pkgs, ... }: {

     

       8
       8
       +
           boot.kernelParams = [ "audit=0" "apparmor=0" "quiet" ];

     

       9
       9
       +
           networking.firewall.enable = false;

     

       10
       10
       +
           networking.useDHCP = false;

     

       13
       11
        
       

     

       14
       14
       -
         nodes.client =

     

       15
       15
       -
           { pkgs, ... }:

     

       16
       16
       -
           { imports = [ common ];

     

       17
       17
       -
             environment.systemPackages = with pkgs; [ netcat ];

     

       18
       18
       -
             services.tor.enable = true;

     

       19
       19
       -
             services.tor.client.enable = true;

     

       20
       20
       -
             services.tor.settings.ControlPort = 9051;

     

       21
       21
       -
           };

     

       12
       12
       +
           environment.systemPackages = with pkgs; [ netcat ];

     

       13
       13
       +
           services.tor.enable = true;

     

       14
       14
       +
           services.tor.client.enable = true;

     

       15
       15
       +
           services.tor.settings.ControlPort = 9051;

     

       16
       16
       +
         };

     

       22
       17
        
       

     

       23
       18
        
         testScript = ''

     

       24
       19
        
           client.wait_for_unit("tor.service")

+15 -6

nixos/tests/without-nix.nix

···

       4
       4
        
           maintainers = [ ericson2314 ];

     

       5
       5
        
         };

     

       6
       6
        
       

     

       7
       7
       -
         nixpkgs.overlays = [

     

       8
       8
       -
           (self: super: {

     

       9
       9
       -
             nix = throw "don't want to use this";

     

       10
       10
       -
           })

     

       11
       11
       -
         ];

     

       12
       12
       -
       

     

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

     

       14
       8
        
           nix.enable = false;

     

       9
       9
       +
           nixpkgs.overlays = [

     

       10
       10
       +
             (self: super: {

     

       11
       11
       +
               nix = throw "don't want to use pkgs.nix";

     

       12
       12
       +
               nixVersions = lib.mapAttrs (k: throw "don't want to use pkgs.nixVersions.${k}") super.nixVersions;

     

       13
       13
       +
               # aliases, some deprecated

     

       14
       14
       +
               nix_2_3 = throw "don't want to use pkgs.nix_2_3";

     

       15
       15
       +
               nix_2_4 = throw "don't want to use pkgs.nix_2_4";

     

       16
       16
       +
               nix_2_5 = throw "don't want to use pkgs.nix_2_5";

     

       17
       17
       +
               nix_2_6 = throw "don't want to use pkgs.nix_2_6";

     

       18
       18
       +
               nixFlakes = throw "don't want to use pkgs.nixFlakes";

     

       19
       19
       +
               nixStable = throw "don't want to use pkgs.nixStable";

     

       20
       20
       +
               nixUnstable = throw "don't want to use pkgs.nixUnstable";

     

       21
       21
       +
               nixStatic = throw "don't want to use pkgs.nixStatic";

     

       22
       22
       +
             })

     

       23
       23
       +
           ];

     

       15
       24
        
         };

     

       16
       25
        
       

     

       17
       26
        
         testScript = ''

+3 -3

pkgs/test/nixos-functions/default.nix

···

       26
       26
        
             fileSystems."/".device = "/dev/null";

     

       27
       27
        
           }).toplevel;

     

       28
       28
        
       

     

       29
       29
       -
           nixosTest-test = pkgs.nixosTest ({ lib, pkgs, ... }: {

     

       29
       29
       +
           nixosTest-test = pkgs.nixosTest ({ lib, pkgs, figlet, ... }: {

     

       30
       30
        
             name = "nixosTest-test";

     

       31
       31
        
             machine = { pkgs, ... }: {

     

       32
       32
        
               system.nixos = dummyVersioning;

     

       33
       33
       -
               environment.systemPackages = [ pkgs.hello ];

     

       33
       33
       +
               environment.systemPackages = [ pkgs.hello figlet ];

     

       34
       34
        
             };

     

       35
       35
        
             testScript = ''

     

       36
       36
       -
               machine.succeed("hello")

     

       36
       36
       +
               machine.succeed("hello | figlet >/dev/console")

     

       37
       37
        
             '';

     

       38
       38
        
           });

     

       39
       39

+1 -3

pkgs/top-level/all-packages.nix

···

       33715
       33715
        
                 loadedTest = if builtins.typeOf test == "path"

     

       33716
       33716
        
                   then import test

     

       33717
       33717
        
                   else test;

     

       33718
       33718
       -
                 calledTest = if lib.isFunction loadedTest

     

       33719
       33719
       -
                   then callPackage loadedTest {}

     

       33720
       33720
       -
                   else loadedTest;

     

       33718
       33718
       +
                 calledTest = lib.toFunction loadedTest pkgs;

     

       33721
       33719
        
               in

     

       33722
       33720
        
                 nixosTesting.makeTest calledTest;

     

       33723
       33721