commit 53edfe1d1c51c38e2adc4d8eb37a7a2657e3fe01 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       296
       296
        
           virtualisation.memorySize =

     

       297
       297
        
             mkOption {

     

       298
       298
        
               type = types.ints.positive;

     

       299
       299
       -
               default = 384;

     

       299
       299
       +
               default = 1024;

     

       300
       300
        
               description =

     

       301
       301
        
                 ''

     

       302
       302
        
                   The memory size in megabytes of the virtual machine.

-4

nixos/tests/airsonic.nix

···

       11
       11
        
               enable = true;

     

       12
       12
        
               maxMemory = 800;

     

       13
       13
        
             };

     

       14
       14
       -
       

     

       15
       15
       -
             # Airsonic is a Java application, and unfortunately requires a significant

     

       16
       16
       -
             # amount of memory.

     

       17
       17
       -
             virtualisation.memorySize = 1024;

     

       18
       14
        
           };

     

       19
       15
        
       

     

       20
       16
        
         testScript = ''

-1

nixos/tests/cage.nix

···

       17
       17
        
             program = "${pkgs.xterm}/bin/xterm -cm -pc -fa Monospace -fs 24";

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
       -
           virtualisation.memorySize = 1024;

     

       21
       20
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Cage can launch:

     

       22
       21
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       23
       22
        
         };

-1

nixos/tests/cagebreak.nix

···

       35
       35
        
           programs.xwayland.enable = true;

     

       36
       36
        
           environment.systemPackages = [ pkgs.cagebreak pkgs.wayland-utils ];

     

       37
       37
        
       

     

       38
       38
       -
           virtualisation.memorySize = 1024;

     

       39
       38
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Cagebreak can launch:

     

       40
       39
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       41
       40
        
         };

-1

nixos/tests/cassandra.nix

···

       41
       41
        
             ];

     

       42
       42
        
           };

     

       43
       43
        
           services.cassandra = cassandraCfg ipAddress // extra;

     

       44
       44
       -
           virtualisation.memorySize = 1024;

     

       45
       44
        
         };

     

       46
       45
        
       in

     

       47
       46
        
       {

-1

nixos/tests/ceph-multi-node.nix

···

       37
       37
        
       

     

       38
       38
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       39
       39
        
           virtualisation = {

     

       40
       40
       -
             memorySize = 1024;

     

       41
       40
        
             emptyDiskImages = [ 20480 ];

     

       42
       41
        
             vlans = [ 1 ];

     

       43
       42
        
           };

-1

nixos/tests/ceph-single-node-bluestore.nix

···

       34
       34
        
       

     

       35
       35
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       36
       36
        
           virtualisation = {

     

       37
       37
       -
             memorySize = 1024;

     

       38
       37
        
             emptyDiskImages = [ 20480 20480 20480 ];

     

       39
       38
        
             vlans = [ 1 ];

     

       40
       39
        
           };

-1

nixos/tests/ceph-single-node.nix

···

       34
       34
        
       

     

       35
       35
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       36
       36
        
           virtualisation = {

     

       37
       37
       -
             memorySize = 1024;

     

       38
       37
        
             emptyDiskImages = [ 20480 20480 20480 ];

     

       39
       38
        
             vlans = [ 1 ];

     

       40
       39
        
           };

-1

nixos/tests/common/wayland-cage.nix

···

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         virtualisation = {

     

       11
       11
       -
           memorySize = 1024;

     

       12
       11
        
           qemu.options = [ "-vga virtio" ];

     

       13
       12
        
         };

     

       14
       13
        
       }

-1

nixos/tests/containers-bridge.nix

···

       15
       15
        
           { pkgs, ... }:

     

       16
       16
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       17
       17
        
             virtualisation.writableStore = true;

     

       18
       18
       -
             virtualisation.memorySize = 768;

     

       19
       18
        
       

     

       20
       19
        
             networking.bridges = {

     

       21
       20
        
               br0 = {

-1

nixos/tests/containers-ephemeral.nix

···

       5
       5
        
         };

     

       6
       6
        
       

     

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

     

       8
       8
       -
           virtualisation.memorySize = 768;

     

       9
       8
        
           virtualisation.writableStore = true;

     

       10
       9
        
       

     

       11
       10
        
           containers.webserver = {

-1

nixos/tests/containers-extra_veth.nix

···

       8
       8
        
           { pkgs, ... }:

     

       9
       9
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       10
       10
        
             virtualisation.writableStore = true;

     

       11
       11
       -
             virtualisation.memorySize = 768;

     

       12
       11
        
             virtualisation.vlans = [];

     

       13
       12
        
       

     

       14
       13
        
             networking.useDHCP = false;

-1

nixos/tests/containers-hosts.nix

···

       7
       7
        
         machine =

     

       8
       8
        
           { lib, ... }:

     

       9
       9
        
           {

     

       10
       10
       -
             virtualisation.memorySize = 256;

     

       11
       10
        
             virtualisation.vlans = [];

     

       12
       11
        
       

     

       13
       12
        
             networking.bridges.br0.interfaces = [];

-1

nixos/tests/containers-imperative.nix

···

       14
       14
        
             nix.binaryCaches = []; # don't try to access cache.nixos.org

     

       15
       15
        
       

     

       16
       16
        
             virtualisation.writableStore = true;

     

       17
       17
       -
             virtualisation.memorySize = 1024;

     

       18
       17
        
             # Make sure we always have all the required dependencies for creating a

     

       19
       18
        
             # container available within the VM, because we don't have network access.

     

       20
       19
        
             virtualisation.additionalPaths = let

-1

nixos/tests/containers-ip.nix

···

       22
       22
        
             imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       23
       23
        
             virtualisation = {

     

       24
       24
        
               writableStore = true;

     

       25
       25
       -
               memorySize = 768;

     

       26
       25
        
             };

     

       27
       26
        
       

     

       28
       27
        
             containers.webserver4 = webserverFor "10.231.136.1" "10.231.136.2";

-2

nixos/tests/containers-macvlans.nix

···

       15
       15
        
           machine1 =

     

       16
       16
        
             { lib, ... }:

     

       17
       17
        
             {

     

       18
       18
       -
               virtualisation.memorySize = 256;

     

       19
       18
        
               virtualisation.vlans = [ 1 ];

     

       20
       19
        
       

     

       21
       20
        
               # To be able to ping containers from the host, it is necessary

     
···

       55
       54
        
           machine2 =

     

       56
       55
        
             { ... }:

     

       57
       56
        
             {

     

       58
       58
       -
               virtualisation.memorySize = 256;

     

       59
       57
        
               virtualisation.vlans = [ 1 ];

     

       60
       58
        
             };

     

       61
       59

-4

nixos/tests/containers-physical_interfaces.nix

···

       7
       7
        
         nodes = {

     

       8
       8
        
           server = { ... }:

     

       9
       9
        
             {

     

       10
       10
       -
               virtualisation.memorySize = 256;

     

       11
       10
        
               virtualisation.vlans = [ 1 ];

     

       12
       11
        
       

     

       13
       12
        
               containers.server = {

     
···

       23
       22
        
               };

     

       24
       23
        
             };

     

       25
       24
        
           bridged = { ... }: {

     

       26
       26
       -
             virtualisation.memorySize = 128;

     

       27
       25
        
             virtualisation.vlans = [ 1 ];

     

       28
       26
        
       

     

       29
       27
        
             containers.bridged = {

     
···

       41
       39
        
           };

     

       42
       40
        
       

     

       43
       41
        
           bonded = { ... }: {

     

       44
       44
       -
             virtualisation.memorySize = 128;

     

       45
       42
        
             virtualisation.vlans = [ 1 ];

     

       46
       43
        
       

     

       47
       44
        
             containers.bonded = {

     
···

       62
       59
        
           };

     

       63
       60
        
       

     

       64
       61
        
           bridgedbond = { ... }: {

     

       65
       65
       -
             virtualisation.memorySize = 128;

     

       66
       62
        
             virtualisation.vlans = [ 1 ];

     

       67
       63
        
       

     

       68
       64
        
             containers.bridgedbond = {

-1

nixos/tests/containers-portforward.nix

···

       15
       15
        
           { pkgs, ... }:

     

       16
       16
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       17
       17
        
             virtualisation.writableStore = true;

     

       18
       18
       -
             virtualisation.memorySize = 768;

     

       19
       18
        
       

     

       20
       19
        
             containers.webserver =

     

       21
       20
        
               { privateNetwork = true;

-1

nixos/tests/containers-tmpfs.nix

···

       8
       8
        
           { pkgs, ... }:

     

       9
       9
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       10
       10
        
             virtualisation.writableStore = true;

     

       11
       11
       -
             virtualisation.memorySize = 768;

     

       12
       11
        
       

     

       13
       12
        
             containers.tmpfs =

     

       14
       13
        
               {

-2

nixos/tests/custom-ca.nix

···

       81
       81
        
       

     

       82
       82
        
             # chromium-based browsers refuse to run as root

     

       83
       83
        
             test-support.displayManager.auto.user = "alice";

     

       84
       84
       -
             # browsers may hang with the default memory

     

       85
       85
       -
             virtualisation.memorySize = 500;

     

       86
       84
        
       

     

       87
       85
        
             networking.hosts."127.0.0.1" = [ "good.example.com" "bad.example.com" ];

     

       88
       86
        
             security.pki.certificateFiles = [ "${example-good-cert}/ca.crt" ];

-1

nixos/tests/enlightenment.nix

···

       19
       19
        
             };

     

       20
       20
        
           };

     

       21
       21
        
           hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       22
       22
       -
           virtualisation.memorySize = 1024;

     

       23
       22
        
           environment.systemPackages = [ pkgs.xdotool ];

     

       24
       23
        
           services.acpid.enable = true;

     

       25
       24
        
           services.connman.enable = true;

-1

nixos/tests/fcitx/default.nix

···

       11
       11
        
                 ...

     

       12
       12
        
               }:

     

       13
       13
        
                 {

     

       14
       14
       -
                   virtualisation.memorySize = 1024;

     

       15
       14
        
       

     

       16
       15
        
                   imports = [

     

       17
       16
        
                     ../common/user-account.nix

-1

nixos/tests/fenics.nix

···

       38
       38
        
               gcc

     

       39
       39
        
               (python3.withPackages (ps: with ps; [ fenics ]))

     

       40
       40
        
             ];

     

       41
       41
       -
             virtualisation.memorySize = 512;

     

       42
       41
        
           };

     

       43
       42
        
         };

     

       44
       43
        
         testScript =

-3

nixos/tests/firefox.nix

···

       13
       13
        
               pkgs.xdotool

     

       14
       14
        
             ];

     

       15
       15
        
       

     

       16
       16
       -
             # Need some more memory to record audio.

     

       17
       17
       -
             virtualisation.memorySize = 500;

     

       18
       18
       -
       

     

       19
       16
        
             # Create a virtual sound device, with mixing

     

       20
       17
        
             # and all, for recording audio.

     

       21
       18
        
             boot.kernelModules = [ "snd-aloop" ];

-1

nixos/tests/gerrit.nix

···

       18
       18
        
             { config, pkgs, ... }: {

     

       19
       19
        
               networking.firewall.allowedTCPPorts = [ 80 2222 ];

     

       20
       20
        
       

     

       21
       21
       -
               virtualisation.memorySize = 1024;

     

       22
       21
        
       

     

       23
       22
        
               services.gerrit = {

     

       24
       23
        
                 enable = true;

-1

nixos/tests/gnome-xorg.nix

···

       40
       40
        
               };

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
       -
             virtualisation.memorySize = 1024;

     

       44
       43
        
           };

     

       45
       44
        
       

     

       46
       45
        
         testScript = { nodes, ... }: let

-1

nixos/tests/gnome.nix

···

       45
       45
        
               };

     

       46
       46
        
             };

     

       47
       47
        
       

     

       48
       48
       -
             virtualisation.memorySize = 1024;

     

       49
       48
        
           };

     

       50
       49
        
       

     

       51
       50
        
         testScript = { nodes, ... }: let

-1

nixos/tests/graphite.nix

···

       4
       4
        
         nodes = {

     

       5
       5
        
           one =

     

       6
       6
        
             { ... }: {

     

       7
       7
       -
               virtualisation.memorySize = 1024;

     

       8
       7
        
               time.timeZone = "UTC";

     

       9
       8
        
               services.graphite = {

     

       10
       9
        
                 web = {

-2

nixos/tests/hadoop/hadoop.nix

···

       95
       95
        
       

     

       96
       96
        
           # YARN cluster

     

       97
       97
        
           rm1 = {pkgs, options, ...}: {

     

       98
       98
       -
             virtualisation.memorySize = 1024;

     

       99
       98
        
             services.hadoop = {

     

       100
       99
        
               inherit package coreSite hdfsSite;

     

       101
       100
        
               yarnSite = options.services.hadoop.yarnSite.default // yarnSiteHA;

     
···

       103
       102
        
             };

     

       104
       103
        
           };

     

       105
       104
        
           rm2 = {pkgs, options, ...}: {

     

       106
       106
       -
             virtualisation.memorySize = 1024;

     

       107
       105
        
             services.hadoop = {

     

       108
       106
        
               inherit package coreSite hdfsSite;

     

       109
       107
        
               yarnSite = options.services.hadoop.yarnSite.default // yarnSiteHA;

-1

nixos/tests/hadoop/hdfs.nix

···

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

     

       3
       3
        
         nodes = {

     

       4
       4
        
           namenode = {pkgs, ...}: {

     

       5
       5
       -
             virtualisation.memorySize = 1024;

     

       6
       5
        
             services.hadoop = {

     

       7
       6
        
               package = pkgs.hadoop;

     

       8
       7
        
               hdfs = {

-1

nixos/tests/installed-tests/fwupd.nix

···

       7
       7
        
           services.fwupd.enable = true;

     

       8
       8
        
           services.fwupd.disabledPlugins = lib.mkForce []; # don't disable test plugin

     

       9
       9
        
           services.fwupd.enableTestRemote = true;

     

       10
       10
       -
           virtualisation.memorySize = 768;

     

       11
       10
        
         };

     

       12
       11
        
       }

-1

nixos/tests/jitsi-meet.nix

···

       8
       8
        
           client = { nodes, pkgs, ... }: {

     

       9
       9
        
           };

     

       10
       10
        
           server = { config, pkgs, ... }: {

     

       11
       11
       -
             virtualisation.memorySize = 512;

     

       12
       11
        
             services.jitsi-meet = {

     

       13
       12
        
               enable = true;

     

       14
       13
        
               hostName = "server";

-1

nixos/tests/kafka.nix

···

       19
       19
        
               };

     

       20
       20
        
       

     

       21
       21
        
               networking.firewall.allowedTCPPorts = [ 2181 ];

     

       22
       22
       -
               virtualisation.memorySize = 1024;

     

       23
       22
        
             };

     

       24
       23
        
             kafka = { ... }: {

     

       25
       24
        
               services.apache-kafka = {

-1

nixos/tests/keycloak.nix

···

       17
       17
        
       

     

       18
       18
        
             nodes = {

     

       19
       19
        
               keycloak = { ... }: {

     

       20
       20
       -
                 virtualisation.memorySize = 1024;

     

       21
       20
        
       

     

       22
       21
        
                 security.pki.certificateFiles = [

     

       23
       22
        
                   certs.ca.cert

-2

nixos/tests/lxd-image.nix

···

       46
       46
        
       

     

       47
       47
        
         machine = { lib, ... }: {

     

       48
       48
        
           virtualisation = {

     

       49
       49
       -
             # OOMs otherwise

     

       50
       50
       -
             memorySize = 1024;

     

       51
       49
        
             # disk full otherwise

     

       52
       50
        
             diskSize = 2048;

     

       53
       51

-1

nixos/tests/metabase.nix

···

       7
       7
        
         nodes = {

     

       8
       8
        
           machine = { ... }: {

     

       9
       9
        
             services.metabase.enable = true;

     

       10
       10
       -
             virtualisation.memorySize = 1024;

     

       11
       10
        
           };

     

       12
       11
        
         };

     

       13
       12

-4

nixos/tests/mysql/mysql.nix

···

       64
       64
        
             {

     

       65
       65
        
               imports = [ users ];

     

       66
       66
        
       

     

       67
       67
       -
               # prevent oom:

     

       68
       68
       -
               # Kernel panic - not syncing: Out of memory: compulsory panic_on_oom is enabled

     

       69
       69
       -
               virtualisation.memorySize = 1024;

     

       70
       70
       -
       

     

       71
       67
        
               services.mysql.enable = true;

     

       72
       68
        
               services.mysql.initialDatabases = [

     

       73
       69
        
                 { name = "testdb3"; schema = ./testdb.sql; }

-1

nixos/tests/networking-proxy.nix

···

       8
       8
        
       

     

       9
       9
        
               services.xserver.enable = false;

     

       10
       10
        
       

     

       11
       11
       -
               virtualisation.memorySize = 128;

     

       12
       11
        
             };

     

       13
       12
        
       in import ./make-test-python.nix ({ pkgs, ...} : {

     

       14
       13
        
         name = "networking-proxy";

-1

nixos/tests/nginx-etag.nix

···

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
        
           client = { pkgs, lib, ... }: {

     

       40
       40
       -
             virtualisation.memorySize = 512;

     

       41
       40
        
             environment.systemPackages = let

     

       42
       41
        
               testRunner = pkgs.writers.writePython3Bin "test-runner" {

     

       43
       42
        
                 libraries = [ pkgs.python3Packages.selenium ];

-1

nixos/tests/nixops/default.nix

···

       26
       26
        
               nix.binaryCaches = lib.mkForce [ ];

     

       27
       27
        
               users.users.person.isNormalUser = true;

     

       28
       28
        
               virtualisation.writableStore = true;

     

       29
       29
       -
               virtualisation.memorySize = 1024 /*MiB*/;

     

       30
       29
        
               virtualisation.additionalPaths = [

     

       31
       30
        
                 pkgs.hello

     

       32
       31
        
                 pkgs.figlet

-1

nixos/tests/opensmtpd-rspamd.nix

···

       39
       39
        
       

     

       40
       40
        
           smtp2 = { pkgs, ... }: {

     

       41
       41
        
             imports = [ common/user-account.nix ];

     

       42
       42
       -
             virtualisation.memorySize = 512;

     

       43
       42
        
             networking = {

     

       44
       43
        
               firewall.allowedTCPPorts = [ 25 143 ];

     

       45
       44
        
               useDHCP = false;

-1

nixos/tests/pantheon.nix

···

       15
       15
        
           services.xserver.enable = true;

     

       16
       16
        
           services.xserver.desktopManager.pantheon.enable = true;

     

       17
       17
        
       

     

       18
       18
       -
           virtualisation.memorySize = 1024;

     

       19
       18
        
         };

     

       20
       19
        
       

     

       21
       20
        
         enableOCR = true;

-1

nixos/tests/paperless-ng.nix

···

       8
       8
        
             enable = true;

     

       9
       9
        
             passwordFile = builtins.toFile "password" "admin";

     

       10
       10
        
           };

     

       11
       11
       -
           virtualisation.memorySize = 1024;

     

       12
       11
        
         };

     

       13
       12
        
       

     

       14
       13
        
         testScript = ''

-1

nixos/tests/plasma5-systemd-start.nix

···

       21
       21
        
               user = "alice";

     

       22
       22
        
             };

     

       23
       23
        
           };

     

       24
       24
       -
           virtualisation.memorySize = 1024;

     

       25
       24
        
         };

     

       26
       25
        
       

     

       27
       26
        
         testScript = { nodes, ... }: let

-1

nixos/tests/plasma5.nix

···

       19
       19
        
             user = "alice";

     

       20
       20
        
           };

     

       21
       21
        
           hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       22
       22
       -
           virtualisation.memorySize = 1024;

     

       23
       22
        
         };

     

       24
       23
        
       

     

       25
       24
        
         testScript = { nodes, ... }: let

-1

nixos/tests/pleroma.nix

···

       202
       202
        
             security.pki.certificateFiles = [ "${tls-cert}/cert.pem" ];

     

       203
       203
        
             networking.extraHosts = hosts nodes;

     

       204
       204
        
             networking.firewall.enable = false;

     

       205
       205
       -
             virtualisation.memorySize = 512;

     

       206
       205
        
             environment.systemPackages = with pkgs; [

     

       207
       206
        
               provision-db

     

       208
       207
        
               provision-secrets

-1

nixos/tests/privacyidea.nix

···

       8
       8
        
       

     

       9
       9
        
         machine = { ... }: {

     

       10
       10
        
           virtualisation.cores = 2;

     

       11
       11
       -
           virtualisation.memorySize = 512;

     

       12
       11
        
       

     

       13
       12
        
           services.privacyidea = {

     

       14
       13
        
             enable = true;

-2

nixos/tests/prometheus-exporters.nix

···

       464
       464
        
               extraFlags = [ "--lnd.network=regtest" ];

     

       465
       465
        
             };

     

       466
       466
        
             metricProvider = {

     

       467
       467
       -
               virtualisation.memorySize = 1024;

     

       468
       467
        
               systemd.services.prometheus-lnd-exporter.serviceConfig.RestartSec = 15;

     

       469
       468
        
               systemd.services.prometheus-lnd-exporter.after = [ "lnd.service" ];

     

       470
       469
        
               services.bitcoind.regtest = {

     
···

       953
       952
        
             };

     

       954
       953
        
             metricProvider = {

     

       955
       954
        
               services.rspamd.enable = true;

     

       956
       956
       -
               virtualisation.memorySize = 1024;

     

       957
       955
        
             };

     

       958
       956
        
             exporterTest = ''

     

       959
       957
        
               wait_for_unit("rspamd.service")

-1

nixos/tests/prometheus.nix

···

       188
       188
        
             # Minio requires at least 1GiB of free disk space to run.

     

       189
       189
        
             virtualisation = {

     

       190
       190
        
               diskSize = 2 * 1024;

     

       191
       191
       -
               memorySize = 1024;

     

       192
       191
        
             };

     

       193
       192
        
             networking.firewall.allowedTCPPorts = [ minioPort ];

     

       194
       193

-5

nixos/tests/rspamd.nix

···

       25
       25
        
           machine = {

     

       26
       26
        
             services.rspamd.enable = true;

     

       27
       27
        
             networking.enableIPv6 = enableIPv6;

     

       28
       28
       -
             virtualisation.memorySize = 1024;

     

       29
       28
        
           };

     

       30
       29
        
           testScript = ''

     

       31
       30
        
             start_all()

     
···

       69
       68
        
                 group = "rspamd";

     

       70
       69
        
               }];

     

       71
       70
        
             };

     

       72
       72
       -
             virtualisation.memorySize = 1024;

     

       73
       71
        
           };

     

       74
       72
        
       

     

       75
       73
        
           testScript = ''

     
···

       118
       116
        
                 '';

     

       119
       117
        
               };

     

       120
       118
        
             };

     

       121
       121
       -
             virtualisation.memorySize = 1024;

     

       122
       119
        
           };

     

       123
       120
        
       

     

       124
       121
        
           testScript = ''

     
···

       224
       221
        
                 rspamd_logger.infox(rspamd_config, 'Work dammit!!!')

     

       225
       222
        
               '';

     

       226
       223
        
             };

     

       227
       227
       -
             virtualisation.memorySize = 1024;

     

       228
       224
        
           };

     

       229
       225
        
           testScript = ''

     

       230
       226
        
             ${initMachine}

     
···

       291
       287
        
               postfix.enable = true;

     

       292
       288
        
               workers.rspamd_proxy.type = "rspamd_proxy";

     

       293
       289
        
             };

     

       294
       294
       -
             virtualisation.memorySize = 1024;

     

       295
       290
        
           };

     

       296
       291
        
           testScript = ''

     

       297
       292
        
             ${initMachine}

-2

nixos/tests/seafile.nix

···

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

     

       2
       2
        
         let

     

       3
       3
        
           client = { config, pkgs, ... }: {

     

       4
       4
       -
             virtualisation.memorySize = 256;

     

       5
       4
        
             environment.systemPackages = [ pkgs.seafile-shared pkgs.curl ];

     

       6
       5
        
           };

     

       7
       6
        
         in {

     
···

       12
       11
        
       

     

       13
       12
        
           nodes = {

     

       14
       13
        
             server = { config, pkgs, ... }: {

     

       15
       15
       -
               virtualisation.memorySize = 512;

     

       16
       14
        
               services.seafile = {

     

       17
       15
        
                 enable = true;

     

       18
       16
        
                 ccnetSettings.General.SERVICE_URL = "http://server";

-1

nixos/tests/signal-desktop.nix

···

       29
       29
        
           environment.systemPackages = with pkgs; [

     

       30
       30
        
             signal-desktop file sqlite sqlcipher-signal

     

       31
       31
        
           ];

     

       32
       32
       -
           virtualisation.memorySize = 1024;

     

       33
       32
        
         };

     

       34
       33
        
       

     

       35
       34
        
         enableOCR = true;

-1

nixos/tests/spark/default.nix

···

       3
       3
        
       

     

       4
       4
        
         nodes = {

     

       5
       5
        
           worker = { nodes, pkgs, ... }: {

     

       6
       6
       -
             virtualisation.memorySize = 1024;

     

       7
       6
        
             services.spark.worker = {

     

       8
       7
        
               enable = true;

     

       9
       8
        
               master = "master:7077";

-1

nixos/tests/sway.nix

···

       44
       44
        
           # To test pinentry via gpg-agent:

     

       45
       45
        
           programs.gnupg.agent.enable = true;

     

       46
       46
        
       

     

       47
       47
       -
           virtualisation.memorySize = 1024;

     

       48
       47
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Sway can launch:

     

       49
       48
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       50
       49
        
         };

-1

nixos/tests/sympa.nix

···

       5
       5
        
         machine =

     

       6
       6
        
           { ... }:

     

       7
       7
        
           {

     

       8
       8
       -
             virtualisation.memorySize = 1024;

     

       9
       8
        
       

     

       10
       9
        
             services.sympa = {

     

       11
       10
        
               enable = true;

-1

nixos/tests/systemd-cryptenroll.nix

···

       8
       8
        
           environment.systemPackages = [ pkgs.cryptsetup ];

     

       9
       9
        
           virtualisation = {

     

       10
       10
        
             emptyDiskImages = [ 512 ];

     

       11
       11
       -
             memorySize = 1024;

     

       12
       11
        
             qemu.options = [

     

       13
       12
        
               "-chardev socket,id=chrtpm,path=/tmp/swtpm-sock"

     

       14
       13
        
               "-tpmdev emulator,id=tpm0,chardev=chrtpm"

-1

nixos/tests/systemd.nix

···

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

     

       6
       6
        
       

     

       7
       7
        
           virtualisation.emptyDiskImages = [ 512 512 ];

     

       8
       8
       -
           virtualisation.memorySize = 1024;

     

       9
       8
        
       

     

       10
       9
        
           environment.systemPackages = [ pkgs.cryptsetup ];

     

       11
       10

-1

nixos/tests/vault-postgresql.nix

···

       12
       12
        
           maintainers = [ lnl7 roberth ];

     

       13
       13
        
         };

     

       14
       14
        
         machine = { lib, pkgs, ... }: {

     

       15
       15
       -
           virtualisation.memorySize = 512;

     

       16
       15
        
           environment.systemPackages = [ pkgs.vault ];

     

       17
       16
        
           environment.variables.VAULT_ADDR = "http://127.0.0.1:8200";

     

       18
       17
        
           services.vault.enable = true;

-1

nixos/tests/vault.nix

···

       8
       8
        
           environment.systemPackages = [ pkgs.vault ];

     

       9
       9
        
           environment.variables.VAULT_ADDR = "http://127.0.0.1:8200";

     

       10
       10
        
           services.vault.enable = true;

     

       11
       11
       -
           virtualisation.memorySize = 512;

     

       12
       11
        
         };

     

       13
       12
        
       

     

       14
       13
        
         testScript =

-1

nixos/tests/vaultwarden.nix

···

       140
       140
        
                     in

     

       141
       141
        
                     [ pkgs.firefox-unwrapped pkgs.geckodriver testRunner ];

     

       142
       142
        
       

     

       143
       143
       -
                   virtualisation.memorySize = 768;

     

       144
       143
        
                 }

     

       145
       144
        
               ];

     

       146
       145

-1

nixos/tests/xfce.nix

···

       23
       23
        
       

     

       24
       24
        
             hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       25
       25
        
       

     

       26
       26
       -
             virtualisation.memorySize = 1024;

     

       27
       26
        
           };

     

       28
       27
        
       

     

       29
       28
        
         testScript = { nodes, ... }: let