···

       
68
       
 
       
      bitNot boolToString mergeAttrs flip mapNullable inNixShell isFloat min max

     

       
69
       
 
       
      importJSON importTOML warn warnIf throwIfNot checkListOfEnum

     

       
70
       
 
       
      info showWarnings nixpkgsVersion version isInOldestRelease

     

       
71
       
-
       
      mod compare splitByAndCompare functionArgs setFunctionArgs isFunction

     

       
0
       
 
       

     

       
72
       
 
       
      toHexString toBaseDigits;

     

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

     

       
74
       
 
       
      composeManyExtensions makeExtensible makeExtensibleWithCustomName;

     
···

       
113
       
 
       
      commitIdFromGitRepo cleanSourceWith pathHasContext

     

       
114
       
 
       
      canCleanSource pathIsRegularFile pathIsGitRepo;

     

       
115
       
 
       
    inherit (self.modules) evalModules setDefaultModuleLocation

     

       
116
       
-
       
      unifyModuleSyntax applyIfFunction mergeModules

     

       
117
       
 
       
      mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions

     

       
118
       
 
       
      pushDownProperties dischargeProperties filterOverrides

     

       
119
       
 
       
      sortProperties fixupOptionType mkIf mkAssert mkMerge mkOverride

     

···

       
68
       
 
       
      bitNot boolToString mergeAttrs flip mapNullable inNixShell isFloat min max

     

       
69
       
 
       
      importJSON importTOML warn warnIf throwIfNot checkListOfEnum

     

       
70
       
 
       
      info showWarnings nixpkgsVersion version isInOldestRelease

     

       
71
       
+
       
      mod compare splitByAndCompare

     

       
72
       
+
       
      functionArgs setFunctionArgs isFunction toFunction

     

       
73
       
 
       
      toHexString toBaseDigits;

     

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

     

       
75
       
 
       
      composeManyExtensions makeExtensible makeExtensibleWithCustomName;

     
···

       
114
       
 
       
      commitIdFromGitRepo cleanSourceWith pathHasContext

     

       
115
       
 
       
      canCleanSource pathIsRegularFile pathIsGitRepo;

     

       
116
       
 
       
    inherit (self.modules) evalModules setDefaultModuleLocation

     

       
117
       
+
       
      unifyModuleSyntax applyModuleArgsIfFunction mergeModules

     

       
118
       
 
       
      mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions

     

       
119
       
 
       
      pushDownProperties dischargeProperties filterOverrides

     

       
120
       
 
       
      sortProperties fixupOptionType mkIf mkAssert mkMerge mkOverride

     

···

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

     

       
283
       
 
       
      loadModule = args: fallbackFile: fallbackKey: m:

     

       
284
       
 
       
        if isFunction m || isAttrs m then

     

       
285
       
-
       
          unifyModuleSyntax fallbackFile fallbackKey (applyIfFunction fallbackKey m args)

     

       
286
       
 
       
        else if isList m then

     

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

     

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

     

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

     

       
290
       
 
       


     

       
291
       
 
       
      /*

     

       
292
       
 
       
      Collects all modules recursively into the form

     
···

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

     

       
384
       
 
       
      };

     

       
385
       
 
       


     

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

     

       
387
       
 
       
    let

     

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

     

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

     

···

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

     

       
283
       
 
       
      loadModule = args: fallbackFile: fallbackKey: m:

     

       
284
       
 
       
        if isFunction m || isAttrs m then

     

       
285
       
+
       
          unifyModuleSyntax fallbackFile fallbackKey (applyModuleArgsIfFunction fallbackKey m args)

     

       
286
       
 
       
        else if isList m then

     

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

     

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

     

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

     

       
290
       
 
       


     

       
291
       
 
       
      /*

     

       
292
       
 
       
      Collects all modules recursively into the form

     
···

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

     

       
384
       
 
       
      };

     

       
385
       
 
       


     

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

     

       
387
       
 
       
    let

     

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

     

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

     

···

       
441
       
 
       
  isFunction = f: builtins.isFunction f ||

     

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

     

       
443
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
445
       
 
       
     representation. For example:

     

       
446
       
 
       


     

···

       
441
       
 
       
  isFunction = f: builtins.isFunction f ||

     

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

     

       
443
       
 
       


     

       
444
       
+
       
  /*

     

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

     

       
446
       
+
       
    Returns callable values as is.

     

       
447
       
+
       


     

       
448
       
+
       
    Example:

     

       
449
       
+
       


     

       
450
       
+
       
      nix-repl> lib.toFunction 1 2

     

       
451
       
+
       
      1

     

       
452
       
+
       


     

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

     

       
454
       
+
       
      3

     

       
455
       
+
       
  */

     

       
456
       
+
       
  toFunction =

     

       
457
       
+
       
    # Any value

     

       
458
       
+
       
    v:

     

       
459
       
+
       
    if isFunction v

     

       
460
       
+
       
    then v

     

       
461
       
+
       
    else k: v;

     

       
462
       
+
       


     

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

     

       
464
       
 
       
     representation. For example:

     

       
465
       
 
       


     

···

       
146
       
 
       


     

       
147
       
 
       
  # Make a full-blown test

     

       
148
       
 
       
  makeTest =

     

       
149
       
-
       
    { testScript

     

       
0
       
 
       

     

       
0
       
 
       

     

       
150
       
 
       
    , enableOCR ? false

     

       
151
       
 
       
    , name ? "unnamed"

     

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

     

       
153
       
 
       
    , skipLint ? false

     

       
154
       
 
       
    , passthru ? {}

     

       
0
       
 
       

     

       
155
       
 
       
    , # For meta.position

     

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

     

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

     

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

     

       
159
       
 
       
          else builtins.unsafeGetAttrPos "testScript" t)

     

       
160
       
-
       
    , ...

     

       
161
       
 
       
    } @ t:

     

       
162
       
 
       
    let

     

       
163
       
-
       
      nodes = qemu_pkg:

     

       
164
       
 
       
        let

     

       
165
       
 
       
          testScript' =

     

       
166
       
 
       
            # Call the test script with the computed nodes.

     

       
167
       
 
       
            if lib.isFunction testScript

     

       
168
       
-
       
            then testScript { nodes = nodes qemu_pkg; }

     

       
169
       
 
       
            else testScript;

     

       
170
       
 
       


     

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

     
···

       
205
       
 
       
          };

     

       
206
       
 
       
        in

     

       
207
       
 
       
          build-vms.buildVirtualNetwork (

     

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

     

       
209
       
 
       
          );

     

       
210
       
 
       


     

       
211
       
 
       
      driver = setupDriverForTest {

     

       
212
       
 
       
        inherit testScript enableOCR skipLint passthru;

     

       
213
       
 
       
        testName = name;

     

       
214
       
 
       
        qemu_pkg = pkgs.qemu_test;

     

       
215
       
-
       
        nodes = nodes pkgs.qemu_test;

     

       
216
       
 
       
      };

     

       
217
       
 
       
      driverInteractive = setupDriverForTest {

     

       
218
       
 
       
        inherit testScript enableOCR skipLint passthru;

     

       
219
       
 
       
        testName = name;

     

       
220
       
 
       
        qemu_pkg = pkgs.qemu;

     

       
221
       
-
       
        nodes = nodes pkgs.qemu;

     

       
222
       
 
       
        interactive = true;

     

       
223
       
 
       
      };

     

       
224
       
 
       


     

       
225
       
-
       
      test =

     

       
226
       
-
       
        let

     

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

     

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

     

       
229
       
-
       
          };

     

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

     

       
231
       
 
       


     

       
232
       
 
       
    in

     

       
233
       
 
       
      test // {

     

       
234
       
-
       
        inherit test driver driverInteractive nodes;

     

       
0
       
 
       

     

       
235
       
 
       
      };

     

       
236
       
 
       


     

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

     

···

       
146
       
 
       


     

       
147
       
 
       
  # Make a full-blown test

     

       
148
       
 
       
  makeTest =

     

       
149
       
+
       
    { machine ? null

     

       
150
       
+
       
    , nodes ? {}

     

       
151
       
+
       
    , testScript

     

       
152
       
 
       
    , enableOCR ? false

     

       
153
       
 
       
    , name ? "unnamed"

     

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

     

       
155
       
 
       
    , skipLint ? false

     

       
156
       
 
       
    , passthru ? {}

     

       
157
       
+
       
    , meta ? {}

     

       
158
       
 
       
    , # For meta.position

     

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

     

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

     

       
161
       
+
       
          then builtins.unsafeGetAttrPos "description" meta

     

       
162
       
 
       
          else builtins.unsafeGetAttrPos "testScript" t)

     

       
0
       
 
       

     

       
163
       
 
       
    } @ t:

     

       
164
       
 
       
    let

     

       
165
       
+
       
      mkNodes = qemu_pkg:

     

       
166
       
 
       
        let

     

       
167
       
 
       
          testScript' =

     

       
168
       
 
       
            # Call the test script with the computed nodes.

     

       
169
       
 
       
            if lib.isFunction testScript

     

       
170
       
+
       
            then testScript { nodes = mkNodes qemu_pkg; }

     

       
171
       
 
       
            else testScript;

     

       
172
       
 
       


     

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

     
···

       
207
       
 
       
          };

     

       
208
       
 
       
        in

     

       
209
       
 
       
          build-vms.buildVirtualNetwork (

     

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

     

       
211
       
 
       
          );

     

       
212
       
 
       


     

       
213
       
 
       
      driver = setupDriverForTest {

     

       
214
       
 
       
        inherit testScript enableOCR skipLint passthru;

     

       
215
       
 
       
        testName = name;

     

       
216
       
 
       
        qemu_pkg = pkgs.qemu_test;

     

       
217
       
+
       
        nodes = mkNodes pkgs.qemu_test;

     

       
218
       
 
       
      };

     

       
219
       
 
       
      driverInteractive = setupDriverForTest {

     

       
220
       
 
       
        inherit testScript enableOCR skipLint passthru;

     

       
221
       
 
       
        testName = name;

     

       
222
       
 
       
        qemu_pkg = pkgs.qemu;

     

       
223
       
+
       
        nodes = mkNodes pkgs.qemu;

     

       
224
       
 
       
        interactive = true;

     

       
225
       
 
       
      };

     

       
226
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
228
       
 
       


     

       
229
       
 
       
    in

     

       
230
       
 
       
      test // {

     

       
231
       
+
       
        inherit test driver driverInteractive;

     

       
232
       
+
       
        inherit (driver) nodes;

     

       
233
       
 
       
      };

     

       
234
       
 
       


     

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

     

···

       
117
       
 
       
    '';

     

       
118
       
 
       
  };

     

       
119
       
 
       


     

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

     

       
121
       
 
       


     

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

     

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

     

···

       
117
       
 
       
    '';

     

       
118
       
 
       
  };

     

       
119
       
 
       


     

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

     

       
121
       
 
       


     

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

     

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

     

···

       
81
       
 
       
  ###### implementation

     

       
82
       
 
       


     

       
83
       
 
       
  config = {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
84
       
 
       


     

       
85
       
-
       
    systemd.services.nix-gc = {

     

       
86
       
 
       
      description = "Nix Garbage Collector";

     

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

     

       
88
       
 
       
      startAt = optional cfg.automatic cfg.dates;

     

···

       
81
       
 
       
  ###### implementation

     

       
82
       
 
       


     

       
83
       
 
       
  config = {

     

       
84
       
+
       
    assertions = [

     

       
85
       
+
       
      {

     

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

     

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

     

       
88
       
+
       
      }

     

       
89
       
+
       
    ];

     

       
90
       
 
       


     

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

     

       
92
       
 
       
      description = "Nix Garbage Collector";

     

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

     

       
94
       
 
       
      startAt = optional cfg.automatic cfg.dates;

     

···

       
37
       
 
       
  ###### implementation

     

       
38
       
 
       


     

       
39
       
 
       
  config = {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
40
       
 
       


     

       
41
       
-
       
    systemd.services.nix-optimise =

     

       
42
       
 
       
      { description = "Nix Store Optimiser";

     

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

     

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

     

···

       
37
       
 
       
  ###### implementation

     

       
38
       
 
       


     

       
39
       
 
       
  config = {

     

       
40
       
+
       
    assertions = [

     

       
41
       
+
       
      {

     

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

     

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

     

       
44
       
+
       
      }

     

       
45
       
+
       
    ];

     

       
46
       
 
       


     

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

     

       
48
       
 
       
      { description = "Nix Store Optimiser";

     

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

     

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

     

···

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

     

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

     

       
798
       
 
       
    # dependency.)

     

       
799
       
-
       
    boot.postBootCommands =

     

       
800
       
 
       
      ''

     

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

     

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

     

···

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

     

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

     

       
798
       
 
       
    # dependency.)

     

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

     

       
800
       
 
       
      ''

     

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

     

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

     

···

       
38
       
 
       
      } // extraConfig);

     

       
39
       
 
       
    in

     

       
40
       
 
       
      makeTest {

     

       
41
       
-
       
        inherit iso;

     

       
42
       
 
       
        name = "boot-" + name;

     

       
43
       
 
       
        nodes = { };

     

       
44
       
 
       
        testScript =

     

···

       
38
       
 
       
      } // extraConfig);

     

       
39
       
 
       
    in

     

       
40
       
 
       
      makeTest {

     

       
0
       
 
       

     

       
41
       
 
       
        name = "boot-" + name;

     

       
42
       
 
       
        nodes = { };

     

       
43
       
 
       
        testScript =

     

···

       
7
       
 
       
  nodes = {

     

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

     

       
9
       
 
       
      services.caddy.enable = true;

     

       
10
       
-
       
      services.caddy.config = ''

     

       
11
       
 
       
        http://localhost {

     

       
12
       
 
       
          encode gzip

     

       
13
       
 
       


     
···

       
22
       
 
       
      '';

     

       
23
       
 
       


     

       
24
       
 
       
      specialisation.etag.configuration = {

     

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

     

       
26
       
 
       
          http://localhost {

     

       
27
       
 
       
            encode gzip

     

       
28
       
 
       


     
···

       
38
       
 
       
      };

     

       
39
       
 
       


     

       
40
       
 
       
      specialisation.config-reload.configuration = {

     

       
41
       
-
       
        services.caddy.config = ''

     

       
42
       
 
       
          http://localhost:8080 {

     

       
43
       
 
       
          }

     

       
44
       
 
       
        '';

     

···

       
7
       
 
       
  nodes = {

     

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

     

       
9
       
 
       
      services.caddy.enable = true;

     

       
10
       
+
       
      services.caddy.extraConfig = ''

     

       
11
       
 
       
        http://localhost {

     

       
12
       
 
       
          encode gzip

     

       
13
       
 
       


     
···

       
22
       
 
       
      '';

     

       
23
       
 
       


     

       
24
       
 
       
      specialisation.etag.configuration = {

     

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

     

       
26
       
 
       
          http://localhost {

     

       
27
       
 
       
            encode gzip

     

       
28
       
 
       


     
···

       
38
       
 
       
      };

     

       
39
       
 
       


     

       
40
       
 
       
      specialisation.config-reload.configuration = {

     

       
41
       
+
       
        services.caddy.extraConfig = ''

     

       
42
       
 
       
          http://localhost:8080 {

     

       
43
       
 
       
          }

     

       
44
       
 
       
        '';

     

···

       
48
       
 
       
      sudo

     

       
49
       
 
       
      ceph

     

       
50
       
 
       
      xfsprogs

     

       
51
       
-
       
      netcat-openbsd

     

       
52
       
 
       
    ];

     

       
53
       
 
       


     

       
54
       
 
       
    boot.kernelModules = [ "xfs" ];

     

···

       
48
       
 
       
      sudo

     

       
49
       
 
       
      ceph

     

       
50
       
 
       
      xfsprogs

     

       
51
       
+
       
      libressl.nc

     

       
52
       
 
       
    ];

     

       
53
       
 
       


     

       
54
       
 
       
    boot.kernelModules = [ "xfs" ];

     

···

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

     

       
16
       
 
       
with pkgs.lib;

     

       
17
       
 
       


     

       
18
       
-
       
mapAttrs (channel: chromiumPkg: makeTest rec {

     

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

     

       
20
       
-
       
  meta = {

     

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

     

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

     

       
23
       
-
       
    inherit (chromiumPkg.meta) timeout;

     

       
24
       
-
       
  };

     

       
25
       
-
       


     

       
26
       
-
       
  enableOCR = true;

     

       
27
       
-
       


     

       
28
       
 
       
  user = "alice";

     

       
29
       
-
       


     

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

     

       
31
       
-
       
  machine.virtualisation.memorySize = 2047;

     

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

     

       
33
       
-
       
  machine.environment = {

     

       
34
       
-
       
    systemPackages = [ chromiumPkg ];

     

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

     

       
36
       
-
       
  };

     

       
37
       
 
       


     

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

     

       
39
       
 
       
    <!DOCTYPE html>

     
···

       
50
       
 
       
    </body>

     

       
51
       
 
       
    </html>

     

       
52
       
 
       
  '';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
53
       
 
       


     

       
54
       
 
       
  testScript = let

     

       
55
       
 
       
    xdo = name: text: let

     

···

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

     

       
16
       
 
       
with pkgs.lib;

     

       
17
       
 
       


     

       
18
       
+
       
let

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       
  user = "alice";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
20
       
 
       


     

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

     

       
22
       
 
       
    <!DOCTYPE html>

     
···

       
33
       
 
       
    </body>

     

       
34
       
 
       
    </html>

     

       
35
       
 
       
  '';

     

       
36
       
+
       
in

     

       
37
       
+
       


     

       
38
       
+
       
mapAttrs (channel: chromiumPkg: makeTest {

     

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

     

       
40
       
+
       
  meta = {

     

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

     

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

     

       
43
       
+
       
    inherit (chromiumPkg.meta) timeout;

     

       
44
       
+
       
  };

     

       
45
       
+
       


     

       
46
       
+
       
  enableOCR = true;

     

       
47
       
+
       


     

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

     

       
49
       
+
       
  machine.virtualisation.memorySize = 2047;

     

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

     

       
51
       
+
       
  machine.environment = {

     

       
52
       
+
       
    systemPackages = [ chromiumPkg ];

     

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

     

       
54
       
+
       
  };

     

       
55
       
 
       


     

       
56
       
 
       
  testScript = let

     

       
57
       
 
       
    xdo = name: text: let

     

···

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

     

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

     

       
3
       
 
       
  name = "cri-o";

     

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

     

       
5
       
 
       


     

       
6
       
 
       
  nodes = {

     

       
7
       
 
       
    crio = {

     

···

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

     

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

     

       
3
       
 
       
  name = "cri-o";

     

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

     

       
5
       
 
       


     

       
6
       
 
       
  nodes = {

     

       
7
       
 
       
    crio = {

     

···

       
20
       
 
       
        nodes = {

     

       
21
       
 
       


     

       
22
       
 
       
          server =

     

       
23
       
-
       
            { ... }:

     

       
24
       
 
       
              {

     

       
25
       
 
       
                networking.firewall.allowedTCPPorts = [ 80 ];

     

       
26
       
 
       


     

···

       
20
       
 
       
        nodes = {

     

       
21
       
 
       


     

       
22
       
 
       
          server =

     

       
23
       
+
       
            { config, ... }:

     

       
24
       
 
       
              {

     

       
25
       
 
       
                networking.firewall.allowedTCPPorts = [ 80 ];

     

       
26
       
 
       


     

···

       
21
       
 
       
        forceSSL = true;

     

       
22
       
 
       
      };

     

       
23
       
 
       


     

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

     

       
25
       
 
       
      security.acme.acceptTerms = true;

     

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

     

       
0
       
 
       

     

       
27
       
 
       
    };

     

       
28
       
 
       
  };

     

       
29
       
 
       


     

···

       
21
       
 
       
        forceSSL = true;

     

       
22
       
 
       
      };

     

       
23
       
 
       


     

       
0
       
 
       

     

       
24
       
 
       
      security.acme.acceptTerms = true;

     

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

     

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

     

       
27
       
 
       
    };

     

       
28
       
 
       
  };

     

       
29
       
 
       


     

···

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

     

       
2
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4
       
 
       
  name = "misc";

     

       
5
       
 
       
  meta = with pkgs.lib.maintainers; {

     

       
6
       
 
       
    maintainers = [ eelco ];

     

       
7
       
 
       
  };

     

       
8
       
-
       


     

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

     

       
10
       
 
       


     

       
11
       
 
       
  machine =

     

       
12
       
 
       
    { lib, ... }:

     

···

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

     

       
2
       
 
       


     

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

     

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

     

       
5
       
+
       
in {

     

       
6
       
 
       
  name = "misc";

     

       
7
       
 
       
  meta = with pkgs.lib.maintainers; {

     

       
8
       
 
       
    maintainers = [ eelco ];

     

       
9
       
 
       
  };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
10
       
 
       


     

       
11
       
 
       
  machine =

     

       
12
       
 
       
    { lib, ... }:

     

···

       
14
       
 
       
      };

     

       
15
       
 
       
    };

     

       
16
       
 
       


     

       
17
       
-
       
    users.testuser = {

     

       
18
       
-
       
      uid = 1000;

     

       
19
       
-
       
      group = "testgroup";

     

       
20
       
-
       
    };

     

       
21
       
-
       
    groups.testgroup.gid = 1000;

     

       
22
       
-
       


     

       
23
       
 
       
    testScript = ''

     

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

     

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

     

···

       
14
       
 
       
      };

     

       
15
       
 
       
    };

     

       
16
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       
    testScript = ''

     

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

     

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

     

···

       
42
       
 
       


     

       
43
       
 
       
        caclient =

     

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

     

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

     

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

     

       
47
       
 
       
            security.acme.acceptTerms = true;

     

       
48
       
 
       


     

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

     

···

       
42
       
 
       


     

       
43
       
 
       
        caclient =

     

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

     

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

     

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

     

       
47
       
 
       
            security.acme.acceptTerms = true;

     

       
48
       
 
       


     

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

     

···

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

     

       
2
       
 
       


     

       
3
       
-
       
rec {

     

       
4
       
 
       
  name = "tor";

     

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

     

       
6
       
 
       


     

       
7
       
-
       
  common =

     

       
8
       
-
       
    { ... }:

     

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

     

       
10
       
-
       
      networking.firewall.enable = false;

     

       
11
       
-
       
      networking.useDHCP = false;

     

       
12
       
-
       
    };

     

       
13
       
 
       


     

       
14
       
-
       
  nodes.client =

     

       
15
       
-
       
    { pkgs, ... }:

     

       
16
       
-
       
    { imports = [ common ];

     

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

     

       
18
       
-
       
      services.tor.enable = true;

     

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

     

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

     

       
21
       
-
       
    };

     

       
22
       
 
       


     

       
23
       
 
       
  testScript = ''

     

       
24
       
 
       
    client.wait_for_unit("tor.service")

     

···

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

     

       
2
       
 
       


     

       
3
       
+
       
{

     

       
4
       
 
       
  name = "tor";

     

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

     

       
6
       
 
       


     

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

     

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

     

       
9
       
+
       
    networking.firewall.enable = false;

     

       
10
       
+
       
    networking.useDHCP = false;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
11
       
 
       


     

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

     

       
13
       
+
       
    services.tor.enable = true;

     

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

     

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

     

       
16
       
+
       
  };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       


     

       
18
       
 
       
  testScript = ''

     

       
19
       
 
       
    client.wait_for_unit("tor.service")

     

···

       
4
       
 
       
    maintainers = [ ericson2314 ];

     

       
5
       
 
       
  };

     

       
6
       
 
       


     

       
7
       
-
       
  nixpkgs.overlays = [

     

       
8
       
-
       
    (self: super: {

     

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

     

       
10
       
-
       
    })

     

       
11
       
-
       
  ];

     

       
12
       
-
       


     

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

     

       
14
       
 
       
    nix.enable = false;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       
  };

     

       
16
       
 
       


     

       
17
       
 
       
  testScript = ''

     

···

       
4
       
 
       
    maintainers = [ ericson2314 ];

     

       
5
       
 
       
  };

     

       
6
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
8
       
 
       
    nix.enable = false;

     

       
9
       
+
       
    nixpkgs.overlays = [

     

       
10
       
+
       
      (self: super: {

     

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

     

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

     

       
13
       
+
       
        # aliases, some deprecated

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       
22
       
+
       
      })

     

       
23
       
+
       
    ];

     

       
24
       
 
       
  };

     

       
25
       
 
       


     

       
26
       
 
       
  testScript = ''

     

···

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

     

       
27
       
 
       
    }).toplevel;

     

       
28
       
 
       


     

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

     

       
30
       
 
       
      name = "nixosTest-test";

     

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

     

       
32
       
 
       
        system.nixos = dummyVersioning;

     

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

     

       
34
       
 
       
      };

     

       
35
       
 
       
      testScript = ''

     

       
36
       
-
       
        machine.succeed("hello")

     

       
37
       
 
       
      '';

     

       
38
       
 
       
    });

     

       
39
       
 
       


     

···

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

     

       
27
       
 
       
    }).toplevel;

     

       
28
       
 
       


     

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

     

       
30
       
 
       
      name = "nixosTest-test";

     

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

     

       
32
       
 
       
        system.nixos = dummyVersioning;

     

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

     

       
34
       
 
       
      };

     

       
35
       
 
       
      testScript = ''

     

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

     

       
37
       
 
       
      '';

     

       
38
       
 
       
    });

     

       
39
       
 
       


     

···

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

     

       
33716
       
 
       
            then import test

     

       
33717
       
 
       
            else test;

     

       
33718
       
-
       
          calledTest = if lib.isFunction loadedTest

     

       
33719
       
-
       
            then callPackage loadedTest {}

     

       
33720
       
-
       
            else loadedTest;

     

       
33721
       
 
       
        in

     

       
33722
       
 
       
          nixosTesting.makeTest calledTest;

     

       
33723
       
 
       


     

···

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

     

       
33716
       
 
       
            then import test

     

       
33717
       
 
       
            else test;

     

       
33718
       
+
       
          calledTest = lib.toFunction loadedTest pkgs;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
33719
       
 
       
        in

     

       
33720
       
 
       
          nixosTesting.makeTest calledTest;

     

       
33721