commit a46c78142e37924698ad714362136bc8d4db1721 · pyrox.dev/nixpkgs

+1 -10

nixos/tests/all-tests.nix

···

       48
       48
        
         clickhouse = handleTest ./clickhouse.nix {};

     

       49
       49
        
         cloud-init = handleTest ./cloud-init.nix {};

     

       50
       50
        
         codimd = handleTest ./codimd.nix {};

     

       51
       51
       -
         colord = handleTest ./colord.nix {};

     

       52
       51
        
         containers-bridge = handleTest ./containers-bridge.nix {};

     

       53
       52
        
         containers-ephemeral = handleTest ./containers-ephemeral.nix {};

     

       54
       53
        
         containers-extra_veth = handleTest ./containers-extra_veth.nix {};

     
···

       88
       87
        
         firewall = handleTest ./firewall.nix {};

     

       89
       88
        
         fish = handleTest ./fish.nix {};

     

       90
       89
        
         flannel = handleTestOn ["x86_64-linux"] ./flannel.nix {};

     

       91
       91
       -
         flatpak = handleTest ./flatpak.nix {};

     

       92
       92
       -
         flatpak-builder = handleTest ./flatpak-builder.nix {};

     

       93
       90
        
         fluentd = handleTest ./fluentd.nix {};

     

       94
       91
        
         fontconfig-default-fonts = handleTest ./fontconfig-default-fonts.nix {};

     

       95
       92
        
         fsck = handleTest ./fsck.nix {};

     

       96
       96
       -
         fwupd = handleTestOn ["x86_64-linux"] ./fwupd.nix {}; # libsmbios is unsupported on aarch64

     

       97
       97
       -
         gdk-pixbuf = handleTest ./gdk-pixbuf.nix {};

     

       98
       93
        
         gotify-server = handleTest ./gotify-server.nix {};

     

       99
       94
        
         gitea = handleTest ./gitea.nix {};

     

       100
       95
        
         gitlab = handleTest ./gitlab.nix {};

     

       101
       96
        
         gitolite = handleTest ./gitolite.nix {};

     

       102
       97
        
         gjs = handleTest ./gjs.nix {};

     

       103
       103
       -
         glib-networking = handleTest ./glib-networking.nix {};

     

       104
       98
        
         glusterfs = handleTest ./glusterfs.nix {};

     

       105
       99
        
         gnome3-xorg = handleTest ./gnome3-xorg.nix {};

     

       106
       100
        
         gnome3 = handleTest ./gnome3.nix {};

     

       107
       107
       -
         gnome-photos = handleTest ./gnome-photos.nix {};

     

       101
       101
       +
         installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});

     

       108
       102
        
         gocd-agent = handleTest ./gocd-agent.nix {};

     

       109
       103
        
         gocd-server = handleTest ./gocd-server.nix {};

     

       110
       104
        
         google-oslogin = handleTest ./google-oslogin {};

     

       111
       111
       -
         graphene = handleTest ./graphene.nix {};

     

       112
       105
        
         grafana = handleTest ./grafana.nix {};

     

       113
       106
        
         graphite = handleTest ./graphite.nix {};

     

       114
       107
        
         graylog = handleTest ./graylog.nix {};

     
···

       216
       209
        
         os-prober = handleTestOn ["x86_64-linux"] ./os-prober.nix {};

     

       217
       210
        
         osquery = handleTest ./osquery.nix {};

     

       218
       211
        
         osrm-backend = handleTest ./osrm-backend.nix {};

     

       219
       219
       -
         ostree = handleTest ./ostree.nix {};

     

       220
       212
        
         overlayfs = handleTest ./overlayfs.nix {};

     

       221
       213
        
         packagekit = handleTest ./packagekit.nix {};

     

       222
       214
        
         pam-oath-login = handleTest ./pam-oath-login.nix {};

     
···

       291
       283
        
         wireguard-generated = handleTest ./wireguard/generated.nix {};

     

       292
       284
        
         wordpress = handleTest ./wordpress.nix {};

     

       293
       285
        
         xautolock = handleTest ./xautolock.nix {};

     

       294
       294
       -
         xdg-desktop-portal = handleTest ./xdg-desktop-portal.nix {};

     

       295
       286
        
         xfce = handleTest ./xfce.nix {};

     

       296
       287
        
         xfce4-14 = handleTest ./xfce4-14.nix {};

     

       297
       288
        
         xmonad = handleTest ./xmonad.nix {};

-18

nixos/tests/colord.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "colord";

     

       6
       6
       -
       

     

       7
       7
       -
         meta = {

     

       8
       8
       -
           maintainers = pkgs.colord.meta.maintainers;

     

       9
       9
       -
         };

     

       10
       10
       -
       

     

       11
       11
       -
         machine = { pkgs, ... }: {

     

       12
       12
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         testScript = ''

     

       16
       16
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.colord.installedTests}/share'");

     

       17
       17
       -
         '';

     

       18
       18
       -
       })

-20

nixos/tests/flatpak-builder.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "flatpak-builder";

     

       6
       6
       -
         meta = {

     

       7
       7
       -
           maintainers = pkgs.flatpak-builder.meta.maintainers;

     

       8
       8
       -
         };

     

       9
       9
       -
       

     

       10
       10
       -
         machine = { pkgs, ... }: {

     

       11
       11
       -
           services.flatpak.enable = true;

     

       12
       12
       -
           xdg.portal.enable = true;

     

       13
       13
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing flatpak-builder ] ++ flatpak-builder.installedTestsDependencies;

     

       14
       14
       -
           virtualisation.diskSize = 2048;

     

       15
       15
       -
         };

     

       16
       16
       -
       

     

       17
       17
       -
         testScript = ''

     

       18
       18
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.flatpak-builder.installedTests}/share' --timeout 3600");

     

       19
       19
       -
         '';

     

       20
       20
       -
       })

-26

nixos/tests/flatpak.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "flatpak";

     

       6
       6
       -
         meta = {

     

       7
       7
       -
           maintainers = pkgs.flatpak.meta.maintainers;

     

       8
       8
       -
         };

     

       9
       9
       -
       

     

       10
       10
       -
         machine = { pkgs, ... }: {

     

       11
       11
       -
           imports = [ ./common/x11.nix ];

     

       12
       12
       -
           services.xserver.desktopManager.gnome3.enable = true; # TODO: figure out minimal environment where the tests work

     

       13
       13
       -
           # common/x11.nix enables the auto display manager (lightdm)

     

       14
       14
       -
           services.xserver.displayManager.gdm.enable = false;

     

       15
       15
       -
           environment.gnome3.excludePackages = pkgs.gnome3.optionalPackages;

     

       16
       16
       -
           services.flatpak.enable = true;

     

       17
       17
       -
           environment.systemPackages = with pkgs; [ gnupg gnome-desktop-testing ostree python2 ];

     

       18
       18
       -
           virtualisation.memorySize = 2047;

     

       19
       19
       -
           virtualisation.diskSize = 1024;

     

       20
       20
       -
         };

     

       21
       21
       -
       

     

       22
       22
       -
         testScript = ''

     

       23
       23
       -
           $machine->waitForX();

     

       24
       24
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.flatpak.installedTests}/share' --timeout 3600");

     

       25
       25
       -
         '';

     

       26
       26
       -
       })

+10 -5

nixos/tests/fontconfig-default-fonts.nix

···

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

     

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

     

       2
       2
        
       {

     

       3
       3
        
         name = "fontconfig-default-fonts";

     

       4
       4
       +
       

     

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

     

       6
       6
       +
           jtojnar

     

       7
       7
       +
           worldofpeace

     

       8
       8
       +
         ];

     

       4
       9
        
       

     

       5
       10
        
         machine = { config, pkgs, ... }: {

     

       6
       11
        
           fonts.enableDefaultFonts = true; # Background fonts

     
···

       20
       25
        
         };

     

       21
       26
        
       

     

       22
       27
        
         testScript = ''

     

       23
       23
       -
           $machine->succeed("fc-match serif | grep '\"Gentium Plus\"'");

     

       24
       24
       -
           $machine->succeed("fc-match sans-serif | grep '\"Cantarell\"'");

     

       25
       25
       -
           $machine->succeed("fc-match monospace | grep '\"Source Code Pro\"'");

     

       26
       26
       -
           $machine->succeed("fc-match emoji | grep '\"Twitter Color Emoji\"'");

     

       28
       28
       +
           machine.succeed("fc-match serif | grep '\"Gentium Plus\"'")

     

       29
       29
       +
           machine.succeed("fc-match sans-serif | grep '\"Cantarell\"'")

     

       30
       30
       +
           machine.succeed("fc-match monospace | grep '\"Source Code Pro\"'")

     

       31
       31
       +
           machine.succeed("fc-match emoji | grep '\"Twitter Color Emoji\"'")

     

       27
       32
        
         '';

     

       28
       33
        
       })

-21

nixos/tests/fwupd.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
         name = "fwupd";

     

       4
       4
       -
       

     

       5
       5
       -
         meta = {

     

       6
       6
       -
           maintainers = pkgs.fwupd.meta.maintainers;

     

       7
       7
       -
         };

     

       8
       8
       -
       

     

       9
       9
       -
         machine = { pkgs, ... }: {

     

       10
       10
       -
           services.fwupd.enable = true;

     

       11
       11
       -
           services.fwupd.blacklistPlugins = []; # don't blacklist test plugin

     

       12
       12
       -
           services.fwupd.enableTestRemote = true;

     

       13
       13
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       14
       14
       -
           environment.variables.XDG_DATA_DIRS = [ "${pkgs.fwupd.installedTests}/share" ];

     

       15
       15
       -
           virtualisation.memorySize = 768;

     

       16
       16
       -
         };

     

       17
       17
       -
       

     

       18
       18
       -
         testScript = ''

     

       19
       19
       -
           $machine->succeed("gnome-desktop-testing-runner");

     

       20
       20
       -
         '';

     

       21
       21
       -
       })

-21

nixos/tests/gdk-pixbuf.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
         name = "gdk-pixbuf";

     

       4
       4
       -
       

     

       5
       5
       -
         meta = {

     

       6
       6
       -
           maintainers = pkgs.gdk-pixbuf.meta.maintainers;

     

       7
       7
       -
         };

     

       8
       8
       -
       

     

       9
       9
       -
         machine = { pkgs, ... }: {

     

       10
       10
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       11
       11
       -
           environment.variables.XDG_DATA_DIRS = [ "${pkgs.gdk-pixbuf.installedTests}/share" ];

     

       12
       12
       -
       

     

       13
       13
       -
           # Tests allocate a lot of memory trying to exploit a CVE

     

       14
       14
       -
           # but qemu-system-i386 has a 2047M memory limit

     

       15
       15
       -
           virtualisation.memorySize = if pkgs.stdenv.isi686 then 2047 else 4096;

     

       16
       16
       -
         };

     

       17
       17
       -
       

     

       18
       18
       -
         testScript = ''

     

       19
       19
       -
           $machine->succeed("gnome-desktop-testing-runner -t 1800"); # increase timeout to 1800s

     

       20
       20
       -
         '';

     

       21
       21
       -
       })

-19

nixos/tests/gjs.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
         name = "gjs";

     

       4
       4
       -
       

     

       5
       5
       -
         meta = {

     

       6
       6
       -
           maintainers = pkgs.gjs.meta.maintainers;

     

       7
       7
       -
         };

     

       8
       8
       -
       

     

       9
       9
       -
         machine = { pkgs, ... }: {

     

       10
       10
       -
           imports = [ ./common/x11.nix ];

     

       11
       11
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       12
       12
       -
           environment.variables.XDG_DATA_DIRS = [ "${pkgs.gjs.installedTests}/share" ];

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         testScript = ''

     

       16
       16
       -
           $machine->waitForX;

     

       17
       17
       -
           $machine->succeed("gnome-desktop-testing-runner");

     

       18
       18
       -
         '';

     

       19
       19
       -
       })

-17

nixos/tests/glib-networking.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "glib-networking";

     

       6
       6
       -
         meta = {

     

       7
       7
       -
           maintainers = pkgs.glib-networking.meta.maintainers;

     

       8
       8
       -
         };

     

       9
       9
       -
       

     

       10
       10
       -
         machine = { pkgs, ... }: {

     

       11
       11
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         testScript = ''

     

       15
       15
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.glib-networking.installedTests}/share'");

     

       16
       16
       -
         '';

     

       17
       17
       -
       })

-42

nixos/tests/gnome-photos.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       let

     

       5
       5
       -
       

     

       6
       6
       -
         # gsettings tool with access to gsettings-desktop-schemas

     

       7
       7
       -
         desktop-gsettings = with pkgs; stdenv.mkDerivation {

     

       8
       8
       -
           name = "desktop-gsettings";

     

       9
       9
       -
           dontUnpack = true;

     

       10
       10
       -
           nativeBuildInputs = [ glib wrapGAppsHook ];

     

       11
       11
       -
           buildInputs = [ gsettings-desktop-schemas ];

     

       12
       12
       -
           installPhase = ''

     

       13
       13
       -
             runHook preInstall

     

       14
       14
       -
             mkdir -p $out/bin

     

       15
       15
       -
             ln -s ${glib.bin}/bin/gsettings $out/bin/desktop-gsettings

     

       16
       16
       -
             runHook postInstall

     

       17
       17
       -
           '';

     

       18
       18
       -
         };

     

       19
       19
       -
       

     

       20
       20
       -
       in

     

       21
       21
       -
       

     

       22
       22
       -
       {

     

       23
       23
       -
         name = "gnome-photos";

     

       24
       24
       -
         meta = {

     

       25
       25
       -
           maintainers = pkgs.gnome-photos.meta.maintainers;

     

       26
       26
       -
         };

     

       27
       27
       -
       

     

       28
       28
       -
         machine = { pkgs, ... }: {

     

       29
       29
       -
           imports = [ ./common/x11.nix ];

     

       30
       30
       -
           programs.dconf.enable = true;

     

       31
       31
       -
           services.gnome3.at-spi2-core.enable = true; # needed for dogtail

     

       32
       32
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing desktop-gsettings ];

     

       33
       33
       -
           services.dbus.packages = with pkgs; [ gnome-photos ];

     

       34
       34
       -
         };

     

       35
       35
       -
       

     

       36
       36
       -
         testScript = ''

     

       37
       37
       -
           $machine->waitForX;

     

       38
       38
       -
           # dogtail needs accessibility enabled

     

       39
       39
       -
           $machine->succeed("desktop-gsettings set org.gnome.desktop.interface toolkit-accessibility true 2>&1");

     

       40
       40
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.gnome-photos.installedTests}/share' 2>&1");

     

       41
       41
       -
         '';

     

       42
       42
       -
       })

-18

nixos/tests/graphene.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "graphene";

     

       6
       6
       -
       

     

       7
       7
       -
         meta = {

     

       8
       8
       -
           maintainers = pkgs.graphene.meta.maintainers;

     

       9
       9
       -
         };

     

       10
       10
       -
       

     

       11
       11
       -
         machine = { pkgs, ... }: {

     

       12
       12
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       13
       13
       -
         };

     

       14
       14
       -
       

     

       15
       15
       -
         testScript = ''

     

       16
       16
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.graphene.installedTests}/share'");

     

       17
       17
       -
         '';

     

       18
       18
       -
       })

+5

nixos/tests/installed-tests/colord.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.colord;

     

       5
       5
       +
       }

+77

nixos/tests/installed-tests/default.nix

···

       1
       1
       +
       # NixOS tests for gnome-desktop-testing-runner using software

     

       2
       2
       +
       # See https://wiki.gnome.org/Initiatives/GnomeGoals/InstalledTests

     

       3
       3
       +
       

     

       4
       4
       +
       { system ? builtins.currentSystem,

     

       5
       5
       +
         config ? {},

     

       6
       6
       +
         pkgs ? import ../../.. { inherit system config; }

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

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

     

       10
       10
       +
       with pkgs.lib;

     

       11
       11
       +
       

     

       12
       12
       +
       let

     

       13
       13
       +
       

     

       14
       14
       +
         callInstalledTest = pkgs.newScope { inherit makeInstalledTest; };

     

       15
       15
       +
       

     

       16
       16
       +
         makeInstalledTest =

     

       17
       17
       +
           { # Package to test. Needs to have an installedTests output

     

       18
       18
       +
             tested

     

       19
       19
       +
       

     

       20
       20
       +
             # Config to inject into machine

     

       21
       21
       +
           , testConfig ? {}

     

       22
       22
       +
       

     

       23
       23
       +
             # Test script snippet to inject before gnome-desktop-testing-runner begins.

     

       24
       24
       +
             # This is useful for extra setup the environment may need before the runner begins.

     

       25
       25
       +
           , preTestScript ? ""

     

       26
       26
       +
       

     

       27
       27
       +
             # Does test need X11?

     

       28
       28
       +
           , withX11 ? false

     

       29
       29
       +
       

     

       30
       30
       +
             # Extra flags to pass to gnome-desktop-testing-runner.

     

       31
       31
       +
           , testRunnerFlags ? ""

     

       32
       32
       +
           }:

     

       33
       33
       +
           makeTest rec {

     

       34
       34
       +
             name = tested.name;

     

       35
       35
       +
       

     

       36
       36
       +
             meta = {

     

       37
       37
       +
               maintainers = tested.meta.maintainers;

     

       38
       38
       +
             };

     

       39
       39
       +
       

     

       40
       40
       +
             machine = { ... }: {

     

       41
       41
       +
               imports = [

     

       42
       42
       +
                 testConfig

     

       43
       43
       +
               ] ++ optional withX11 ../common/x11.nix;

     

       44
       44
       +
       

     

       45
       45
       +
               environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       46
       46
       +
       

     

       47
       47
       +
             };

     

       48
       48
       +
       

     

       49
       49
       +
             testScript =

     

       50
       50
       +
               optionalString withX11 ''

     

       51
       51
       +
                 machine.wait_for_x()

     

       52
       52
       +
               '' +

     

       53
       53
       +
               optionalString (preTestScript != "") ''

     

       54
       54
       +
                 ${preTestScript}

     

       55
       55
       +
               '' +

     

       56
       56
       +
               ''

     

       57
       57
       +
                 machine.succeed(

     

       58
       58
       +
                     "gnome-desktop-testing-runner ${testRunnerFlags} -d '${tested.installedTests}/share'"

     

       59
       59
       +
                 )

     

       60
       60
       +
               '';

     

       61
       61
       +
           };

     

       62
       62
       +
       

     

       63
       63
       +
       in

     

       64
       64
       +
       

     

       65
       65
       +
       {

     

       66
       66
       +
         colord = callInstalledTest ./colord.nix {};

     

       67
       67
       +
         flatpak = callInstalledTest ./flatpak.nix {};

     

       68
       68
       +
         flatpak-builder = callInstalledTest ./flatpak-builder.nix {};

     

       69
       69
       +
         fwupd = callInstalledTest ./fwupd.nix {};

     

       70
       70
       +
         gdk-pixbuf = callInstalledTest ./gdk-pixbuf.nix {};

     

       71
       71
       +
         gjs = callInstalledTest ./gjs.nix {};

     

       72
       72
       +
         glib-networking = callInstalledTest ./glib-networking.nix {};

     

       73
       73
       +
         gnome-photos = callInstalledTest ./gnome-photos.nix {};

     

       74
       74
       +
         graphene = callInstalledTest ./graphene.nix {};

     

       75
       75
       +
         ostree = callInstalledTest ./ostree.nix {};

     

       76
       76
       +
         xdg-desktop-portal = callInstalledTest ./xdg-desktop-portal.nix {};

     

       77
       77
       +
       }

+14

nixos/tests/installed-tests/flatpak-builder.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.flatpak-builder;

     

       5
       5
       +
       

     

       6
       6
       +
         testConfig = {

     

       7
       7
       +
           services.flatpak.enable = true;

     

       8
       8
       +
           xdg.portal.enable = true;

     

       9
       9
       +
           environment.systemPackages = with pkgs; [ flatpak-builder ] ++ flatpak-builder.installedTestsDependencies;

     

       10
       10
       +
           virtualisation.diskSize = 2048;

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         testRunnerFlags = "--timeout 3600";

     

       14
       14
       +
       }

+19

nixos/tests/installed-tests/flatpak.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.flatpak;

     

       5
       5
       +
         withX11 = true;

     

       6
       6
       +
       

     

       7
       7
       +
         testConfig = {

     

       8
       8
       +
           services.xserver.desktopManager.gnome3.enable = true; # TODO: figure out minimal environment where the tests work

     

       9
       9
       +
           # common/x11.nix enables the auto display manager (lightdm)

     

       10
       10
       +
           services.xserver.displayManager.gdm.enable = false;

     

       11
       11
       +
           services.gnome3.core-utilities.enable = false;

     

       12
       12
       +
           services.flatpak.enable = true;

     

       13
       13
       +
           environment.systemPackages = with pkgs; [ gnupg ostree python2 ];

     

       14
       14
       +
           virtualisation.memorySize = 2047;

     

       15
       15
       +
           virtualisation.diskSize = 1024;

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         testRunnerFlags = "--timeout 3600";

     

       19
       19
       +
       }

+12

nixos/tests/installed-tests/fwupd.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.fwupd;

     

       5
       5
       +
       

     

       6
       6
       +
         testConfig = {

     

       7
       7
       +
           services.fwupd.enable = true;

     

       8
       8
       +
           services.fwupd.blacklistPlugins = []; # don't blacklist test plugin

     

       9
       9
       +
           services.fwupd.enableTestRemote = true;

     

       10
       10
       +
           virtualisation.memorySize = 768;

     

       11
       11
       +
         };

     

       12
       12
       +
       }

+13

nixos/tests/installed-tests/gdk-pixbuf.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.gdk-pixbuf;

     

       5
       5
       +
       

     

       6
       6
       +
         testConfig = {

     

       7
       7
       +
           # Tests allocate a lot of memory trying to exploit a CVE

     

       8
       8
       +
           # but qemu-system-i386 has a 2047M memory limit

     

       9
       9
       +
           virtualisation.memorySize = if pkgs.stdenv.isi686 then 2047 else 4096;

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         testRunnerFlags = "--timeout 1800";

     

       13
       13
       +
       }

+6

nixos/tests/installed-tests/gjs.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.gjs;

     

       5
       5
       +
         withX11 = true;

     

       6
       6
       +
       }

+5

nixos/tests/installed-tests/glib-networking.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.glib-networking;

     

       5
       5
       +
       }

+35

nixos/tests/installed-tests/gnome-photos.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.gnome-photos;

     

       5
       5
       +
       

     

       6
       6
       +
         withX11 = true;

     

       7
       7
       +
       

     

       8
       8
       +
         testConfig = {

     

       9
       9
       +
           programs.dconf.enable = true;

     

       10
       10
       +
           services.gnome3.at-spi2-core.enable = true; # needed for dogtail

     

       11
       11
       +
           environment.systemPackages = with pkgs; [

     

       12
       12
       +
             # gsettings tool with access to gsettings-desktop-schemas

     

       13
       13
       +
             (stdenv.mkDerivation {

     

       14
       14
       +
               name = "desktop-gsettings";

     

       15
       15
       +
               dontUnpack = true;

     

       16
       16
       +
               nativeBuildInputs = [ glib wrapGAppsHook ];

     

       17
       17
       +
               buildInputs = [ gsettings-desktop-schemas ];

     

       18
       18
       +
               installPhase = ''

     

       19
       19
       +
                 runHook preInstall

     

       20
       20
       +
                 mkdir -p $out/bin

     

       21
       21
       +
                 ln -s ${glib.bin}/bin/gsettings $out/bin/desktop-gsettings

     

       22
       22
       +
                 runHook postInstall

     

       23
       23
       +
               '';

     

       24
       24
       +
             })

     

       25
       25
       +
           ];

     

       26
       26
       +
           services.dbus.packages = with pkgs; [ gnome-photos ];

     

       27
       27
       +
         };

     

       28
       28
       +
       

     

       29
       29
       +
         preTestScript = ''

     

       30
       30
       +
           # dogtail needs accessibility enabled

     

       31
       31
       +
           machine.succeed(

     

       32
       32
       +
               "desktop-gsettings set org.gnome.desktop.interface toolkit-accessibility true 2>&1"

     

       33
       33
       +
           )

     

       34
       34
       +
         '';

     

       35
       35
       +
       }

+5

nixos/tests/installed-tests/graphene.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.graphene;

     

       5
       5
       +
       }

+23

nixos/tests/installed-tests/ostree.nix

···

       1
       1
       +
       { pkgs, lib, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.ostree;

     

       5
       5
       +
       

     

       6
       6
       +
         # TODO: Wrap/patch the tests directly in the package

     

       7
       7
       +
         testConfig = {

     

       8
       8
       +
           environment.systemPackages = with pkgs; [

     

       9
       9
       +
             (python3.withPackages (p: with p; [ pyyaml ]))

     

       10
       10
       +
             gnupg

     

       11
       11
       +
             ostree

     

       12
       12
       +
           ];

     

       13
       13
       +
       

     

       14
       14
       +
           # for GJS tests

     

       15
       15
       +
           environment.variables.GI_TYPELIB_PATH = lib.makeSearchPath "lib/girepository-1.0" (with pkgs; [

     

       16
       16
       +
             gtk3

     

       17
       17
       +
             pango.out

     

       18
       18
       +
             ostree

     

       19
       19
       +
             gdk-pixbuf

     

       20
       20
       +
             atk

     

       21
       21
       +
           ]);

     

       22
       22
       +
         };

     

       23
       23
       +
       }

+5

nixos/tests/installed-tests/xdg-desktop-portal.nix

···

       1
       1
       +
       { pkgs, makeInstalledTest, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       makeInstalledTest {

     

       4
       4
       +
         tested = pkgs.xdg-desktop-portal;

     

       5
       5
       +
       }

-21

nixos/tests/ostree.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
         name = "ostree";

     

       4
       4
       -
       

     

       5
       5
       -
         meta = {

     

       6
       6
       -
           maintainers = pkgs.ostree.meta.maintainers;

     

       7
       7
       -
         };

     

       8
       8
       -
       

     

       9
       9
       -
         # TODO: Wrap/patch the tests directly in the package

     

       10
       10
       -
         machine = { pkgs, ... }: {

     

       11
       11
       -
           environment.systemPackages = with pkgs; [

     

       12
       12
       -
             gnome-desktop-testing ostree gnupg (python3.withPackages (p: with p; [ pyyaml ]))

     

       13
       13
       -
           ];

     

       14
       14
       -
       

     

       15
       15
       -
           environment.variables.GI_TYPELIB_PATH = lib.makeSearchPath "lib/girepository-1.0" (with pkgs; [ gtk3 pango.out ostree gdk-pixbuf atk ]); # for GJS tests

     

       16
       16
       -
         };

     

       17
       17
       -
       

     

       18
       18
       -
         testScript = ''

     

       19
       19
       -
           $machine->succeed("gnome-desktop-testing-runner -d ${pkgs.ostree.installedTests}/share");

     

       20
       20
       -
         '';

     

       21
       21
       -
       })

+6 -4

nixos/tests/packagekit.nix

···

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

     

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

     

       2
       2
        
         name = "packagekit";

     

       3
       3
        
         meta = with pkgs.stdenv.lib.maintainers; {

     

       4
       4
        
           maintainers = [ peterhoeg ];

     
···

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         testScript = ''

     

       16
       16
       -
           startAll;

     

       16
       16
       +
           start_all()

     

       17
       17
        
       

     

       18
       18
        
           # send a dbus message to activate the service

     

       19
       19
       -
           $machine->succeed("dbus-send --system --type=method_call --print-reply --dest=org.freedesktop.PackageKit /org/freedesktop/PackageKit org.freedesktop.DBus.Introspectable.Introspect");

     

       19
       19
       +
           machine.succeed(

     

       20
       20
       +
               "dbus-send --system --type=method_call --print-reply --dest=org.freedesktop.PackageKit /org/freedesktop/PackageKit org.freedesktop.DBus.Introspectable.Introspect"

     

       21
       21
       +
           )

     

       20
       22
        
       

     

       21
       23
        
           # so now it should be running

     

       22
       22
       -
           $machine->succeed("systemctl is-active packagekit.service");

     

       24
       24
       +
           machine.wait_for_unit("packagekit.service")

     

       23
       25
        
         '';

     

       24
       26
        
       })

+26 -18

nixos/tests/udisks2.nix

···

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

     

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

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     
···

       30
       30
        
       

     

       31
       31
        
         testScript =

     

       32
       32
        
           ''

     

       33
       33
       -
             my $stick = $machine->stateDir . "/usbstick.img";

     

       34
       34
       -
             system("xz -d < ${stick} > $stick") == 0 or die;

     

       33
       33
       +
             import lzma

     

       35
       34
        
       

     

       36
       36
       -
             $machine->succeed("udisksctl info -b /dev/vda >&2");

     

       37
       37
       -
             $machine->fail("udisksctl info -b /dev/sda1");

     

       35
       35
       +
             with lzma.open(

     

       36
       36
       +
                 "${stick}"

     

       37
       37
       +
             ) as data, open(machine.state_dir + "/usbstick.img", "wb") as stick:

     

       38
       38
       +
                 stick.write(data.read())

     

       39
       39
       +
       

     

       40
       40
       +
             machine.succeed("udisksctl info -b /dev/vda >&2")

     

       41
       41
       +
             machine.fail("udisksctl info -b /dev/sda1")

     

       38
       42
        
       

     

       39
       43
        
             # Attach a USB stick and wait for it to show up.

     

       40
       40
       -
             $machine->sendMonitorCommand("drive_add 0 id=stick,if=none,file=$stick,format=raw");

     

       41
       41
       -
             $machine->sendMonitorCommand("device_add usb-storage,id=stick,drive=stick");

     

       42
       42
       -
             $machine->waitUntilSucceeds("udisksctl info -b /dev/sda1");

     

       43
       43
       -
             $machine->succeed("udisksctl info -b /dev/sda1 | grep 'IdLabel:.*USBSTICK'");

     

       44
       44
       +
             machine.send_monitor_command(

     

       45
       45
       +
                 f"drive_add 0 id=stick,if=none,file={stick.name},format=raw"

     

       46
       46
       +
             )

     

       47
       47
       +
             machine.send_monitor_command("device_add usb-storage,id=stick,drive=stick")

     

       48
       48
       +
             machine.wait_until_succeeds("udisksctl info -b /dev/sda1")

     

       49
       49
       +
             machine.succeed("udisksctl info -b /dev/sda1 | grep 'IdLabel:.*USBSTICK'")

     

       44
       50
        
       

     

       45
       51
        
             # Mount the stick as a non-root user and do some stuff with it.

     

       46
       46
       -
             $machine->succeed("su - alice -c 'udisksctl info -b /dev/sda1'");

     

       47
       47
       -
             $machine->succeed("su - alice -c 'udisksctl mount -b /dev/sda1'");

     

       48
       48
       -
             $machine->succeed("su - alice -c 'cat /run/media/alice/USBSTICK/test.txt'") =~ /Hello World/ or die;

     

       49
       49
       -
             $machine->succeed("su - alice -c 'echo foo > /run/media/alice/USBSTICK/bar.txt'");

     

       52
       52
       +
             machine.succeed("su - alice -c 'udisksctl info -b /dev/sda1'")

     

       53
       53
       +
             machine.succeed("su - alice -c 'udisksctl mount -b /dev/sda1'")

     

       54
       54
       +
             machine.succeed(

     

       55
       55
       +
                 "su - alice -c 'cat /run/media/alice/USBSTICK/test.txt' | grep -q 'Hello World'"

     

       56
       56
       +
             )

     

       57
       57
       +
             machine.succeed("su - alice -c 'echo foo > /run/media/alice/USBSTICK/bar.txt'")

     

       50
       58
        
       

     

       51
       59
        
             # Unmounting the stick should make the mountpoint disappear.

     

       52
       52
       -
             $machine->succeed("su - alice -c 'udisksctl unmount -b /dev/sda1'");

     

       53
       53
       -
             $machine->fail("[ -d /run/media/alice/USBSTICK ]");

     

       60
       60
       +
             machine.succeed("su - alice -c 'udisksctl unmount -b /dev/sda1'")

     

       61
       61
       +
             machine.fail("[ -d /run/media/alice/USBSTICK ]")

     

       54
       62
        
       

     

       55
       63
        
             # Remove the USB stick.

     

       56
       56
       -
             $machine->sendMonitorCommand("device_del stick");

     

       57
       57
       -
             $machine->waitUntilFails("udisksctl info -b /dev/sda1");

     

       58
       58
       -
             $machine->fail("[ -e /dev/sda ]");

     

       64
       64
       +
             machine.send_monitor_command("device_del stick")

     

       65
       65
       +
             machine.wait_until_fails("udisksctl info -b /dev/sda1")

     

       66
       66
       +
             machine.fail("[ -e /dev/sda ]")

     

       59
       67
        
           '';

     

       60
       68
        
       

     

       61
       69
        
       })

-17

nixos/tests/xdg-desktop-portal.nix

···

       1
       1
       -
       # run installed tests

     

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

     

       3
       3
       -
       

     

       4
       4
       -
       {

     

       5
       5
       -
         name = "xdg-desktop-portal";

     

       6
       6
       -
         meta = {

     

       7
       7
       -
           maintainers = pkgs.xdg-desktop-portal.meta.maintainers;

     

       8
       8
       -
         };

     

       9
       9
       -
       

     

       10
       10
       -
         machine = { pkgs, ... }: {

     

       11
       11
       -
           environment.systemPackages = with pkgs; [ gnome-desktop-testing ];

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         testScript = ''

     

       15
       15
       -
           $machine->succeed("gnome-desktop-testing-runner -d '${pkgs.xdg-desktop-portal.installedTests}/share'");

     

       16
       16
       -
         '';

     

       17
       17
       -
       })