commit fb24b403c17c5faa6ea69b7b3c658a9061b8bf26 · pyrox.dev/nixpkgs

+15 -5

nixos/tests/all-tests.nix

···

       616
        
         pyload = runTest ./pyload.nix;

     

       617
        
         oci-containers = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./oci-containers.nix { };

     

       618
        
         odoo = runTest ./odoo.nix;

     

       619
       -
         odoo17 = handleTest ./odoo.nix { package = pkgs.odoo17; };

     

       620
       -
         odoo16 = handleTest ./odoo.nix { package = pkgs.odoo16; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       621
        
         oncall = runTest ./web-apps/oncall.nix;

     

       622
        
         # 9pnet_virtio used to mount /nix partition doesn't support

     

       623
        
         # hibernation. This test happens to work on x86_64-linux but

     
···

       1297
        
         systemd-initrd-btrfs-raid = runTest ./systemd-initrd-btrfs-raid.nix;

     

       1298
        
         systemd-initrd-luks-fido2 = runTest ./systemd-initrd-luks-fido2.nix;

     

       1299
        
         systemd-initrd-luks-keyfile = runTest ./systemd-initrd-luks-keyfile.nix;

     

       1300
       -
         systemd-initrd-luks-empty-passphrase = handleTest ./initrd-luks-empty-passphrase.nix {

     

       1301
       -
           systemdStage1 = true;

     

       0
        
       
     

       1302
        
         };

     

       1303
        
         systemd-initrd-luks-password = runTest ./systemd-initrd-luks-password.nix;

     

       1304
        
         systemd-initrd-luks-tpm2 = runTest ./systemd-initrd-luks-tpm2.nix;

     
···

       1310
        
           "x86_64-linux"

     

       1311
        
           "i686-linux"

     

       1312
        
         ] ./initrd-network-openvpn { systemdStage1 = true; };

     

       1313
       -
         systemd-initrd-shutdown = handleTest ./systemd-shutdown.nix { systemdStage1 = true; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1314
        
         systemd-initrd-simple = runTest ./systemd-initrd-simple.nix;

     

       1315
        
         systemd-initrd-swraid = runTest ./systemd-initrd-swraid.nix;

     

       1316
        
         systemd-initrd-vconsole = runTest ./systemd-initrd-vconsole.nix;

···

       616
        
         pyload = runTest ./pyload.nix;

     

       617
        
         oci-containers = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./oci-containers.nix { };

     

       618
        
         odoo = runTest ./odoo.nix;

     

       619
       +
         odoo17 = runTest {

     

       620
       +
           imports = [ ./odoo.nix ];

     

       621
       +
           _module.args.package = pkgs.odoo17;

     

       622
       +
         };

     

       623
       +
         odoo16 = runTest {

     

       624
       +
           imports = [ ./odoo.nix ];

     

       625
       +
           _module.args.package = pkgs.odoo16;

     

       626
       +
         };

     

       627
        
         oncall = runTest ./web-apps/oncall.nix;

     

       628
        
         # 9pnet_virtio used to mount /nix partition doesn't support

     

       629
        
         # hibernation. This test happens to work on x86_64-linux but

     
···

       1303
        
         systemd-initrd-btrfs-raid = runTest ./systemd-initrd-btrfs-raid.nix;

     

       1304
        
         systemd-initrd-luks-fido2 = runTest ./systemd-initrd-luks-fido2.nix;

     

       1305
        
         systemd-initrd-luks-keyfile = runTest ./systemd-initrd-luks-keyfile.nix;

     

       1306
       +
         systemd-initrd-luks-empty-passphrase = runTest {

     

       1307
       +
           imports = [ ./initrd-luks-empty-passphrase.nix ];

     

       1308
       +
           _module.args.systemdStage1 = true;

     

       1309
        
         };

     

       1310
        
         systemd-initrd-luks-password = runTest ./systemd-initrd-luks-password.nix;

     

       1311
        
         systemd-initrd-luks-tpm2 = runTest ./systemd-initrd-luks-tpm2.nix;

     
···

       1317
        
           "x86_64-linux"

     

       1318
        
           "i686-linux"

     

       1319
        
         ] ./initrd-network-openvpn { systemdStage1 = true; };

     

       1320
       +
         systemd-initrd-shutdown = runTest {

     

       1321
       +
           imports = [ ./systemd-shutdown.nix ];

     

       1322
       +
           _module.args.systemdStage1 = true;

     

       1323
       +
         };

     

       1324
        
         systemd-initrd-simple = runTest ./systemd-initrd-simple.nix;

     

       1325
        
         systemd-initrd-swraid = runTest ./systemd-initrd-swraid.nix;

     

       1326
        
         systemd-initrd-vconsole = runTest ./systemd-initrd-vconsole.nix;

nixos/tests/breitbandmessung.nix

···

       3
        
         name = "breitbandmessung";

     

       4
        
         meta.maintainers = with lib.maintainers; [ b4dm4n ];

     

       5
        
       

     

       0
        
       
     

       0
        
       
     

       6
        
         nodes.machine =

     

       7
        
           { pkgs, ... }:

     

       8
        
           {

···

       3
        
         name = "breitbandmessung";

     

       4
        
         meta.maintainers = with lib.maintainers; [ b4dm4n ];

     

       5
        
       

     

       6
       +
         node.pkgsReadOnly = false;

     

       7
       +
       

     

       8
        
         nodes.machine =

     

       9
        
           { pkgs, ... }:

     

       10
        
           {

+18 -22

nixos/tests/brscan5.nix

···

       1
        
       # integration tests for brscan5 sane driver

     

       2
       -
       #

     

       3
       -
       

     

       4
       -
       { pkgs, ... }:

     

       5
        
       {

     

       6
        
         name = "brscan5";

     

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

     

       8
       -
           maintainers = [ mattchrist ];

     

       9
       -
         };

     

       10
        
       

     

       11
       -
         nodes.machine =

     

       12
       -
           { pkgs, ... }:

     

       13
       -
           {

     

       14
       -
             nixpkgs.config.allowUnfree = true;

     

       15
       -
             hardware.sane = {

     

       0
        
       
     

       0
        
       
     

       16
        
               enable = true;

     

       17
       -
               brscan5 = {

     

       18
       -
                 enable = true;

     

       19
       -
                 netDevices = {

     

       20
       -
                   "a" = {

     

       21
       -
                     model = "ADS-1200";

     

       22
       -
                     nodename = "BRW0080927AFBCE";

     

       23
       -
                   };

     

       24
       -
                   "b" = {

     

       25
       -
                     model = "ADS-1200";

     

       26
       -
                     ip = "192.168.1.2";

     

       27
       -
                   };

     

       28
        
                 };

     

       29
        
               };

     

       30
        
             };

     

       31
        
           };

     

       0
        
       
     

       32
        
       

     

       33
        
         testScript = ''

     

       34
        
           import re

···

       1
        
       # integration tests for brscan5 sane driver

     

       2
       +
       { lib, ... }:

     

       0
        
       
     

       0
        
       
     

       3
        
       {

     

       4
        
         name = "brscan5";

     

       5
       +
         meta.maintainers = with lib.maintainers; [ mattchrist ];

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       +
         node.pkgsReadOnly = false;

     

       8
       +
       

     

       9
       +
         nodes.machine = {

     

       10
       +
           nixpkgs.config.allowUnfree = true;

     

       11
       +
           hardware.sane = {

     

       12
       +
             enable = true;

     

       13
       +
             brscan5 = {

     

       14
        
               enable = true;

     

       15
       +
               netDevices = {

     

       16
       +
                 "a" = {

     

       17
       +
                   model = "ADS-1200";

     

       18
       +
                   nodename = "BRW0080927AFBCE";

     

       19
       +
                 };

     

       20
       +
                 "b" = {

     

       21
       +
                   model = "ADS-1200";

     

       22
       +
                   ip = "192.168.1.2";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
                 };

     

       24
        
               };

     

       25
        
             };

     

       26
        
           };

     

       27
       +
         };

     

       28
        
       

     

       29
        
         testScript = ''

     

       30
        
           import re

+3 -1

nixos/tests/consul.nix

···

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

     

       2
        
       

     

       3
        
       let

     

       4
        
         # Settings for both servers and agents

     
···

       116
        
       in

     

       117
        
       {

     

       118
        
         name = "consul";

     

       0
        
       
     

       0
        
       
     

       119
        
       

     

       120
        
         nodes = {

     

       121
        
           server1 = server 0;

···

       1
       +
       { lib, ... }:

     

       2
        
       

     

       3
        
       let

     

       4
        
         # Settings for both servers and agents

     
···

       116
        
       in

     

       117
        
       {

     

       118
        
         name = "consul";

     

       119
       +
       

     

       120
       +
         node.pkgsReadOnly = false;

     

       121
        
       

     

       122
        
         nodes = {

     

       123
        
           server1 = server 0;

+13 -18

nixos/tests/deconz.nix

···

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

     

       2
        
       let

     

       3
        
         httpPort = 800;

     

       4
        
       in

     
···

       9
        
           bjornfor

     

       10
        
         ];

     

       11
        
       

     

       12
       -
         nodes.machine =

     

       13
       -
           {

     

       14
       -
             config,

     

       15
       -
             pkgs,

     

       16
       -
             lib,

     

       17
       -
             ...

     

       18
       -
           }:

     

       19
       -
           {

     

       20
       -
             nixpkgs.config.allowUnfree = true;

     

       21
       -
             services.deconz = {

     

       22
       -
               enable = true;

     

       23
       -
               inherit httpPort;

     

       24
       -
               extraArgs = [

     

       25
       -
                 "--dbg-err=2"

     

       26
       -
                 "--dbg-info=2"

     

       27
       -
               ];

     

       28
       -
             };

     

       29
        
           };

     

       0
        
       
     

       30
        
       

     

       31
        
         testScript = ''

     

       32
        
           machine.wait_for_unit("deconz.service")

···

       1
       +
       { lib, ... }:

     

       2
        
       let

     

       3
        
         httpPort = 800;

     

       4
        
       in

     
···

       9
        
           bjornfor

     

       10
        
         ];

     

       11
        
       

     

       12
       +
         node.pkgsReadOnly = false;

     

       13
       +
       

     

       14
       +
         nodes.machine = {

     

       15
       +
           nixpkgs.config.allowUnfree = true;

     

       16
       +
           services.deconz = {

     

       17
       +
             enable = true;

     

       18
       +
             inherit httpPort;

     

       19
       +
             extraArgs = [

     

       20
       +
               "--dbg-err=2"

     

       21
       +
               "--dbg-info=2"

     

       22
       +
             ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
           };

     

       24
       +
         };

     

       25
        
       

     

       26
        
         testScript = ''

     

       27
        
           machine.wait_for_unit("deconz.service")

+5 -5

nixos/tests/discourse.nix

···

       4
        
       #  3. replying to that message via email.

     

       5
        
       

     

       6
        
       {

     

       0
        
       
     

       7
        
         pkgs,

     

       8
        
         lib,

     

       9
       -
         package ? pkgs.discourse,

     

       10
        
         ...

     

       11
        
       }:

     

       12
        
       let

     
···

       24
        
       in

     

       25
        
       {

     

       26
        
         name = "discourse";

     

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

     

       28
       -
           maintainers = [ talyz ];

     

       29
       -
         };

     

       30
        
       

     

       31
        
         nodes.discourse =

     

       32
        
           { nodes, ... }:

     
···

       62
        
       

     

       63
        
             services.discourse = {

     

       64
        
               enable = true;

     

       65
       -
               inherit admin package;

     

       66
        
               hostname = discourseDomain;

     

       67
        
               sslCertificate = "${certs.${discourseDomain}.cert}";

     

       68
        
               sslCertificateKey = "${certs.${discourseDomain}.key}";

···

       4
        
       #  3. replying to that message via email.

     

       5
        
       

     

       6
        
       {

     

       7
       +
         package,

     

       8
        
         pkgs,

     

       9
        
         lib,

     

       0
        
       
     

       10
        
         ...

     

       11
        
       }:

     

       12
        
       let

     
···

       24
        
       in

     

       25
        
       {

     

       26
        
         name = "discourse";

     

       27
       +
         meta.maintainers = with lib.maintainers; [ talyz ];

     

       28
       +
       

     

       29
       +
         _module.args.package = lib.mkDefault pkgs.discourse;

     

       30
        
       

     

       31
        
         nodes.discourse =

     

       32
        
           { nodes, ... }:

     
···

       62
        
       

     

       63
        
             services.discourse = {

     

       64
        
               enable = true;

     

       65
       +
               inherit admin;

     

       66
        
               hostname = discourseDomain;

     

       67
        
               sslCertificate = "${certs.${discourseDomain}.cert}";

     

       68
        
               sslCertificateKey = "${certs.${discourseDomain}.key}";

+8 -21

nixos/tests/fanout.nix

···

       1
       -
       {

     

       2
       -
         system ? builtins.currentSystem,

     

       3
       -
         config ? { },

     

       4
       -
         pkgs ? import ../.. { inherit system config; },

     

       5
       -
       }:

     

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

     

       7
        
       {

     

       8
        
         name = "fanout";

     

       9
       -
         meta.maintainers = [ lib.maintainers.therishidesai ];

     

       10
        
       

     

       11
       -
         nodes =

     

       12
       -
           let

     

       13
       -
             cfg =

     

       14
       -
               { ... }:

     

       15
       -
               {

     

       16
       -
                 services.fanout = {

     

       17
       -
                   enable = true;

     

       18
       -
                   fanoutDevices = 2;

     

       19
       -
                   bufferSize = 8192;

     

       20
       -
                 };

     

       21
       -
               };

     

       22
       -
           in

     

       23
       -
           {

     

       24
       -
             machine = cfg;

     

       25
        
           };

     

       0
        
       
     

       26
        
       

     

       27
        
         testScript = ''

     

       28
        
           start_all()

···

       1
       +
       { lib, ... }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       {

     

       3
        
         name = "fanout";

     

       4
       +
         meta.maintainers = with lib.maintainers; [ therishidesai ];

     

       5
        
       

     

       6
       +
         nodes.machine = {

     

       7
       +
           services.fanout = {

     

       8
       +
             enable = true;

     

       9
       +
             fanoutDevices = 2;

     

       10
       +
             bufferSize = 8192;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
           };

     

       12
       +
         };

     

       13
        
       

     

       14
        
         testScript = ''

     

       15
        
           start_all()

+10 -10

nixos/tests/gnome-extensions.nix

···

       3
        
         name = "gnome-extensions";

     

       4
        
         meta.maintainers = [ ];

     

       5
        
       

     

       0
        
       
     

       0
        
       
     

       6
        
         nodes.machine =

     

       7
        
           { pkgs, ... }:

     

       8
        
           {

     
···

       21
        
       

     

       22
        
             # Configure GDM

     

       23
        
             services.xserver.enable = true;

     

       24
       -
             services.xserver.displayManager = {

     

       25
       -
               gdm = {

     

       26
       -
                 enable = true;

     

       27
       -
                 debug = true;

     

       28
       -
                 wayland = true;

     

       29
       -
               };

     

       30
       -
               autoLogin = {

     

       31
       -
                 enable = true;

     

       32
       -
                 user = "alice";

     

       33
       -
               };

     

       34
        
             };

     

       35
        
       

     

       36
        
             # Configure Gnome

···

       3
        
         name = "gnome-extensions";

     

       4
        
         meta.maintainers = [ ];

     

       5
        
       

     

       6
       +
         node.pkgsReadOnly = false;

     

       7
       +
       

     

       8
        
         nodes.machine =

     

       9
        
           { pkgs, ... }:

     

       10
        
           {

     
···

       23
        
       

     

       24
        
             # Configure GDM

     

       25
        
             services.xserver.enable = true;

     

       26
       +
             services.xserver.displayManager.gdm = {

     

       27
       +
               enable = true;

     

       28
       +
               debug = true;

     

       29
       +
               wayland = true;

     

       30
       +
             };

     

       31
       +
             services.displayManager.autoLogin = {

     

       32
       +
               enable = true;

     

       33
       +
               user = "alice";

     

       0
        
       
     

       0
        
       
     

       34
        
             };

     

       35
        
       

     

       36
        
             # Configure Gnome

+6 -7

nixos/tests/initrd-luks-empty-passphrase.nix

···

       1
        
       {

     

       2
       -
         system ? builtins.currentSystem,

     

       3
       -
         config ? { },

     

       4
       -
         pkgs ? import ../.. { inherit system config; },

     

       5
       -
         systemdStage1 ? false,

     

       6
        
       }:

     

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

     

       8
        
       let

     

       9
       -
       

     

       10
        
         keyfile = pkgs.writeText "luks-keyfile" ''

     

       11
        
           MIGHAoGBAJ4rGTSo/ldyjQypd0kuS7k2OSsmQYzMH6TNj3nQ/vIUjDn7fqa3slt2

     

       12
        
           gV6EK3TmTbGc4tzC1v4SWx2m+2Bjdtn4Fs4wiBwn1lbRdC6i5ZYCqasTWIntWn+6

     

       13
        
           FllUkMD5oqjOR/YcboxG8Z3B5sJuvTP9llsF+gnuveWih9dpbBr7AgEC

     

       14
        
         '';

     

       15
       -
       

     

       16
        
       in

     

       17
        
       {

     

       18
        
         name = "initrd-luks-empty-passphrase";

     

       0
        
       
     

       0
        
       
     

       19
        
       

     

       20
        
         nodes.machine =

     

       21
        
           { pkgs, ... }:

···

       1
        
       {

     

       2
       +
         systemdStage1,

     

       3
       +
         lib,

     

       4
       +
         pkgs,

     

       5
       +
         ...

     

       6
        
       }:

     

       0
        
       
     

       7
        
       let

     

       0
        
       
     

       8
        
         keyfile = pkgs.writeText "luks-keyfile" ''

     

       9
        
           MIGHAoGBAJ4rGTSo/ldyjQypd0kuS7k2OSsmQYzMH6TNj3nQ/vIUjDn7fqa3slt2

     

       10
        
           gV6EK3TmTbGc4tzC1v4SWx2m+2Bjdtn4Fs4wiBwn1lbRdC6i5ZYCqasTWIntWn+6

     

       11
        
           FllUkMD5oqjOR/YcboxG8Z3B5sJuvTP9llsF+gnuveWih9dpbBr7AgEC

     

       12
        
         '';

     

       0
        
       
     

       13
        
       in

     

       14
        
       {

     

       15
        
         name = "initrd-luks-empty-passphrase";

     

       16
       +
       

     

       17
       +
         _module.args.systemdStage1 = lib.mkDefault false;

     

       18
        
       

     

       19
        
         nodes.machine =

     

       20
        
           { pkgs, ... }:

+4 -4

nixos/tests/minecraft-server.nix

···

       3
        
         rcon-pass = "foobar";

     

       4
        
         rcon-port = 43000;

     

       5
        
       in

     

       6
       -
       { pkgs, ... }:

     

       7
        
       {

     

       8
        
         name = "minecraft-server";

     

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

     

       10
       -
           maintainers = [ nequissimus ];

     

       11
       -
         };

     

       12
        
       

     

       13
        
         nodes.server =

     

       14
        
           { ... }:

···

       3
        
         rcon-pass = "foobar";

     

       4
        
         rcon-port = 43000;

     

       5
        
       in

     

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

     

       7
        
       {

     

       8
        
         name = "minecraft-server";

     

       9
       +
         meta.maintainers = with lib.maintainers; [ nequissimus ];

     

       10
       +
       

     

       11
       +
         node.pkgsReadOnly = false;

     

       12
        
       

     

       13
        
         nodes.server =

     

       14
        
           { ... }:

+21 -25

nixos/tests/odoo.nix

···

       1
        
       {

     

       2
       -
         pkgs,

     

       3
        
         lib,

     

       4
       -
         package ? pkgs.odoo,

     

       5
        
         ...

     

       6
        
       }:

     

       7
        
       {

     

       8
        
         name = "odoo";

     

       9
        
         meta.maintainers = with lib.maintainers; [ mkg20001 ];

     

       10
        
       

     

       11
       -
         nodes = {

     

       12
       -
           server =

     

       13
       -
             { ... }:

     

       14
       -
             {

     

       15
       -
               services.nginx = {

     

       16
       -
                 enable = true;

     

       17
       -
                 recommendedProxySettings = true;

     

       18
       -
               };

     

       19
        
       

     

       20
       -
               services.odoo = {

     

       21
       -
                 enable = true;

     

       22
       -
                 package = package;

     

       23
       -
                 autoInit = true;

     

       24
       -
                 autoInitExtraFlags = [ "--without-demo=all" ];

     

       25
       -
                 domain = "localhost";

     

       26
       -
               };

     

       27
       -
             };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       28
        
         };

     

       29
        
       

     

       30
       -
         testScript =

     

       31
       -
           { nodes, ... }:

     

       32
       -
           ''

     

       33
       -
             server.wait_for_unit("odoo.service")

     

       34
       -
             server.wait_until_succeeds("curl -s http://localhost:8069/web/database/selector | grep '<title>Odoo</title>'")

     

       35
       -
             server.succeed("curl -s http://localhost/web/database/selector | grep '<title>Odoo</title>'")

     

       36
       -
           '';

     

       37
        
       }

···

       1
        
       {

     

       2
       +
         package,

     

       3
        
         lib,

     

       4
       +
         pkgs,

     

       5
        
         ...

     

       6
        
       }:

     

       7
        
       {

     

       8
        
         name = "odoo";

     

       9
        
         meta.maintainers = with lib.maintainers; [ mkg20001 ];

     

       10
        
       

     

       11
       +
         _module.args.package = lib.mkDefault pkgs.odoo;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
       +
         nodes.server = {

     

       14
       +
           services.nginx = {

     

       15
       +
             enable = true;

     

       16
       +
             recommendedProxySettings = true;

     

       17
       +
           };

     

       18
       +
       

     

       19
       +
           services.odoo = {

     

       20
       +
             enable = true;

     

       21
       +
             package = package;

     

       22
       +
             autoInit = true;

     

       23
       +
             autoInitExtraFlags = [ "--without-demo=all" ];

     

       24
       +
             domain = "localhost";

     

       25
       +
           };

     

       26
        
         };

     

       27
        
       

     

       28
       +
         testScript = ''

     

       29
       +
           server.wait_for_unit("odoo.service")

     

       30
       +
           server.wait_until_succeeds("curl -s http://localhost:8069/web/database/selector | grep '<title>Odoo</title>'")

     

       31
       +
           server.succeed("curl -s http://localhost/web/database/selector | grep '<title>Odoo</title>'")

     

       32
       +
         '';

     

       0
        
       
     

       0
        
       
     

       33
        
       }

+4 -1

nixos/tests/openldap.nix

···

       54
        
         name = "openldap";

     

       55
        
       

     

       56
        
         nodes.machine =

     

       57
       -
           { pkgs, ... }:

     

       58
        
           {

     

       59
        
             environment.etc."openldap/root_password".text = "notapassword";

     

       60
        
       

     
···

       124
        
                 configuration =

     

       125
        
                   { ... }:

     

       126
        
                   {

     

       0
        
       
     

       0
        
       
     

       127
        
                     users.ldap = ldapClientConfig;

     

       128
        
                     services.openldap = {

     

       129
        
                       enable = true;

     
···

       133
        
               };

     

       134
        
             };

     

       135
        
           };

     

       0
        
       
     

       136
        
         testScript =

     

       137
        
           { nodes, ... }:

     

       138
        
           let

···

       54
        
         name = "openldap";

     

       55
        
       

     

       56
        
         nodes.machine =

     

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

     

       58
        
           {

     

       59
        
             environment.etc."openldap/root_password".text = "notapassword";

     

       60
        
       

     
···

       124
        
                 configuration =

     

       125
        
                   { ... }:

     

       126
        
                   {

     

       127
       +
                     nixpkgs.hostPlatform = config.nixpkgs.hostPlatform;

     

       128
       +
       

     

       129
        
                     users.ldap = ldapClientConfig;

     

       130
        
                     services.openldap = {

     

       131
        
                       enable = true;

     
···

       135
        
               };

     

       136
        
             };

     

       137
        
           };

     

       138
       +
       

     

       139
        
         testScript =

     

       140
        
           { nodes, ... }:

     

       141
        
           let

+20 -20

nixos/tests/outline.nix

···

       15
        
       

     

       16
        
         meta.maintainers = lib.teams.cyberus.members;

     

       17
        
       

     

       18
       -
         nodes = {

     

       19
       -
           outline =

     

       20
       -
             { pkgs, config, ... }:

     

       21
       -
             {

     

       22
       -
               nixpkgs.config.allowUnfree = true;

     

       23
       -
               environment.systemPackages = [ pkgs.minio-client ];

     

       24
       -
               services.outline = {

     

       25
       -
                 enable = true;

     

       26
       -
                 forceHttps = false;

     

       27
       -
                 storage = {

     

       28
       -
                   inherit accessKey secretKeyFile;

     

       29
       -
                   uploadBucketUrl = "http://localhost:9000";

     

       30
       -
                   uploadBucketName = "outline";

     

       31
       -
                   region = config.services.minio.region;

     

       32
       -
                 };

     

       33
       -
               };

     

       34
       -
               services.minio = {

     

       35
       -
                 enable = true;

     

       36
       -
                 inherit rootCredentialsFile;

     

       37
        
               };

     

       38
        
             };

     

       39
       -
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
       

     

       41
        
         testScript = ''

     

       42
        
           machine.wait_for_unit("minio.service")

···

       15
        
       

     

       16
        
         meta.maintainers = lib.teams.cyberus.members;

     

       17
        
       

     

       18
       +
         node.pkgsReadOnly = false;

     

       19
       +
       

     

       20
       +
         nodes.outline =

     

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

     

       22
       +
           {

     

       23
       +
             nixpkgs.config.allowUnfree = true;

     

       24
       +
             environment.systemPackages = [ pkgs.minio-client ];

     

       25
       +
             services.outline = {

     

       26
       +
               enable = true;

     

       27
       +
               forceHttps = false;

     

       28
       +
               storage = {

     

       29
       +
                 inherit accessKey secretKeyFile;

     

       30
       +
                 uploadBucketUrl = "http://localhost:9000";

     

       31
       +
                 uploadBucketName = "outline";

     

       32
       +
                 region = config.services.minio.region;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
               };

     

       34
        
             };

     

       35
       +
             services.minio = {

     

       36
       +
               enable = true;

     

       37
       +
               inherit rootCredentialsFile;

     

       38
       +
             };

     

       39
       +
           };

     

       40
        
       

     

       41
        
         testScript = ''

     

       42
        
           machine.wait_for_unit("minio.service")

+5 -12

nixos/tests/quake3.nix

···

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

     

       2
       -
       

     

       3
        
       let

     

       4
       -
       

     

       5
        
         # Build Quake with coverage instrumentation.

     

       6
        
         overrides = pkgs: {

     

       7
        
           quake3game = pkgs.quake3game.override (args: {

     
···

       23
        
       

     

       24
        
         client =

     

       25
        
           { pkgs, ... }:

     

       26
       -
       

     

       27
        
           {

     

       28
        
             imports = [ ./common/x11.nix ];

     

       29
        
             hardware.graphics.enable = true;

     
···

       31
        
             nixpkgs.config.packageOverrides = overrides;

     

       32
        
             nixpkgs.config.allowUnfreePredicate = unfreePredicate;

     

       33
        
           };

     

       34
       -
       

     

       35
        
       in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
       

     

       37
       -
       rec {

     

       38
       -
         name = "quake3";

     

       39
       -
         meta = with lib.maintainers; {

     

       40
       -
           maintainers = [ domenkozar ];

     

       41
       -
         };

     

       42
        
       

     

       43
        
         # TODO: lcov doesn't work atm

     

       44
        
         #makeCoverageReport = true;

     
···

       46
        
         nodes = {

     

       47
        
           server =

     

       48
        
             { pkgs, ... }:

     

       49
       -
       

     

       50
        
             {

     

       51
        
               systemd.services.quake3-server = {

     

       52
        
                 wantedBy = [ "multi-user.target" ];

     
···

       96
        
           client2.shutdown()

     

       97
        
           server.stop_job("quake3-server")

     

       98
        
         '';

     

       99
       -
       

     

       100
        
       }

···

       1
       +
       { lib, ... }:

     

       0
        
       
     

       2
        
       let

     

       0
        
       
     

       3
        
         # Build Quake with coverage instrumentation.

     

       4
        
         overrides = pkgs: {

     

       5
        
           quake3game = pkgs.quake3game.override (args: {

     
···

       21
        
       

     

       22
        
         client =

     

       23
        
           { pkgs, ... }:

     

       0
        
       
     

       24
        
           {

     

       25
        
             imports = [ ./common/x11.nix ];

     

       26
        
             hardware.graphics.enable = true;

     
···

       28
        
             nixpkgs.config.packageOverrides = overrides;

     

       29
        
             nixpkgs.config.allowUnfreePredicate = unfreePredicate;

     

       30
        
           };

     

       0
        
       
     

       31
        
       in

     

       32
       +
       {

     

       33
       +
         name = "quake3";

     

       34
       +
         meta.maintainers = with lib.maintainers; [ domenkozar ];

     

       35
        
       

     

       36
       +
         node.pkgsReadOnly = false;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
       

     

       38
        
         # TODO: lcov doesn't work atm

     

       39
        
         #makeCoverageReport = true;

     
···

       41
        
         nodes = {

     

       42
        
           server =

     

       43
        
             { pkgs, ... }:

     

       0
        
       
     

       44
        
             {

     

       45
        
               systemd.services.quake3-server = {

     

       46
        
                 wantedBy = [ "multi-user.target" ];

     
···

       90
        
           client2.shutdown()

     

       91
        
           server.stop_job("quake3-server")

     

       92
        
         '';

     

       0
        
       
     

       93
        
       }

+5 -5

nixos/tests/sabnzbd.nix

···

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

     

       2
        
       {

     

       3
        
         name = "sabnzbd";

     

       4
       -
         meta = with pkgs.lib; {

     

       5
       -
           maintainers = with maintainers; [ jojosch ];

     

       6
       -
         };

     

       7
        
       

     

       8
        
         nodes.machine =

     

       9
       -
           { pkgs, ... }:

     

       10
        
           {

     

       11
        
             services.sabnzbd = {

     

       12
        
               enable = true;

···

       1
       +
       { lib, ... }:

     

       2
        
       {

     

       3
        
         name = "sabnzbd";

     

       4
       +
         meta.maintainers = with lib.maintainers; [ jojosch ];

     

       5
       +
       

     

       6
       +
         node.pkgsReadOnly = false;

     

       7
        
       

     

       8
        
         nodes.machine =

     

       9
       +
           { lib, ... }:

     

       10
        
           {

     

       11
        
             services.sabnzbd = {

     

       12
        
               enable = true;

+3 -3

nixos/tests/squid.nix

···

       43
        
       in

     

       44
        
       {

     

       45
        
         name = "squid";

     

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

     

       47
       -
           maintainers = [ cobalt ];

     

       48
       -
         };

     

       49
        
       

     

       50
        
         nodes = {

     

       51
        
           client =

···

       43
        
       in

     

       44
        
       {

     

       45
        
         name = "squid";

     

       46
       +
         meta.maintainers = with lib.maintainers; [ cobalt ];

     

       47
       +
       

     

       48
       +
         node.pkgsReadOnly = false;

     

       49
        
       

     

       50
        
         nodes = {

     

       51
        
           client =

+5 -5

nixos/tests/systemd-analyze.nix

···

       1
        
       {

     

       2
       -
         pkgs,

     

       3
       -
         latestKernel ? false,

     

       4
        
         ...

     

       5
        
       }:

     

       6
        
       

     

       7
        
       {

     

       8
        
         name = "systemd-analyze";

     

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

     

       10
       -
           maintainers = [ raskin ];

     

       11
       -
         };

     

       12
        
       

     

       13
        
         nodes.machine =

     

       14
        
           { pkgs, lib, ... }:

···

       1
        
       {

     

       2
       +
         latestKernel,

     

       3
       +
         lib,

     

       4
        
         ...

     

       5
        
       }:

     

       6
        
       

     

       7
        
       {

     

       8
        
         name = "systemd-analyze";

     

       9
       +
         meta.maintainers = with lib.maintainers; [ raskin ];

     

       10
       +
       

     

       11
       +
         _module.args.latestKernel = lib.mkDefault false;

     

       12
        
       

     

       13
        
         nodes.machine =

     

       14
        
           { pkgs, lib, ... }:

+5 -4

nixos/tests/systemd-shutdown.nix

···

       1
        
       {

     

       0
        
       
     

       0
        
       
     

       2
        
         pkgs,

     

       3
       -
         systemdStage1 ? false,

     

       4
        
         ...

     

       5
        
       }:

     

       6
        
       let

     
···

       8
        
       in

     

       9
        
       {

     

       10
        
         name = "systemd-shutdown";

     

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

     

       12
       -
           maintainers = [ das_j ];

     

       13
       -
         };

     

       14
        
       

     

       15
        
         nodes.machine = {

     

       16
        
           imports = [ ../modules/profiles/minimal.nix ];

···

       1
        
       {

     

       2
       +
         systemdStage1,

     

       3
       +
         lib,

     

       4
        
         pkgs,

     

       0
        
       
     

       5
        
         ...

     

       6
        
       }:

     

       7
        
       let

     
···

       9
        
       in

     

       10
        
       {

     

       11
        
         name = "systemd-shutdown";

     

       12
       +
         meta.maintainers = with lib.maintainers; [ das_j ];

     

       13
       +
       

     

       14
       +
         _module.args.systemdStage1 = lib.mkDefault false;

     

       15
        
       

     

       16
        
         nodes.machine = {

     

       17
        
           imports = [ ../modules/profiles/minimal.nix ];

+14 -11

nixos/tests/web-apps/netbox-upgrade.nix

···

       10
        
             (lib.take 2)

     

       11
        
             (lib.concatStringsSep ".")

     

       12
        
           ];

     

       13
       -
         oldApiVersion = apiVersion pkgs."${oldNetbox}".version;

     

       14
       -
         newApiVersion = apiVersion pkgs."${newNetbox}".version;

     

       15
        
       in

     

       16
        
       {

     

       17
        
         name = "netbox-upgrade";

     

       18
        
       

     

       19
       -
         meta = with lib.maintainers; {

     

       20
       -
           maintainers = [

     

       21
       -
             minijackson

     

       22
       -
             raitobezarius

     

       23
       -
           ];

     

       24
       -
         };

     

       25
        
       

     

       26
        
         nodes.machine =

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
           { config, pkgs, ... }:

     

       28
        
           {

     

       29
        
             virtualisation.memorySize = 2048;

     
···

       31
        
               enable = true;

     

       32
        
               # Pick the NetBox package from this config's "pkgs" argument,

     

       33
        
               # so that `nixpkgs.config.permittedInsecurePackages` works

     

       34
       -
               package = pkgs."${oldNetbox}";

     

       35
        
               secretKeyFile = pkgs.writeText "secret" ''

     

       36
        
                 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

     

       37
        
               '';

     
···

       53
        
       

     

       54
        
             networking.firewall.allowedTCPPorts = [ 80 ];

     

       55
        
       

     

       56
       -
             nixpkgs.config.permittedInsecurePackages = [ pkgs."${oldNetbox}".name ];

     

       57
        
       

     

       58
       -
             specialisation.upgrade.configuration.services.netbox.package = lib.mkForce pkgs."${newNetbox}";

     

       59
        
           };

     

       60
        
       

     

       61
        
         testScript =

···

       10
        
             (lib.take 2)

     

       11
        
             (lib.concatStringsSep ".")

     

       12
        
           ];

     

       13
       +
         oldApiVersion = apiVersion pkgs.${oldNetbox}.version;

     

       14
       +
         newApiVersion = apiVersion pkgs.${newNetbox}.version;

     

       15
        
       in

     

       16
        
       {

     

       17
        
         name = "netbox-upgrade";

     

       18
        
       

     

       19
       +
         meta.maintainers = with lib.maintainers; [

     

       20
       +
           minijackson

     

       21
       +
           raitobezarius

     

       22
       +
         ];

     

       23
       +
       

     

       24
       +
         node.pkgsReadOnly = false;

     

       25
        
       

     

       26
        
         nodes.machine =

     

       27
       +
           let

     

       28
       +
             pkgs' = pkgs;

     

       29
       +
           in

     

       30
        
           { config, pkgs, ... }:

     

       31
        
           {

     

       32
        
             virtualisation.memorySize = 2048;

     
···

       34
        
               enable = true;

     

       35
        
               # Pick the NetBox package from this config's "pkgs" argument,

     

       36
        
               # so that `nixpkgs.config.permittedInsecurePackages` works

     

       37
       +
               package = pkgs.${oldNetbox};

     

       38
        
               secretKeyFile = pkgs.writeText "secret" ''

     

       39
        
                 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

     

       40
        
               '';

     
···

       56
        
       

     

       57
        
             networking.firewall.allowedTCPPorts = [ 80 ];

     

       58
        
       

     

       59
       +
             nixpkgs.config.permittedInsecurePackages = [ pkgs'.${oldNetbox}.name ];

     

       60
        
       

     

       61
       +
             specialisation.upgrade.configuration.services.netbox.package = lib.mkForce pkgs.${newNetbox};

     

       62
        
           };

     

       63
        
       

     

       64
        
         testScript =

+21 -23

nixos/tests/without-nix.nix

···

       1
        
       { lib, ... }:

     

       2
        
       {

     

       3
        
         name = "without-nix";

     

       4
       -
         meta = with lib.maintainers; {

     

       5
       -
           maintainers = [ ericson2314 ];

     

       6
       -
         };

     

       7
        
       

     

       8
       -
         nodes.machine =

     

       9
       -
           { ... }:

     

       10
       -
           {

     

       11
       -
             nix.enable = false;

     

       12
       -
             nixpkgs.overlays = [

     

       13
       -
               (self: super: {

     

       14
       -
                 nix = throw "don't want to use pkgs.nix";

     

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

     

       16
       -
                 # aliases, some deprecated

     

       17
       -
                 nix_2_3 = throw "don't want to use pkgs.nix_2_3";

     

       18
       -
                 nix_2_4 = throw "don't want to use pkgs.nix_2_4";

     

       19
       -
                 nix_2_5 = throw "don't want to use pkgs.nix_2_5";

     

       20
       -
                 nix_2_6 = throw "don't want to use pkgs.nix_2_6";

     

       21
       -
                 nixFlakes = throw "don't want to use pkgs.nixFlakes";

     

       22
       -
                 nixStable = throw "don't want to use pkgs.nixStable";

     

       23
       -
                 nixUnstable = throw "don't want to use pkgs.nixUnstable";

     

       24
       -
                 nixStatic = throw "don't want to use pkgs.nixStatic";

     

       25
       -
               })

     

       26
       -
             ];

     

       27
       -
           };

     

       28
        
       

     

       29
        
         testScript = ''

     

       30
        
           start_all()

···

       1
        
       { lib, ... }:

     

       2
        
       {

     

       3
        
         name = "without-nix";

     

       4
       +
         meta.maintainers = with lib.maintainers; [ ericson2314 ];

     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
       +
         node.pkgsReadOnly = false;

     

       7
       +
       

     

       8
       +
         nodes.machine = {

     

       9
       +
           nix.enable = false;

     

       10
       +
           nixpkgs.overlays = [

     

       11
       +
             (self: super: {

     

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

     

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

     

       14
       +
               # aliases, some deprecated

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       23
       +
             })

     

       24
       +
           ];

     

       25
       +
         };

     

       26
        
       

     

       27
        
         testScript = ''

     

       28
        
           start_all()