2022-06-25 10:47:50 +00:00
|
|
|
{ system,
|
|
|
|
|
pkgs,
|
|
|
|
|
|
|
|
|
|
# Projects the test configuration into a the desired value; usually
|
|
|
|
|
# the test runner: `config: config.test`.
|
|
|
|
|
callTest,
|
|
|
|
|
|
|
|
|
|
}:
|
2018-11-11 11:30:07 +00:00
|
|
|
# The return value of this function will be an attrset with arbitrary depth and
|
|
|
|
|
# the `anything` returned by callTest at its test leafs.
|
|
|
|
|
# The tests not supported by `system` will be replaced with `{}`, so that
|
2018-11-11 13:55:23 +00:00
|
|
|
# `passthru.tests` can contain links to those without breaking on architectures
|
2018-11-11 11:30:07 +00:00
|
|
|
# where said tests are unsupported.
|
|
|
|
|
# Example callTest that just extracts the derivation from the test:
|
|
|
|
|
# callTest = t: t.test;
|
|
|
|
|
|
|
|
|
|
with pkgs.lib;
|
|
|
|
|
|
|
|
|
|
let
|
|
|
|
|
discoverTests = val:
|
2022-06-25 19:26:50 +00:00
|
|
|
if isAttrs val
|
|
|
|
|
then
|
|
|
|
|
if hasAttr "test" val then callTest val
|
2023-08-06 13:40:10 +00:00
|
|
|
else mapAttrs (n: s: if n == "passthru" then s else discoverTests s) val
|
2022-06-25 19:26:50 +00:00
|
|
|
else if isFunction val
|
|
|
|
|
then
|
|
|
|
|
# Tests based on make-test-python.nix will return the second lambda
|
|
|
|
|
# in that file, which are then forwarded to the test definition
|
|
|
|
|
# following the `import make-test-python.nix` expression
|
|
|
|
|
# (if it is a function).
|
|
|
|
|
discoverTests (val { inherit system pkgs; })
|
|
|
|
|
else val;
|
2018-11-11 11:30:07 +00:00
|
|
|
handleTest = path: args:
|
|
|
|
|
discoverTests (import path ({ inherit system pkgs; } // args));
|
|
|
|
|
handleTestOn = systems: path: args:
|
|
|
|
|
if elem system systems then handleTest path args
|
|
|
|
|
else {};
|
2021-12-03 12:04:36 +00:00
|
|
|
|
2022-01-07 00:09:46 +00:00
|
|
|
nixosLib = import ../lib {
|
|
|
|
|
# Experimental features need testing too, but there's no point in warning
|
|
|
|
|
# about it, so we enable the feature flag.
|
|
|
|
|
featureFlags.minimalModules = {};
|
|
|
|
|
};
|
2021-12-03 12:04:36 +00:00
|
|
|
evalMinimalConfig = module: nixosLib.evalModules { modules = [ module ]; };
|
2022-06-03 12:34:29 +00:00
|
|
|
|
2022-06-06 18:19:59 +00:00
|
|
|
inherit
|
|
|
|
|
(rec {
|
2022-09-29 08:32:31 +00:00
|
|
|
doRunTest = arg: ((import ../lib/testing-python.nix { inherit system pkgs; }).evalTest {
|
2023-05-07 17:25:33 +00:00
|
|
|
imports = [ arg readOnlyPkgs ];
|
2022-09-29 08:32:31 +00:00
|
|
|
}).config.result;
|
2022-06-06 18:19:59 +00:00
|
|
|
findTests = tree:
|
|
|
|
|
if tree?recurseForDerivations && tree.recurseForDerivations
|
2022-06-25 10:47:50 +00:00
|
|
|
then
|
|
|
|
|
mapAttrs
|
|
|
|
|
(k: findTests)
|
|
|
|
|
(builtins.removeAttrs tree ["recurseForDerivations"])
|
|
|
|
|
else callTest tree;
|
|
|
|
|
|
2022-06-06 18:19:59 +00:00
|
|
|
runTest = arg: let r = doRunTest arg; in findTests r;
|
|
|
|
|
runTestOn = systems: arg:
|
|
|
|
|
if elem system systems then runTest arg
|
|
|
|
|
else {};
|
|
|
|
|
})
|
|
|
|
|
runTest
|
|
|
|
|
runTestOn
|
|
|
|
|
;
|
|
|
|
|
|
2023-05-07 13:44:54 +00:00
|
|
|
# Using a single instance of nixpkgs makes test evaluation faster.
|
|
|
|
|
# To make sure we don't accidentally depend on a modified pkgs, we make the
|
|
|
|
|
# related options read-only. We need to test the right configuration.
|
|
|
|
|
#
|
|
|
|
|
# If your service depends on a nixpkgs setting, first try to avoid that, but
|
|
|
|
|
# otherwise, you can remove the readOnlyPkgs import and test your service as
|
|
|
|
|
# usual.
|
|
|
|
|
readOnlyPkgs =
|
|
|
|
|
# TODO: We currently accept this for nixosTests, so that the `pkgs` argument
|
|
|
|
|
# is consistent with `pkgs` in `pkgs.nixosTests`. Can we reinitialize
|
|
|
|
|
# it with `allowAliases = false`?
|
|
|
|
|
# warnIf pkgs.config.allowAliases "nixosTests: pkgs includes aliases."
|
|
|
|
|
{
|
2024-03-02 05:33:14 +00:00
|
|
|
_file = "${__curPos.file} readOnlyPkgs";
|
2023-05-07 13:44:54 +00:00
|
|
|
_class = "nixosTest";
|
2024-03-02 05:33:14 +00:00
|
|
|
node.pkgs = pkgs.pkgsLinux;
|
2023-05-07 13:44:54 +00:00
|
|
|
};
|
|
|
|
|
|
2022-06-06 17:24:30 +00:00
|
|
|
in {
|
2023-04-25 09:59:14 +00:00
|
|
|
|
|
|
|
|
# Testing the test driver
|
|
|
|
|
nixos-test-driver = {
|
|
|
|
|
extra-python-packages = handleTest ./nixos-test-driver/extra-python-packages.nix {};
|
2023-06-04 03:10:20 +00:00
|
|
|
lib-extend = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./nixos-test-driver/lib-extend.nix {};
|
2023-04-25 10:21:38 +00:00
|
|
|
node-name = runTest ./nixos-test-driver/node-name.nix;
|
2023-07-07 08:58:13 +00:00
|
|
|
busybox = runTest ./nixos-test-driver/busybox.nix;
|
2023-10-27 11:32:04 +00:00
|
|
|
driver-timeout = pkgs.runCommand "ensure-timeout-induced-failure" {
|
|
|
|
|
failed = pkgs.testers.testBuildFailure ((runTest ./nixos-test-driver/timeout.nix).config.rawTestDerivation);
|
|
|
|
|
} ''
|
|
|
|
|
grep -F "timeout reached; test terminating" $failed/testBuildFailure.log
|
|
|
|
|
# The program will always be terminated by SIGTERM (143) if it waits for the deadline thread.
|
|
|
|
|
[[ 143 = $(cat $failed/testBuildFailure.exit) ]]
|
|
|
|
|
touch $out
|
|
|
|
|
'';
|
2023-04-25 09:59:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
# NixOS vm tests and non-vm unit tests
|
|
|
|
|
|
2022-06-06 19:19:22 +00:00
|
|
|
_3proxy = runTest ./3proxy.nix;
|
2023-04-04 18:18:38 +00:00
|
|
|
aaaaxy = runTest ./aaaaxy.nix;
|
2022-06-06 21:49:59 +00:00
|
|
|
acme = runTest ./acme.nix;
|
2023-05-31 13:08:39 +00:00
|
|
|
acme-dns = handleTest ./acme-dns.nix {};
|
2022-06-09 15:43:22 +00:00
|
|
|
adguardhome = runTest ./adguardhome.nix;
|
2022-11-25 18:20:39 +00:00
|
|
|
aesmd = runTestOn ["x86_64-linux"] ./aesmd.nix;
|
2022-06-09 15:46:51 +00:00
|
|
|
agate = runTest ./web-servers/agate.nix;
|
2020-04-19 18:01:37 +00:00
|
|
|
agda = handleTest ./agda.nix {};
|
2024-10-14 21:25:16 +00:00
|
|
|
agorakit = runTest ./web-apps/agorakit.nix;
|
2021-05-03 15:38:02 +00:00
|
|
|
airsonic = handleTest ./airsonic.nix {};
|
2022-09-24 13:52:36 +00:00
|
|
|
akkoma = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix {};
|
|
|
|
|
akkoma-confined = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix { confined = true; };
|
2023-04-11 15:55:16 +00:00
|
|
|
alice-lg = handleTest ./alice-lg.nix {};
|
2024-06-08 15:31:12 +00:00
|
|
|
alloy = handleTest ./alloy.nix {};
|
2021-10-05 11:33:18 +00:00
|
|
|
allTerminfo = handleTest ./all-terminfo.nix {};
|
2022-11-16 16:56:44 +00:00
|
|
|
alps = handleTest ./alps.nix {};
|
2024-08-27 05:53:59 +00:00
|
|
|
amazon-cloudwatch-agent = handleTest ./amazon-cloudwatch-agent.nix {};
|
2021-04-18 09:19:06 +00:00
|
|
|
amazon-init-shell = handleTest ./amazon-init-shell.nix {};
|
2023-10-25 09:29:11 +00:00
|
|
|
amazon-ssm-agent = handleTest ./amazon-ssm-agent.nix {};
|
2023-08-10 18:42:41 +00:00
|
|
|
amd-sev = runTest ./amd-sev.nix;
|
2020-11-02 20:05:23 +00:00
|
|
|
anbox = runTest ./anbox.nix;
|
2023-11-20 20:22:02 +00:00
|
|
|
angie-api = handleTest ./angie-api.nix {};
|
2023-09-25 13:01:02 +00:00
|
|
|
anki-sync-server = handleTest ./anki-sync-server.nix {};
|
2023-06-27 10:30:06 +00:00
|
|
|
anuko-time-tracker = handleTest ./anuko-time-tracker.nix {};
|
2022-12-29 12:43:50 +00:00
|
|
|
apcupsd = handleTest ./apcupsd.nix {};
|
2023-04-04 18:12:51 +00:00
|
|
|
apfs = runTest ./apfs.nix;
|
2023-07-16 20:16:55 +00:00
|
|
|
appliance-repart-image = runTest ./appliance-repart-image.nix;
|
2024-09-18 17:26:31 +00:00
|
|
|
appliance-repart-image-verity-store = runTest ./appliance-repart-image-verity-store.nix;
|
2021-02-28 21:18:01 +00:00
|
|
|
apparmor = handleTest ./apparmor.nix {};
|
2023-10-31 00:06:08 +00:00
|
|
|
archi = handleTest ./archi.nix {};
|
2024-04-16 17:14:48 +00:00
|
|
|
aria2 = handleTest ./aria2.nix {};
|
2023-11-25 21:06:11 +00:00
|
|
|
armagetronad = handleTest ./armagetronad.nix {};
|
2024-05-09 06:41:39 +00:00
|
|
|
artalk = handleTest ./artalk.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
atd = handleTest ./atd.nix {};
|
2021-05-14 00:11:05 +00:00
|
|
|
atop = handleTest ./atop.nix {};
|
2024-10-10 14:57:51 +00:00
|
|
|
atticd = runTest ./atticd.nix;
|
2022-12-16 03:07:15 +00:00
|
|
|
atuin = handleTest ./atuin.nix {};
|
2023-09-29 09:46:13 +00:00
|
|
|
audiobookshelf = handleTest ./audiobookshelf.nix {};
|
2022-07-31 21:40:48 +00:00
|
|
|
auth-mysql = handleTest ./auth-mysql.nix {};
|
2023-03-02 21:18:50 +00:00
|
|
|
authelia = handleTest ./authelia.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
avahi = handleTest ./avahi.nix {};
|
2020-10-11 18:45:25 +00:00
|
|
|
avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };
|
2024-08-15 20:06:15 +00:00
|
|
|
ayatana-indicators = runTest ./ayatana-indicators.nix;
|
2019-10-11 23:30:55 +00:00
|
|
|
babeld = handleTest ./babeld.nix {};
|
2020-05-10 10:54:09 +00:00
|
|
|
bazarr = handleTest ./bazarr.nix {};
|
2021-11-06 21:24:16 +00:00
|
|
|
bcachefs = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bcachefs.nix {};
|
2019-02-22 13:10:02 +00:00
|
|
|
beanstalkd = handleTest ./beanstalkd.nix {};
|
2019-11-24 00:10:17 +00:00
|
|
|
bees = handleTest ./bees.nix {};
|
2024-05-17 19:19:41 +00:00
|
|
|
benchexec = handleTest ./benchexec.nix {};
|
2022-10-04 04:06:28 +00:00
|
|
|
binary-cache = handleTest ./binary-cache.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
bind = handleTest ./bind.nix {};
|
2022-01-25 14:15:52 +00:00
|
|
|
bird = handleTest ./bird.nix {};
|
2023-04-12 07:20:16 +00:00
|
|
|
birdwatcher = handleTest ./birdwatcher.nix {};
|
2020-07-21 11:43:32 +00:00
|
|
|
bitcoind = handleTest ./bitcoind.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
bittorrent = handleTest ./bittorrent.nix {};
|
2020-06-23 11:09:03 +00:00
|
|
|
blockbook-frontend = handleTest ./blockbook-frontend.nix {};
|
2022-02-10 22:44:18 +00:00
|
|
|
blocky = handleTest ./blocky.nix {};
|
2021-05-25 18:13:29 +00:00
|
|
|
boot = handleTestOn ["x86_64-linux" "aarch64-linux"] ./boot.nix {};
|
2022-12-21 22:11:37 +00:00
|
|
|
bootspec = handleTestOn ["x86_64-linux"] ./bootspec.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
boot-stage1 = handleTest ./boot-stage1.nix {};
|
|
|
|
|
borgbackup = handleTest ./borgbackup.nix {};
|
2024-03-02 11:24:17 +00:00
|
|
|
borgmatic = handleTest ./borgmatic.nix {};
|
2021-05-04 12:30:25 +00:00
|
|
|
botamusique = handleTest ./botamusique.nix {};
|
2021-12-04 01:20:26 +00:00
|
|
|
bpf = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bpf.nix {};
|
2023-06-29 02:43:06 +00:00
|
|
|
bpftune = handleTest ./bpftune.nix {};
|
2022-01-26 13:03:05 +00:00
|
|
|
breitbandmessung = handleTest ./breitbandmessung.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
brscan5 = handleTest ./brscan5.nix {};
|
2021-05-30 12:00:00 +00:00
|
|
|
btrbk = handleTest ./btrbk.nix {};
|
2022-10-02 10:42:57 +00:00
|
|
|
btrbk-doas = handleTest ./btrbk-doas.nix {};
|
2022-03-19 15:51:32 +00:00
|
|
|
btrbk-no-timer = handleTest ./btrbk-no-timer.nix {};
|
2022-10-18 15:50:44 +00:00
|
|
|
btrbk-section-order = handleTest ./btrbk-section-order.nix {};
|
2023-02-17 02:48:02 +00:00
|
|
|
budgie = handleTest ./budgie.nix {};
|
2023-12-26 21:13:50 +00:00
|
|
|
buildbot = handleTest ./buildbot.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
buildkite-agents = handleTest ./buildkite-agents.nix {};
|
2023-10-01 20:09:53 +00:00
|
|
|
c2fmzq = handleTest ./c2fmzq.nix {};
|
2019-10-09 11:32:03 +00:00
|
|
|
caddy = handleTest ./caddy.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
cadvisor = handleTestOn ["x86_64-linux"] ./cadvisor.nix {};
|
2021-05-27 18:37:24 +00:00
|
|
|
cage = handleTest ./cage.nix {};
|
|
|
|
|
cagebreak = handleTest ./cagebreak.nix {};
|
2021-02-23 11:23:20 +00:00
|
|
|
calibre-web = handleTest ./calibre-web.nix {};
|
2023-06-28 12:06:47 +00:00
|
|
|
calibre-server = handleTest ./calibre-server.nix {};
|
2024-08-15 14:35:10 +00:00
|
|
|
canaille = handleTest ./canaille.nix {};
|
2023-04-07 13:36:13 +00:00
|
|
|
castopod = handleTest ./castopod.nix {};
|
2020-12-09 12:01:56 +00:00
|
|
|
cassandra_3_0 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_0; };
|
|
|
|
|
cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; };
|
2022-04-06 11:03:07 +00:00
|
|
|
cassandra_4 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_4; };
|
2023-08-15 03:34:32 +00:00
|
|
|
centrifugo = runTest ./centrifugo.nix;
|
2023-03-24 13:29:07 +00:00
|
|
|
ceph-multi-node = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-multi-node.nix {};
|
|
|
|
|
ceph-single-node = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node.nix {};
|
|
|
|
|
ceph-single-node-bluestore = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node-bluestore.nix {};
|
2024-08-22 13:31:52 +00:00
|
|
|
ceph-single-node-bluestore-dmcrypt = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node-bluestore-dmcrypt.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
certmgr = handleTest ./certmgr.nix {};
|
2022-09-24 07:38:37 +00:00
|
|
|
cfssl = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cfssl.nix {};
|
2022-04-05 00:02:11 +00:00
|
|
|
cgit = handleTest ./cgit.nix {};
|
2020-08-25 07:44:27 +00:00
|
|
|
charliecloud = handleTest ./charliecloud.nix {};
|
2024-08-16 16:14:15 +00:00
|
|
|
chromadb = runTest ./chromadb.nix;
|
2022-10-09 21:29:45 +00:00
|
|
|
chromium = (handleTestOn ["aarch64-linux" "x86_64-linux"] ./chromium.nix {}).stable or {};
|
2023-08-10 00:02:33 +00:00
|
|
|
chrony = handleTestOn ["aarch64-linux" "x86_64-linux"] ./chrony.nix {};
|
2023-01-15 13:06:58 +00:00
|
|
|
chrony-ptp = handleTestOn ["aarch64-linux" "x86_64-linux"] ./chrony-ptp.nix {};
|
2022-09-05 07:40:17 +00:00
|
|
|
cinnamon = handleTest ./cinnamon.nix {};
|
2023-11-19 16:10:36 +00:00
|
|
|
cinnamon-wayland = handleTest ./cinnamon-wayland.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
cjdns = handleTest ./cjdns.nix {};
|
2022-10-22 23:13:35 +00:00
|
|
|
clatd = handleTest ./clatd.nix {};
|
2018-12-19 14:06:53 +00:00
|
|
|
clickhouse = handleTest ./clickhouse.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
cloud-init = handleTest ./cloud-init.nix {};
|
2022-09-30 14:08:49 +00:00
|
|
|
cloud-init-hostname = handleTest ./cloud-init-hostname.nix {};
|
2023-01-01 23:19:37 +00:00
|
|
|
cloudlog = handleTest ./cloudlog.nix {};
|
2022-09-24 06:15:39 +00:00
|
|
|
cntr = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cntr.nix {};
|
2023-01-29 17:40:46 +00:00
|
|
|
cockpit = handleTest ./cockpit.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
cockroachdb = handleTestOn ["x86_64-linux"] ./cockroachdb.nix {};
|
2023-12-19 14:40:57 +00:00
|
|
|
code-server = handleTest ./code-server.nix {};
|
2022-10-24 20:08:00 +00:00
|
|
|
coder = handleTest ./coder.nix {};
|
2021-12-22 12:00:00 +00:00
|
|
|
collectd = handleTest ./collectd.nix {};
|
2024-04-15 11:57:37 +00:00
|
|
|
commafeed = handleTest ./commafeed.nix {};
|
2023-01-25 23:22:21 +00:00
|
|
|
connman = handleTest ./connman.nix {};
|
2019-11-24 14:08:53 +00:00
|
|
|
consul = handleTest ./consul.nix {};
|
2023-04-25 14:54:08 +00:00
|
|
|
consul-template = handleTest ./consul-template.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-bridge = handleTest ./containers-bridge.nix {};
|
2020-04-19 13:41:18 +00:00
|
|
|
containers-custom-pkgs.nix = handleTest ./containers-custom-pkgs.nix {};
|
2019-08-18 19:37:38 +00:00
|
|
|
containers-ephemeral = handleTest ./containers-ephemeral.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-extra_veth = handleTest ./containers-extra_veth.nix {};
|
|
|
|
|
containers-hosts = handleTest ./containers-hosts.nix {};
|
|
|
|
|
containers-imperative = handleTest ./containers-imperative.nix {};
|
2019-11-25 23:44:12 +00:00
|
|
|
containers-ip = handleTest ./containers-ip.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-macvlans = handleTest ./containers-macvlans.nix {};
|
2021-02-26 16:14:08 +00:00
|
|
|
containers-names = handleTest ./containers-names.nix {};
|
2021-02-24 13:02:57 +00:00
|
|
|
containers-nested = handleTest ./containers-nested.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-physical_interfaces = handleTest ./containers-physical_interfaces.nix {};
|
2019-12-10 19:34:37 +00:00
|
|
|
containers-portforward = handleTest ./containers-portforward.nix {};
|
2020-08-23 09:00:09 +00:00
|
|
|
containers-reloadable = handleTest ./containers-reloadable.nix {};
|
2024-03-20 18:22:44 +00:00
|
|
|
containers-require-bind-mounts = handleTest ./containers-require-bind-mounts.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-restart_networking = handleTest ./containers-restart_networking.nix {};
|
|
|
|
|
containers-tmpfs = handleTest ./containers-tmpfs.nix {};
|
2022-10-29 20:22:57 +00:00
|
|
|
containers-unified-hierarchy = handleTest ./containers-unified-hierarchy.nix {};
|
2020-06-05 12:54:29 +00:00
|
|
|
convos = handleTest ./convos.nix {};
|
2020-01-07 16:52:32 +00:00
|
|
|
corerad = handleTest ./corerad.nix {};
|
2021-07-03 07:32:03 +00:00
|
|
|
coturn = handleTest ./coturn.nix {};
|
2019-07-24 18:48:43 +00:00
|
|
|
couchdb = handleTest ./couchdb.nix {};
|
2024-04-02 10:16:53 +00:00
|
|
|
crabfit = handleTest ./crabfit.nix {};
|
2022-09-24 07:39:15 +00:00
|
|
|
cri-o = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cri-o.nix {};
|
2024-07-19 12:45:19 +00:00
|
|
|
cryptpad = runTest ./cryptpad.nix;
|
2022-07-20 18:14:06 +00:00
|
|
|
cups-pdf = handleTest ./cups-pdf.nix {};
|
2023-07-21 18:37:48 +00:00
|
|
|
curl-impersonate = handleTest ./curl-impersonate.nix {};
|
2021-01-10 17:28:29 +00:00
|
|
|
custom-ca = handleTest ./custom-ca.nix {};
|
2020-07-22 08:34:57 +00:00
|
|
|
croc = handleTest ./croc.nix {};
|
2024-05-10 02:29:44 +00:00
|
|
|
cyrus-imap = runTest ./cyrus-imap.nix;
|
2023-05-01 23:39:19 +00:00
|
|
|
darling = handleTest ./darling.nix {};
|
2024-07-01 19:42:50 +00:00
|
|
|
darling-dmg = runTest ./darling-dmg.nix;
|
2023-09-02 18:30:30 +00:00
|
|
|
dae = handleTest ./dae.nix {};
|
2024-03-25 14:32:01 +00:00
|
|
|
davis = handleTest ./davis.nix {};
|
2023-11-14 20:58:11 +00:00
|
|
|
db-rest = handleTest ./db-rest.nix {};
|
2023-06-14 08:27:19 +00:00
|
|
|
dconf = handleTest ./dconf.nix {};
|
2024-07-16 17:45:02 +00:00
|
|
|
ddns-updater = handleTest ./ddns-updater.nix {};
|
2023-09-17 18:04:28 +00:00
|
|
|
deconz = handleTest ./deconz.nix {};
|
2023-04-25 03:34:09 +00:00
|
|
|
deepin = handleTest ./deepin.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
deluge = handleTest ./deluge.nix {};
|
2022-05-13 07:46:01 +00:00
|
|
|
dendrite = handleTest ./matrix/dendrite.nix {};
|
2024-07-20 19:25:05 +00:00
|
|
|
dependency-track = handleTest ./dependency-track.nix {};
|
2024-04-19 11:26:38 +00:00
|
|
|
devpi-server = handleTest ./devpi-server.nix {};
|
2021-09-19 23:43:54 +00:00
|
|
|
dex-oidc = handleTest ./dex-oidc.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
dhparams = handleTest ./dhparams.nix {};
|
2021-09-12 06:06:34 +00:00
|
|
|
disable-installer-tools = handleTest ./disable-installer-tools.nix {};
|
2021-03-14 14:44:34 +00:00
|
|
|
discourse = handleTest ./discourse.nix {};
|
2020-02-01 23:59:02 +00:00
|
|
|
dnscrypt-proxy2 = handleTestOn ["x86_64-linux"] ./dnscrypt-proxy2.nix {};
|
2023-11-27 21:00:42 +00:00
|
|
|
dnsdist = import ./dnsdist.nix { inherit pkgs runTest; };
|
2020-04-14 03:13:36 +00:00
|
|
|
doas = handleTest ./doas.nix {};
|
2022-09-24 07:40:42 +00:00
|
|
|
docker = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker.nix {};
|
|
|
|
|
docker-rootless = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker-rootless.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
docker-registry = handleTest ./docker-registry.nix {};
|
|
|
|
|
docker-tools = handleTestOn ["x86_64-linux"] ./docker-tools.nix {};
|
2024-07-28 20:52:11 +00:00
|
|
|
docker-tools-nix-shell = runTest ./docker-tools-nix-shell.nix;
|
2020-12-12 23:33:46 +00:00
|
|
|
docker-tools-cross = handleTestOn ["x86_64-linux" "aarch64-linux"] ./docker-tools-cross.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
docker-tools-overlay = handleTestOn ["x86_64-linux"] ./docker-tools-overlay.nix {};
|
2019-03-26 18:04:28 +00:00
|
|
|
documize = handleTest ./documize.nix {};
|
2022-07-14 09:57:37 +00:00
|
|
|
documentation = pkgs.callPackage ../modules/misc/documentation/test.nix { inherit nixosLib; };
|
2022-01-23 11:11:05 +00:00
|
|
|
doh-proxy-rust = handleTest ./doh-proxy-rust.nix {};
|
2019-12-25 22:04:55 +00:00
|
|
|
dokuwiki = handleTest ./dokuwiki.nix {};
|
2022-11-01 13:02:39 +00:00
|
|
|
dolibarr = handleTest ./dolibarr.nix {};
|
2021-11-13 22:00:20 +00:00
|
|
|
domination = handleTest ./domination.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
dovecot = handleTest ./dovecot.nix {};
|
2023-12-23 21:53:20 +00:00
|
|
|
drawterm = discoverTests (import ./drawterm.nix);
|
2021-11-30 20:42:29 +00:00
|
|
|
drbd = handleTest ./drbd.nix {};
|
2024-03-13 18:42:18 +00:00
|
|
|
druid = handleTestOn [ "x86_64-linux" ] ./druid {};
|
2023-11-27 17:45:10 +00:00
|
|
|
dublin-traceroute = handleTest ./dublin-traceroute.nix {};
|
2022-03-24 07:34:09 +00:00
|
|
|
earlyoom = handleTestOn ["x86_64-linux"] ./earlyoom.nix {};
|
2023-04-25 11:07:08 +00:00
|
|
|
early-mount-options = handleTest ./early-mount-options.nix {};
|
2020-02-13 20:31:58 +00:00
|
|
|
ec2-config = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-config or {};
|
2018-11-11 11:30:07 +00:00
|
|
|
ec2-nixops = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-nixops or {};
|
|
|
|
|
ecryptfs = handleTest ./ecryptfs.nix {};
|
2022-05-17 18:16:22 +00:00
|
|
|
fscrypt = handleTest ./fscrypt.nix {};
|
2023-10-18 02:13:16 +00:00
|
|
|
fastnetmon-advanced = runTest ./fastnetmon-advanced.nix;
|
2024-07-03 09:24:22 +00:00
|
|
|
eintopf = handleTest ./eintopf.nix {};
|
2019-06-15 09:16:28 +00:00
|
|
|
ejabberd = handleTest ./xmpp/ejabberd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
elk = handleTestOn ["x86_64-linux"] ./elk.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
emacs-daemon = handleTest ./emacs-daemon.nix {};
|
2022-10-22 12:53:35 +00:00
|
|
|
endlessh = handleTest ./endlessh.nix {};
|
2022-09-23 20:39:38 +00:00
|
|
|
endlessh-go = handleTest ./endlessh-go.nix {};
|
2020-05-24 12:20:58 +00:00
|
|
|
engelsystem = handleTest ./engelsystem.nix {};
|
2020-05-02 14:28:50 +00:00
|
|
|
enlightenment = handleTest ./enlightenment.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
env = handleTest ./env.nix {};
|
2022-12-28 14:09:54 +00:00
|
|
|
envfs = handleTest ./envfs.nix {};
|
2021-08-28 02:28:27 +00:00
|
|
|
envoy = handleTest ./envoy.nix {};
|
2020-05-24 18:39:23 +00:00
|
|
|
ergo = handleTest ./ergo.nix {};
|
2022-01-12 20:47:27 +00:00
|
|
|
ergochat = handleTest ./ergochat.nix {};
|
2023-07-29 10:20:37 +00:00
|
|
|
eris-server = handleTest ./eris-server.nix {};
|
2023-03-22 21:48:59 +00:00
|
|
|
esphome = handleTest ./esphome.nix {};
|
2021-12-03 12:21:16 +00:00
|
|
|
etc = pkgs.callPackage ../modules/system/etc/test.nix { inherit evalMinimalConfig; };
|
2022-12-01 16:49:48 +00:00
|
|
|
activation = pkgs.callPackage ../modules/system/activation/test.nix { };
|
2024-07-16 18:25:06 +00:00
|
|
|
activation-lib = pkgs.callPackage ../modules/system/activation/lib/test.nix { };
|
2023-10-17 15:35:16 +00:00
|
|
|
activation-var = runTest ./activation/var.nix;
|
2023-10-17 19:39:51 +00:00
|
|
|
activation-nix-channel = runTest ./activation/nix-channel.nix;
|
2023-10-12 22:02:48 +00:00
|
|
|
activation-etc-overlay-mutable = runTest ./activation/etc-overlay-mutable.nix;
|
|
|
|
|
activation-etc-overlay-immutable = runTest ./activation/etc-overlay-immutable.nix;
|
2023-10-17 14:40:26 +00:00
|
|
|
activation-perlless = runTest ./activation/perlless.nix;
|
2024-02-14 14:45:02 +00:00
|
|
|
etcd = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./etcd/etcd.nix {};
|
|
|
|
|
etcd-cluster = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./etcd/etcd-cluster.nix {};
|
2021-03-28 21:49:45 +00:00
|
|
|
etebase-server = handleTest ./etebase-server.nix {};
|
2020-11-30 21:10:07 +00:00
|
|
|
etesync-dav = handleTest ./etesync-dav.nix {};
|
2021-07-27 13:14:24 +00:00
|
|
|
evcc = handleTest ./evcc.nix {};
|
2022-11-19 12:13:56 +00:00
|
|
|
fail2ban = handleTest ./fail2ban.nix { };
|
2023-06-18 00:59:06 +00:00
|
|
|
fakeroute = handleTest ./fakeroute.nix {};
|
2019-10-29 14:06:32 +00:00
|
|
|
fancontrol = handleTest ./fancontrol.nix {};
|
2023-07-25 17:45:54 +00:00
|
|
|
fanout = handleTest ./fanout.nix {};
|
2023-03-12 06:19:03 +00:00
|
|
|
fcitx5 = handleTest ./fcitx5 {};
|
2024-06-27 05:17:12 +00:00
|
|
|
fedimintd = runTest ./fedimintd.nix;
|
2022-01-23 11:11:05 +00:00
|
|
|
fenics = handleTest ./fenics.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
ferm = handleTest ./ferm.nix {};
|
2023-10-15 08:40:11 +00:00
|
|
|
ferretdb = handleTest ./ferretdb.nix {};
|
2024-05-21 16:27:45 +00:00
|
|
|
filesender = handleTest ./filesender.nix {};
|
2024-02-03 21:40:40 +00:00
|
|
|
filesystems-overlayfs = runTest ./filesystems-overlayfs.nix;
|
2024-04-06 15:37:34 +00:00
|
|
|
firefly-iii = handleTest ./firefly-iii.nix {};
|
2024-08-02 16:04:22 +00:00
|
|
|
firefly-iii-data-importer = handleTest ./firefly-iii-data-importer.nix {};
|
2021-08-09 09:57:57 +00:00
|
|
|
firefox = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox; };
|
2023-03-24 13:18:26 +00:00
|
|
|
firefox-beta = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-beta; };
|
2023-03-24 13:16:22 +00:00
|
|
|
firefox-devedition = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-devedition; };
|
2021-08-10 14:15:57 +00:00
|
|
|
firefox-esr = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr; }; # used in `tested` job
|
firefox-esr-115-unwrapped: init at 115.0esr
The next major version of the Firefox Extended Support Release.
https://www.mozilla.org/en-US/firefox/115.0/releasenotes/
https://www.mozilla.org/en-US/security/advisories/mfsa2023-22/
Fixes: CVE-2023-3482, CVE-2023-37201, CVE-2023-37202, CVE-2023-37203
CVE-2023-37204, CVE-2023-37205, CVE-2023-37206, CVE-2023-37207,
CVE-2023-37208, CVE-2023-37209, CVE-2023-37210, CVE-2023-37211,
CVE-2023-37211, CVE-2023-37212
2023-07-03 00:39:20 +00:00
|
|
|
firefox-esr-115 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-115; };
|
2024-07-08 17:39:05 +00:00
|
|
|
firefox-esr-128 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-128; };
|
2023-01-08 00:08:00 +00:00
|
|
|
firefoxpwa = handleTest ./firefoxpwa.nix {};
|
2020-08-07 16:45:20 +00:00
|
|
|
firejail = handleTest ./firejail.nix {};
|
2022-12-22 16:23:23 +00:00
|
|
|
firewall = handleTest ./firewall.nix { nftables = false; };
|
|
|
|
|
firewall-nftables = handleTest ./firewall.nix { nftables = true; };
|
2018-12-17 19:12:09 +00:00
|
|
|
fish = handleTest ./fish.nix {};
|
2019-02-12 17:26:08 +00:00
|
|
|
flannel = handleTestOn ["x86_64-linux"] ./flannel.nix {};
|
2024-07-05 20:06:17 +00:00
|
|
|
flaresolverr = handleTest ./flaresolverr.nix {};
|
2024-06-05 18:14:56 +00:00
|
|
|
flood = handleTest ./flood.nix {};
|
2023-10-23 08:22:11 +00:00
|
|
|
floorp = handleTest ./firefox.nix { firefoxPackage = pkgs.floorp; };
|
2019-07-29 15:35:27 +00:00
|
|
|
fluentd = handleTest ./fluentd.nix {};
|
2021-08-21 20:51:01 +00:00
|
|
|
fluidd = handleTest ./fluidd.nix {};
|
2019-08-29 12:02:20 +00:00
|
|
|
fontconfig-default-fonts = handleTest ./fontconfig-default-fonts.nix {};
|
2024-07-31 01:59:13 +00:00
|
|
|
forgejo = handleTest ./forgejo.nix { forgejoPackage = pkgs.forgejo; };
|
|
|
|
|
forgejo-lts = handleTest ./forgejo.nix { forgejoPackage = pkgs.forgejo-lts; };
|
2022-11-29 17:30:00 +00:00
|
|
|
freenet = handleTest ./freenet.nix {};
|
2020-01-07 14:53:34 +00:00
|
|
|
freeswitch = handleTest ./freeswitch.nix {};
|
2023-10-29 19:49:08 +00:00
|
|
|
freetube = discoverTests (import ./freetube.nix);
|
2024-07-01 18:46:05 +00:00
|
|
|
freshrss-extensions = handleTest ./freshrss-extensions.nix {};
|
2023-01-06 00:25:34 +00:00
|
|
|
freshrss-sqlite = handleTest ./freshrss-sqlite.nix {};
|
|
|
|
|
freshrss-pgsql = handleTest ./freshrss-pgsql.nix {};
|
2023-12-25 00:01:20 +00:00
|
|
|
freshrss-http-auth = handleTest ./freshrss-http-auth.nix {};
|
2024-04-14 14:10:51 +00:00
|
|
|
freshrss-none-auth = handleTest ./freshrss-none-auth.nix {};
|
2023-03-30 11:06:31 +00:00
|
|
|
frigate = handleTest ./frigate.nix {};
|
2023-09-13 13:24:47 +00:00
|
|
|
frp = handleTest ./frp.nix {};
|
2021-06-08 19:37:03 +00:00
|
|
|
frr = handleTest ./frr.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
fsck = handleTest ./fsck.nix {};
|
2022-12-21 04:05:02 +00:00
|
|
|
fsck-systemd-stage-1 = handleTest ./fsck.nix { systemdStage1 = true; };
|
2020-07-29 17:40:38 +00:00
|
|
|
ft2-clone = handleTest ./ft2-clone.nix {};
|
2023-05-24 12:48:02 +00:00
|
|
|
legit = handleTest ./legit.nix {};
|
2022-06-07 10:53:15 +00:00
|
|
|
mimir = handleTest ./mimir.nix {};
|
2024-05-03 08:35:19 +00:00
|
|
|
gancio = handleTest ./gancio.nix {};
|
2022-10-15 20:40:34 +00:00
|
|
|
garage = handleTest ./garage {};
|
2024-09-19 19:34:10 +00:00
|
|
|
gatus = runTest ./gatus.nix;
|
2022-08-11 10:10:58 +00:00
|
|
|
gemstash = handleTest ./gemstash.nix {};
|
2023-11-17 22:29:45 +00:00
|
|
|
geoserver = runTest ./geoserver.nix;
|
2020-03-05 21:11:28 +00:00
|
|
|
gerrit = handleTest ./gerrit.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
geth = handleTest ./geth.nix {};
|
2021-05-19 23:15:28 +00:00
|
|
|
ghostunnel = handleTest ./ghostunnel.nix {};
|
2020-02-26 13:05:00 +00:00
|
|
|
gitdaemon = handleTest ./gitdaemon.nix {};
|
2023-02-24 01:59:30 +00:00
|
|
|
gitea = handleTest ./gitea.nix { giteaPackage = pkgs.gitea; };
|
2023-02-26 12:50:49 +00:00
|
|
|
github-runner = handleTest ./github-runner.nix {};
|
2023-05-11 07:07:37 +00:00
|
|
|
gitlab = runTest ./gitlab.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
gitolite = handleTest ./gitolite.nix {};
|
2019-12-04 23:10:57 +00:00
|
|
|
gitolite-fcgiwrap = handleTest ./gitolite-fcgiwrap.nix {};
|
2024-07-01 07:32:41 +00:00
|
|
|
glance = runTest ./glance.nix;
|
2024-04-01 20:44:08 +00:00
|
|
|
glances = runTest ./glances.nix;
|
2019-08-16 23:28:43 +00:00
|
|
|
glusterfs = handleTest ./glusterfs.nix {};
|
2021-05-07 21:18:14 +00:00
|
|
|
gnome = handleTest ./gnome.nix {};
|
2023-10-15 13:57:54 +00:00
|
|
|
gnome-extensions = handleTest ./gnome-extensions.nix {};
|
2022-12-28 21:45:22 +00:00
|
|
|
gnome-flashback = handleTest ./gnome-flashback.nix {};
|
2021-05-07 21:18:14 +00:00
|
|
|
gnome-xorg = handleTest ./gnome-xorg.nix {};
|
2023-10-22 21:04:25 +00:00
|
|
|
gns3-server = handleTest ./gns3-server.nix {};
|
2023-02-02 17:17:40 +00:00
|
|
|
gnupg = handleTest ./gnupg.nix {};
|
2024-07-14 19:14:11 +00:00
|
|
|
goatcounter = handleTest ./goatcounter.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
go-neb = handleTest ./go-neb.nix {};
|
2021-04-09 14:57:33 +00:00
|
|
|
gobgpd = handleTest ./gobgpd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
gocd-agent = handleTest ./gocd-agent.nix {};
|
|
|
|
|
gocd-server = handleTest ./gocd-server.nix {};
|
2022-09-10 16:01:37 +00:00
|
|
|
gollum = handleTest ./gollum.nix {};
|
2022-12-21 00:08:48 +00:00
|
|
|
gonic = handleTest ./gonic.nix {};
|
2019-05-17 01:29:17 +00:00
|
|
|
google-oslogin = handleTest ./google-oslogin {};
|
2023-10-25 11:54:47 +00:00
|
|
|
goss = handleTest ./goss.nix {};
|
2024-07-11 07:07:40 +00:00
|
|
|
gotenberg = handleTest ./gotenberg.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
gotify-server = handleTest ./gotify-server.nix {};
|
2023-05-19 18:18:17 +00:00
|
|
|
gotosocial = runTest ./web-apps/gotosocial.nix;
|
2022-09-18 09:35:07 +00:00
|
|
|
grafana = handleTest ./grafana {};
|
2022-06-15 10:11:03 +00:00
|
|
|
grafana-agent = handleTest ./grafana-agent.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
graphite = handleTest ./graphite.nix {};
|
2019-07-09 00:01:43 +00:00
|
|
|
graylog = handleTest ./graylog.nix {};
|
2024-05-16 12:09:13 +00:00
|
|
|
greetd-no-shadow = handleTest ./greetd-no-shadow.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
grocy = handleTest ./grocy.nix {};
|
2023-10-16 16:58:19 +00:00
|
|
|
grow-partition = runTest ./grow-partition.nix;
|
2020-06-13 10:06:26 +00:00
|
|
|
grub = handleTest ./grub.nix {};
|
2023-06-16 17:12:42 +00:00
|
|
|
guacamole-server = handleTest ./guacamole-server.nix {};
|
2023-10-29 06:44:03 +00:00
|
|
|
guix = handleTest ./guix {};
|
2019-11-27 07:01:46 +00:00
|
|
|
gvisor = handleTest ./gvisor.nix {};
|
2022-01-08 13:08:34 +00:00
|
|
|
hadoop = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop; };
|
2024-06-24 03:55:57 +00:00
|
|
|
hadoop_3_3 = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop_3_3; };
|
2022-01-08 13:08:34 +00:00
|
|
|
hadoop2 = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop2; };
|
2022-01-23 11:11:05 +00:00
|
|
|
haka = handleTest ./haka.nix {};
|
2022-03-02 17:00:16 +00:00
|
|
|
haste-server = handleTest ./haste-server.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
haproxy = handleTest ./haproxy.nix {};
|
2019-01-06 13:04:41 +00:00
|
|
|
hardened = handleTest ./hardened.nix {};
|
2023-05-10 16:41:25 +00:00
|
|
|
harmonia = runTest ./harmonia.nix;
|
2022-12-01 15:47:24 +00:00
|
|
|
headscale = handleTest ./headscale.nix {};
|
2022-06-10 12:31:00 +00:00
|
|
|
healthchecks = handleTest ./web-apps/healthchecks.nix {};
|
2022-03-28 20:19:17 +00:00
|
|
|
hbase2 = handleTest ./hbase.nix { package=pkgs.hbase2; };
|
2024-06-24 13:29:06 +00:00
|
|
|
hbase_2_5 = handleTest ./hbase.nix { package=pkgs.hbase_2_5; };
|
2022-09-30 16:43:14 +00:00
|
|
|
hbase_2_4 = handleTest ./hbase.nix { package=pkgs.hbase_2_4; };
|
2022-03-28 20:19:17 +00:00
|
|
|
hbase3 = handleTest ./hbase.nix { package=pkgs.hbase3; };
|
2023-06-25 16:35:47 +00:00
|
|
|
hddfancontrol = handleTest ./hddfancontrol.nix {};
|
2020-11-29 17:51:50 +00:00
|
|
|
hedgedoc = handleTest ./hedgedoc.nix {};
|
2020-11-27 19:20:36 +00:00
|
|
|
herbstluftwm = handleTest ./herbstluftwm.nix {};
|
2024-06-15 13:25:40 +00:00
|
|
|
homebox = handleTest ./homebox.nix {};
|
2023-07-12 15:46:28 +00:00
|
|
|
homepage-dashboard = handleTest ./homepage-dashboard.nix {};
|
2023-08-17 16:08:48 +00:00
|
|
|
honk = runTest ./honk.nix;
|
2020-11-29 23:00:38 +00:00
|
|
|
installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});
|
2021-09-07 17:44:12 +00:00
|
|
|
invidious = handleTest ./invidious.nix {};
|
2024-04-21 21:58:48 +00:00
|
|
|
isolate = handleTest ./isolate.nix {};
|
2023-10-24 16:53:12 +00:00
|
|
|
livebook-service = handleTest ./livebook-service.nix {};
|
2023-12-24 21:23:15 +00:00
|
|
|
pyload = handleTest ./pyload.nix {};
|
2022-09-24 05:58:01 +00:00
|
|
|
oci-containers = handleTestOn ["aarch64-linux" "x86_64-linux"] ./oci-containers.nix {};
|
2021-11-02 00:48:47 +00:00
|
|
|
odoo = handleTest ./odoo.nix {};
|
2024-10-10 19:43:06 +00:00
|
|
|
odoo17 = handleTest ./odoo.nix { package = pkgs.odoo17; };
|
2024-06-19 13:35:20 +00:00
|
|
|
odoo16 = handleTest ./odoo.nix { package = pkgs.odoo16; };
|
2023-08-24 20:04:40 +00:00
|
|
|
odoo15 = handleTest ./odoo.nix { package = pkgs.odoo15; };
|
2020-03-26 13:33:57 +00:00
|
|
|
# 9pnet_virtio used to mount /nix partition doesn't support
|
|
|
|
|
# hibernation. This test happens to work on x86_64-linux but
|
|
|
|
|
# not on other platforms.
|
|
|
|
|
hibernate = handleTestOn ["x86_64-linux"] ./hibernate.nix {};
|
2022-04-13 11:48:20 +00:00
|
|
|
hibernate-systemd-stage-1 = handleTestOn ["x86_64-linux"] ./hibernate.nix { systemdStage1 = true; };
|
2018-11-11 11:30:07 +00:00
|
|
|
hitch = handleTest ./hitch {};
|
2020-01-20 11:34:57 +00:00
|
|
|
hledger-web = handleTest ./hledger-web.nix {};
|
2021-07-18 07:51:49 +00:00
|
|
|
hockeypuck = handleTest ./hockeypuck.nix { };
|
2018-11-11 11:30:07 +00:00
|
|
|
home-assistant = handleTest ./home-assistant.nix {};
|
2020-05-12 21:48:27 +00:00
|
|
|
hostname = handleTest ./hostname.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
hound = handleTest ./hound.nix {};
|
2020-12-29 16:13:26 +00:00
|
|
|
hub = handleTest ./git/hub.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
hydra = handleTest ./hydra {};
|
|
|
|
|
i3wm = handleTest ./i3wm.nix {};
|
2019-07-07 01:03:59 +00:00
|
|
|
icingaweb2 = handleTest ./icingaweb2.nix {};
|
2024-07-18 15:17:36 +00:00
|
|
|
ifm = handleTest ./ifm.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
iftop = handleTest ./iftop.nix {};
|
2024-07-02 19:18:19 +00:00
|
|
|
immich = handleTest ./web-apps/immich.nix {};
|
2018-11-14 22:51:15 +00:00
|
|
|
incron = handleTest ./incron.nix {};
|
2024-05-09 14:03:07 +00:00
|
|
|
incus = pkgs.recurseIntoAttrs (handleTest ./incus { inherit handleTestOn; inherit (pkgs) incus; });
|
|
|
|
|
incus-lts = pkgs.recurseIntoAttrs (handleTest ./incus { inherit handleTestOn; });
|
2018-11-11 11:30:07 +00:00
|
|
|
influxdb = handleTest ./influxdb.nix {};
|
2023-08-14 22:26:41 +00:00
|
|
|
influxdb2 = handleTest ./influxdb2.nix {};
|
2023-12-20 09:23:08 +00:00
|
|
|
initrd-network-openvpn = handleTestOn [ "x86_64-linux" "i686-linux" ] ./initrd-network-openvpn {};
|
2020-11-29 23:00:38 +00:00
|
|
|
initrd-network-ssh = handleTest ./initrd-network-ssh {};
|
2023-03-22 14:17:23 +00:00
|
|
|
initrd-luks-empty-passphrase = handleTest ./initrd-luks-empty-passphrase.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
initrdNetwork = handleTest ./initrd-network.nix {};
|
2020-12-12 13:39:58 +00:00
|
|
|
initrd-secrets = handleTest ./initrd-secrets.nix {};
|
nixos/grub: Name initrd-secrets by system, not by initrd
Previously, secrets were named according to the initrd they were
associated with. This created a problem: If secrets were changed whilst
the initrd remained the same, there were two versions of the secrets
with one initrd. The result was that only one version of the secrets would
by recorded into the /boot partition and get used. AFAICT this would
only be the oldest version of the secrets for the given initrd version.
This manifests as #114594, which I found frustrating while trying to use
initrd secrets for the first time. While developing the secrets I found
I could not get new versions of the secrets to take effect.
Additionally, it's a nasty issue to run into if you had cause to change
the initrd secrets for credential rotation, etc, if you change them and
discover you cannot, or alternatively that you can't roll back as you
would expect.
Additional changes in this patch.
* Add a regression test that switching to another grub configuration
with the alternate secrets works. This test relies on the fact that it
is not changing the initrd. I have checked that the test fails if I
undo my change.
* Persist the useBootLoader disk state, similarly to other boot state.
* I had to do this, otherwise I could not find a route to testing the
alternate boot configuration. I did attempt a few different ways of
testing this, including directly running install-grub.pl, but what
I've settled on is most like what a user would do and avoids
depending on lots of internal details.
* Making tests that test the boot are a bit tricky (see hibernate.nix
and installer.nix for inspiration), I found that in addition to
having to copy quite a bit of code I still couldn't get things to
work as desired since the bootloader state was being clobbered.
My change to persist the useBootLoader state could break things,
conceptually. I need some help here discovering if that is the case,
possibly by letting this run through a staging CI if there is one.
Fix #114594.
cc potential reviewers:
@lopsided98 (original implementer) @joachifm (original reviewer),
@wkennington (numerous fixes to grub-install.pl), @lheckemann (wrote
original secrets test).
2023-01-05 12:28:32 +00:00
|
|
|
initrd-secrets-changing = handleTest ./initrd-secrets-changing.nix {};
|
2022-02-18 21:47:54 +00:00
|
|
|
input-remapper = handleTest ./input-remapper.nix {};
|
2021-03-22 13:32:46 +00:00
|
|
|
inspircd = handleTest ./inspircd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
installer = handleTest ./installer.nix {};
|
2022-04-17 21:24:13 +00:00
|
|
|
installer-systemd-stage-1 = handleTest ./installer-systemd-stage-1.nix {};
|
2023-03-17 08:39:03 +00:00
|
|
|
intune = handleTest ./intune.nix {};
|
2022-01-20 13:45:35 +00:00
|
|
|
invoiceplane = handleTest ./invoiceplane.nix {};
|
2020-02-02 12:00:00 +00:00
|
|
|
iodine = handleTest ./iodine.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
ipv6 = handleTest ./ipv6.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
iscsi-multipath-root = handleTest ./iscsi-multipath-root.nix {};
|
2020-10-18 17:55:42 +00:00
|
|
|
iscsi-root = handleTest ./iscsi-root.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
isso = handleTest ./isso.nix {};
|
2019-01-25 06:09:36 +00:00
|
|
|
jackett = handleTest ./jackett.nix {};
|
2019-05-01 09:57:34 +00:00
|
|
|
jellyfin = handleTest ./jellyfin.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
jenkins = handleTest ./jenkins.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
jenkins-cli = handleTest ./jenkins-cli.nix {};
|
2021-10-15 18:00:24 +00:00
|
|
|
jibri = handleTest ./jibri.nix {};
|
2020-02-06 16:00:19 +00:00
|
|
|
jirafeau = handleTest ./jirafeau.nix {};
|
2020-03-18 03:23:15 +00:00
|
|
|
jitsi-meet = handleTest ./jitsi-meet.nix {};
|
2023-07-01 16:50:08 +00:00
|
|
|
jool = import ./jool.nix { inherit pkgs runTest; };
|
2024-04-06 08:02:46 +00:00
|
|
|
jotta-cli = handleTest ./jotta-cli.nix {};
|
2022-07-22 06:13:20 +00:00
|
|
|
k3s = handleTest ./k3s {};
|
2019-04-01 12:39:25 +00:00
|
|
|
kafka = handleTest ./kafka.nix {};
|
2022-05-05 10:09:42 +00:00
|
|
|
kanidm = handleTest ./kanidm.nix {};
|
2024-03-10 20:32:24 +00:00
|
|
|
kanidm-provisioning = handleTest ./kanidm-provisioning.nix {};
|
2022-10-10 05:16:25 +00:00
|
|
|
karma = handleTest ./karma.nix {};
|
2023-04-30 03:27:25 +00:00
|
|
|
kavita = handleTest ./kavita.nix {};
|
2021-05-30 18:37:14 +00:00
|
|
|
kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};
|
2021-07-19 19:21:02 +00:00
|
|
|
kbd-update-search-paths-patch = handleTest ./kbd-update-search-paths-patch.nix {};
|
2021-07-13 22:43:17 +00:00
|
|
|
kea = handleTest ./kea.nix {};
|
2019-12-22 07:45:31 +00:00
|
|
|
keepalived = handleTest ./keepalived.nix {};
|
2021-02-02 11:35:46 +00:00
|
|
|
keepassxc = handleTest ./keepassxc.nix {};
|
2019-01-11 04:36:51 +00:00
|
|
|
kerberos = handleTest ./kerberos/default.nix {};
|
2021-04-07 15:57:58 +00:00
|
|
|
kernel-generic = handleTest ./kernel-generic.nix {};
|
2021-01-31 13:55:53 +00:00
|
|
|
kernel-latest-ath-user-regd = handleTest ./kernel-latest-ath-user-regd.nix {};
|
2024-03-27 15:15:37 +00:00
|
|
|
kernel-rust = handleTest ./kernel-rust.nix {};
|
2022-05-18 13:41:54 +00:00
|
|
|
keter = handleTest ./keter.nix {};
|
2021-10-24 22:20:46 +00:00
|
|
|
kexec = handleTest ./kexec.nix {};
|
2020-10-26 14:33:57 +00:00
|
|
|
keycloak = discoverTests (import ./keycloak.nix);
|
2023-03-15 13:15:38 +00:00
|
|
|
keyd = handleTest ./keyd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
keymap = handleTest ./keymap.nix {};
|
2024-11-01 22:50:17 +00:00
|
|
|
kimai = handleTest ./kimai.nix {};
|
2019-03-13 00:12:56 +00:00
|
|
|
knot = handleTest ./knot.nix {};
|
2022-08-12 21:52:52 +00:00
|
|
|
komga = handleTest ./komga.nix {};
|
2023-12-24 04:40:56 +00:00
|
|
|
krb5 = discoverTests (import ./krb5);
|
2021-02-26 12:06:18 +00:00
|
|
|
ksm = handleTest ./ksm.nix {};
|
2022-09-25 18:46:03 +00:00
|
|
|
kthxbye = handleTest ./kthxbye.nix {};
|
2021-07-30 15:16:23 +00:00
|
|
|
kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};
|
2023-10-08 16:56:05 +00:00
|
|
|
kubo = import ./kubo { inherit recurseIntoAttrs runTest; };
|
2022-08-16 13:03:37 +00:00
|
|
|
ladybird = handleTest ./ladybird.nix {};
|
2022-08-16 18:33:08 +00:00
|
|
|
languagetool = handleTest ./languagetool.nix {};
|
2023-09-17 15:12:55 +00:00
|
|
|
lanraragi = handleTest ./lanraragi.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
latestKernel.login = handleTest ./login.nix { latestKernel = true; };
|
|
|
|
|
leaps = handleTest ./leaps.nix {};
|
2022-09-02 09:02:51 +00:00
|
|
|
lemmy = handleTest ./lemmy.nix {};
|
2021-11-15 11:46:20 +00:00
|
|
|
libinput = handleTest ./libinput.nix {};
|
2023-10-05 14:09:58 +00:00
|
|
|
librenms = handleTest ./librenms.nix {};
|
2021-11-18 18:10:48 +00:00
|
|
|
libresprite = handleTest ./libresprite.nix {};
|
2024-05-09 18:22:57 +00:00
|
|
|
libreswan = runTest ./libreswan.nix;
|
2024-05-09 18:24:56 +00:00
|
|
|
libreswan-nat = runTest ./libreswan-nat.nix;
|
2022-07-09 00:40:24 +00:00
|
|
|
librewolf = handleTest ./firefox.nix { firefoxPackage = pkgs.librewolf; };
|
2022-07-15 20:00:28 +00:00
|
|
|
libuiohook = handleTest ./libuiohook.nix {};
|
2022-08-22 03:17:06 +00:00
|
|
|
libvirtd = handleTest ./libvirtd.nix {};
|
2021-11-15 11:46:20 +00:00
|
|
|
lidarr = handleTest ./lidarr.nix {};
|
2019-08-06 22:29:50 +00:00
|
|
|
lightdm = handleTest ./lightdm.nix {};
|
2022-07-24 15:04:12 +00:00
|
|
|
lighttpd = handleTest ./lighttpd.nix {};
|
2019-03-16 12:24:23 +00:00
|
|
|
limesurvey = handleTest ./limesurvey.nix {};
|
2023-08-23 15:50:28 +00:00
|
|
|
listmonk = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./listmonk.nix {};
|
2021-07-30 15:41:54 +00:00
|
|
|
litestream = handleTest ./litestream.nix {};
|
2023-04-27 13:26:57 +00:00
|
|
|
lldap = handleTest ./lldap.nix {};
|
2024-05-12 22:07:22 +00:00
|
|
|
localsend = handleTest ./localsend.nix {};
|
2020-11-24 01:53:21 +00:00
|
|
|
locate = handleTest ./locate.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
login = handleTest ./login.nix {};
|
2022-02-11 08:49:52 +00:00
|
|
|
logrotate = handleTest ./logrotate.nix {};
|
2019-06-27 16:11:09 +00:00
|
|
|
loki = handleTest ./loki.nix {};
|
2023-02-20 07:19:02 +00:00
|
|
|
luks = handleTest ./luks.nix {};
|
2022-02-01 17:21:11 +00:00
|
|
|
lvm2 = handleTest ./lvm2 {};
|
2024-05-08 11:52:25 +00:00
|
|
|
lxc = handleTest ./lxc {};
|
2023-09-04 19:19:34 +00:00
|
|
|
lxd = pkgs.recurseIntoAttrs (handleTest ./lxd { inherit handleTestOn; });
|
2021-10-20 21:39:53 +00:00
|
|
|
lxd-image-server = handleTest ./lxd-image-server.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
#logstash = handleTest ./logstash.nix {};
|
2024-08-05 21:12:50 +00:00
|
|
|
lomiri = discoverTests (import ./lomiri.nix);
|
2024-06-19 14:23:11 +00:00
|
|
|
lomiri-calculator-app = runTest ./lomiri-calculator-app.nix;
|
2024-07-24 17:18:05 +00:00
|
|
|
lomiri-camera-app = runTest ./lomiri-camera-app.nix;
|
2024-06-29 19:24:57 +00:00
|
|
|
lomiri-clock-app = runTest ./lomiri-clock-app.nix;
|
2024-08-24 21:09:29 +00:00
|
|
|
lomiri-docviewer-app = runTest ./lomiri-docviewer-app.nix;
|
2024-06-07 09:37:49 +00:00
|
|
|
lomiri-filemanager-app = runTest ./lomiri-filemanager-app.nix;
|
2024-08-14 13:26:08 +00:00
|
|
|
lomiri-gallery-app = runTest ./lomiri-gallery-app.nix;
|
2024-02-15 08:59:39 +00:00
|
|
|
lomiri-system-settings = handleTest ./lomiri-system-settings.nix {};
|
2019-11-05 10:57:05 +00:00
|
|
|
lorri = handleTest ./lorri/default.nix {};
|
2024-03-20 08:48:22 +00:00
|
|
|
ly = handleTest ./ly.nix {};
|
2023-04-21 06:59:13 +00:00
|
|
|
maddy = discoverTests (import ./maddy { inherit handleTest; });
|
2022-04-01 02:41:31 +00:00
|
|
|
maestral = handleTest ./maestral.nix {};
|
2020-03-30 11:30:05 +00:00
|
|
|
magic-wormhole-mailbox-server = handleTest ./magic-wormhole-mailbox-server.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
magnetico = handleTest ./magnetico.nix {};
|
2019-03-27 11:35:24 +00:00
|
|
|
mailcatcher = handleTest ./mailcatcher.nix {};
|
2020-12-17 15:58:57 +00:00
|
|
|
mailhog = handleTest ./mailhog.nix {};
|
2024-07-24 13:48:20 +00:00
|
|
|
mailpit = handleTest ./mailpit.nix {};
|
2023-02-09 17:56:56 +00:00
|
|
|
mailman = handleTest ./mailman.nix {};
|
2021-09-24 18:54:08 +00:00
|
|
|
man = handleTest ./man.nix {};
|
2021-12-08 09:47:07 +00:00
|
|
|
mariadb-galera = handleTest ./mysql/mariadb-galera.nix {};
|
2024-07-04 16:07:44 +00:00
|
|
|
mastodon = pkgs.recurseIntoAttrs (handleTest ./web-apps/mastodon { inherit handleTestOn; });
|
2023-03-25 16:02:52 +00:00
|
|
|
pixelfed = discoverTests (import ./web-apps/pixelfed { inherit handleTestOn; });
|
2023-01-08 15:44:00 +00:00
|
|
|
mate = handleTest ./mate.nix {};
|
2024-03-12 14:29:08 +00:00
|
|
|
mate-wayland = handleTest ./mate-wayland.nix {};
|
2023-10-29 03:16:44 +00:00
|
|
|
matter-server = handleTest ./matter-server.nix {};
|
2019-10-04 20:38:58 +00:00
|
|
|
matomo = handleTest ./matomo.nix {};
|
2024-09-04 18:35:52 +00:00
|
|
|
matrix-appservice-irc = runTest ./matrix/appservice-irc.nix;
|
2022-05-13 07:46:01 +00:00
|
|
|
matrix-conduit = handleTest ./matrix/conduit.nix {};
|
|
|
|
|
matrix-synapse = handleTest ./matrix/synapse.nix {};
|
2023-07-07 09:27:55 +00:00
|
|
|
matrix-synapse-workers = handleTest ./matrix/synapse-workers.nix {};
|
2024-03-17 17:56:18 +00:00
|
|
|
mautrix-meta-postgres = handleTest ./matrix/mautrix-meta-postgres.nix {};
|
|
|
|
|
mautrix-meta-sqlite = handleTest ./matrix/mautrix-meta-sqlite.nix {};
|
2021-04-12 01:29:29 +00:00
|
|
|
mattermost = handleTest ./mattermost.nix {};
|
2024-02-01 07:30:57 +00:00
|
|
|
mealie = handleTest ./mealie.nix {};
|
2023-08-10 18:43:26 +00:00
|
|
|
mediamtx = handleTest ./mediamtx.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
mediatomb = handleTest ./mediatomb.nix {};
|
2019-06-06 01:19:11 +00:00
|
|
|
mediawiki = handleTest ./mediawiki.nix {};
|
2020-04-07 09:00:43 +00:00
|
|
|
meilisearch = handleTest ./meilisearch.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
memcached = handleTest ./memcached.nix {};
|
2022-10-19 08:49:57 +00:00
|
|
|
merecat = handleTest ./merecat.nix {};
|
2019-08-18 07:28:16 +00:00
|
|
|
metabase = handleTest ./metabase.nix {};
|
2024-02-10 14:43:17 +00:00
|
|
|
mihomo = handleTest ./mihomo.nix {};
|
2023-01-14 23:28:32 +00:00
|
|
|
mindustry = handleTest ./mindustry.nix {};
|
2020-11-28 17:42:10 +00:00
|
|
|
minecraft = handleTest ./minecraft.nix {};
|
2020-11-28 17:42:46 +00:00
|
|
|
minecraft-server = handleTest ./minecraft-server.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
minidlna = handleTest ./minidlna.nix {};
|
2018-12-21 18:36:58 +00:00
|
|
|
miniflux = handleTest ./miniflux.nix {};
|
2019-02-05 16:38:34 +00:00
|
|
|
minio = handleTest ./minio.nix {};
|
2024-06-10 13:55:54 +00:00
|
|
|
miracle-wm = runTest ./miracle-wm.nix;
|
2023-02-04 01:23:14 +00:00
|
|
|
miriway = handleTest ./miriway.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
misc = handleTest ./misc.nix {};
|
2024-06-12 15:34:42 +00:00
|
|
|
misskey = handleTest ./misskey.nix {};
|
2021-05-30 15:33:09 +00:00
|
|
|
mjolnir = handleTest ./matrix/mjolnir.nix {};
|
2023-09-05 15:53:09 +00:00
|
|
|
mobilizon = handleTest ./mobilizon.nix {};
|
2021-08-13 18:55:15 +00:00
|
|
|
mod_perl = handleTest ./mod_perl.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
molly-brown = handleTest ./molly-brown.nix {};
|
2024-01-05 11:10:12 +00:00
|
|
|
mollysocket = handleTest ./mollysocket.nix { };
|
2023-12-18 16:48:48 +00:00
|
|
|
monado = handleTest ./monado.nix {};
|
2024-03-19 20:54:05 +00:00
|
|
|
monetdb = handleTest ./monetdb.nix {};
|
2023-04-16 09:21:57 +00:00
|
|
|
monica = handleTest ./web-apps/monica.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
mongodb = handleTest ./mongodb.nix {};
|
2019-06-21 14:09:15 +00:00
|
|
|
moodle = handleTest ./moodle.nix {};
|
2022-03-22 22:35:39 +00:00
|
|
|
moonraker = handleTest ./moonraker.nix {};
|
2024-02-22 09:36:50 +00:00
|
|
|
morph-browser = handleTest ./morph-browser.nix { };
|
2018-11-11 11:30:07 +00:00
|
|
|
morty = handleTest ./morty.nix {};
|
2019-04-24 08:23:13 +00:00
|
|
|
mosquitto = handleTest ./mosquitto.nix {};
|
2021-10-06 19:51:07 +00:00
|
|
|
moosefs = handleTest ./moosefs.nix {};
|
2024-03-22 16:49:50 +00:00
|
|
|
movim = discoverTests (import ./web-apps/movim { inherit handleTestOn; });
|
2018-11-11 11:30:07 +00:00
|
|
|
mpd = handleTest ./mpd.nix {};
|
2021-07-31 22:44:02 +00:00
|
|
|
mpv = handleTest ./mpv.nix {};
|
2021-11-15 05:58:12 +00:00
|
|
|
mtp = handleTest ./mtp.nix {};
|
2023-02-03 09:28:48 +00:00
|
|
|
multipass = handleTest ./multipass.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
mumble = handleTest ./mumble.nix {};
|
2023-02-04 10:16:53 +00:00
|
|
|
# Fails on aarch64-linux at the PDF creation step - need to debug this on an
|
|
|
|
|
# aarch64 machine..
|
|
|
|
|
musescore = handleTestOn ["x86_64-linux"] ./musescore.nix {};
|
2024-05-17 23:10:54 +00:00
|
|
|
music-assistant = runTest ./music-assistant.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
munin = handleTest ./munin.nix {};
|
|
|
|
|
mutableUsers = handleTest ./mutable-users.nix {};
|
2024-03-18 16:40:30 +00:00
|
|
|
mycelium = handleTest ./mycelium {};
|
2023-12-18 21:31:29 +00:00
|
|
|
mympd = handleTest ./mympd.nix {};
|
2020-04-02 20:40:55 +00:00
|
|
|
mysql = handleTest ./mysql/mysql.nix {};
|
|
|
|
|
mysql-autobackup = handleTest ./mysql/mysql-autobackup.nix {};
|
|
|
|
|
mysql-backup = handleTest ./mysql/mysql-backup.nix {};
|
|
|
|
|
mysql-replication = handleTest ./mysql/mysql-replication.nix {};
|
2020-11-28 17:00:25 +00:00
|
|
|
n8n = handleTest ./n8n.nix {};
|
2024-05-03 18:40:22 +00:00
|
|
|
nagios = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./nagios.nix {};
|
2020-11-06 17:59:51 +00:00
|
|
|
nar-serve = handleTest ./nar-serve.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
nat.firewall = handleTest ./nat.nix { withFirewall = true; };
|
|
|
|
|
nat.standalone = handleTest ./nat.nix { withFirewall = false; };
|
2022-12-22 16:23:23 +00:00
|
|
|
nat.nftables.firewall = handleTest ./nat.nix { withFirewall = true; nftables = true; };
|
|
|
|
|
nat.nftables.standalone = handleTest ./nat.nix { withFirewall = false; nftables = true; };
|
2021-06-26 11:58:40 +00:00
|
|
|
nats = handleTest ./nats.nix {};
|
2020-12-05 18:11:21 +00:00
|
|
|
navidrome = handleTest ./navidrome.nix {};
|
2022-03-06 13:49:57 +00:00
|
|
|
nbd = handleTest ./nbd.nix {};
|
2020-06-07 21:59:12 +00:00
|
|
|
ncdns = handleTest ./ncdns.nix {};
|
2019-02-03 15:47:01 +00:00
|
|
|
ndppd = handleTest ./ndppd.nix {};
|
2024-07-16 20:00:16 +00:00
|
|
|
nix-channel = pkgs.callPackage ../modules/config/nix-channel/test.nix { };
|
2021-03-05 05:28:58 +00:00
|
|
|
nebula = handleTest ./nebula.nix {};
|
2022-08-14 16:59:15 +00:00
|
|
|
netbird = handleTest ./netbird.nix {};
|
2024-03-16 18:13:51 +00:00
|
|
|
nimdow = handleTest ./nimdow.nix {};
|
2019-02-01 13:29:54 +00:00
|
|
|
neo4j = handleTest ./neo4j.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
netdata = handleTest ./netdata.nix {};
|
2024-03-16 20:05:56 +00:00
|
|
|
networking.scripted = handleTest ./networking/networkd-and-scripted.nix { networkd = false; };
|
|
|
|
|
networking.networkd = handleTest ./networking/networkd-and-scripted.nix { networkd = true; };
|
2024-03-01 00:38:35 +00:00
|
|
|
networking.networkmanager = handleTest ./networking/networkmanager.nix {};
|
2023-09-24 08:06:08 +00:00
|
|
|
netbox_3_6 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_6; };
|
2024-01-22 15:17:57 +00:00
|
|
|
netbox_3_7 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_7; };
|
2024-08-02 08:58:19 +00:00
|
|
|
netbox_4_0 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_4_0; };
|
2024-10-07 14:14:33 +00:00
|
|
|
netbox_4_1 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_4_1; };
|
2023-07-31 12:56:05 +00:00
|
|
|
netbox-upgrade = handleTest ./web-apps/netbox-upgrade.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
# TODO: put in networking.nix after the test becomes more complete
|
|
|
|
|
networkingProxy = handleTest ./networking-proxy.nix {};
|
|
|
|
|
nextcloud = handleTest ./nextcloud {};
|
2024-09-30 09:15:23 +00:00
|
|
|
nextflow = handleTestOn ["x86_64-linux"] ./nextflow.nix {};
|
2024-05-20 12:54:08 +00:00
|
|
|
nextjs-ollama-llm-ui = runTest ./web-apps/nextjs-ollama-llm-ui.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
nexus = handleTest ./nexus.nix {};
|
2019-11-27 14:37:27 +00:00
|
|
|
# TODO: Test nfsv3 + Kerberos
|
|
|
|
|
nfs3 = handleTest ./nfs { version = 3; };
|
|
|
|
|
nfs4 = handleTest ./nfs { version = 4; };
|
2018-11-11 11:30:07 +00:00
|
|
|
nghttpx = handleTest ./nghttpx.nix {};
|
|
|
|
|
nginx = handleTest ./nginx.nix {};
|
2020-10-20 16:05:41 +00:00
|
|
|
nginx-auth = handleTest ./nginx-auth.nix {};
|
nginx: Clear Last-Modified if ETag is from store
This is what I've suspected a while ago[1]:
> Heads-up everyone: After testing this in a few production instances,
> it seems that some browsers still get cache hits for new store paths
> (and changed contents) for some reason. I highly suspect that it might
> be due to the last-modified header (as mentioned in [2]).
>
> Going to test this with last-modified disabled for a little while and
> if this is the case I think we should improve that patch by disabling
> last-modified if serving from a store path.
Much earlier[2] when I reviewed the patch, I wrote this:
> Other than that, it looks good to me.
>
> However, I'm not sure what we should do with Last-Modified header.
> From RFC 2616, section 13.3.4:
>
> - If both an entity tag and a Last-Modified value have been
> provided by the origin server, SHOULD use both validators in
> cache-conditional requests. This allows both HTTP/1.0 and
> HTTP/1.1 caches to respond appropriately.
>
> I'm a bit nervous about the SHOULD here, as user agents in the wild
> could possibly just use Last-Modified and use the cached content
> instead.
Unfortunately, I didn't pursue this any further back then because
@pbogdan noted[3] the following:
> Hmm, could they (assuming they are conforming):
>
> * If an entity tag has been provided by the origin server, MUST
> use that entity tag in any cache-conditional request (using If-
> Match or If-None-Match).
Since running with this patch in some deployments, I found that both
Firefox and Chrome/Chromium do NOT re-validate against the ETag if the
Last-Modified header is still the same.
So I wrote a small NixOS VM test with Geckodriver to have a test case
which is closer to the real world and I indeed was able to reproduce
this.
Whether this is actually a bug in Chrome or Firefox is an entirely
different issue and even IF it is the fault of the browsers and it is
fixed at some point, we'd still need to handle this for older browser
versions.
Apart from clearing the header, I also recreated the patch by using a
plain "git diff" with a small description on top. This should make it
easier for future authors to work on that patch.
[1]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-495072764
[2]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-451644084
[3]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-451646135
Signed-off-by: aszlig <aszlig@nix.build>
2019-12-30 13:06:00 +00:00
|
|
|
nginx-etag = handleTest ./nginx-etag.nix {};
|
nginx: change etags for statically compressed files served from store
Per RFC 9110, [section 8.8.1][1], different representations of the same
resource should have different Etags:
> A strong validator is unique across all versions of all
> representations associated with a particular resource over time.
> However, there is no implication of uniqueness across representations
> of different resources (i.e., the same strong validator might be in
> use for representations of multiple resources at the same time and
> does not imply that those representations are equivalent)
When serving statically compressed files (ie, when there is an existing
corresponding .gz/.br/etc. file on disk), Nginx sends the Etag marked
as strong. These tags should be different for each compressed format
(as shown in an explicit example in section [8.8.3.3][2] of the RFC).
Upstream Etags are composed of the file modification timestamp and
content length, and the latter generally changes between these
representations.
Previous implementation of Nix-specific Etags for things served from
store used the store hash. This is fine to share between different
files, but it becomes a problem for statically compressed versions of
the same file, as it means Nginx was serving different representations
of the same resource with the same Etag, marked as strong.
This patch addresses this by imitating the upstream Nginx behavior, and
appending the value of content length to the store hash.
[1]: https://www.rfc-editor.org/rfc/rfc9110.html#name-validator-fields
[2]:
https://www.rfc-editor.org/rfc/rfc9110.html#name-example-entity-tags-varying
2024-01-02 19:29:15 +00:00
|
|
|
nginx-etag-compression = handleTest ./nginx-etag-compression.nix {};
|
2022-12-03 17:58:33 +00:00
|
|
|
nginx-globalredirect = handleTest ./nginx-globalredirect.nix {};
|
2022-04-18 10:22:39 +00:00
|
|
|
nginx-http3 = handleTest ./nginx-http3.nix {};
|
2024-09-25 17:55:38 +00:00
|
|
|
nginx-mime = handleTest ./nginx-mime.nix {};
|
2022-02-14 23:10:37 +00:00
|
|
|
nginx-modsecurity = handleTest ./nginx-modsecurity.nix {};
|
2024-01-15 16:25:21 +00:00
|
|
|
nginx-moreheaders = handleTest ./nginx-moreheaders.nix {};
|
2022-09-18 12:54:04 +00:00
|
|
|
nginx-njs = handleTest ./nginx-njs.nix {};
|
2023-07-28 18:30:43 +00:00
|
|
|
nginx-proxyprotocol = handleTest ./nginx-proxyprotocol {};
|
nginx: Fix ETag patch to ignore realpath(3) error
While our ETag patch works pretty fine if it comes to serving data off
store paths, it unfortunately broke something that might be a bit more
common, namely when using regexes to extract path components of
location directives for example.
Recently, @devhell has reported a bug with a nginx location directive
like this:
location ~^/\~([a-z0-9_]+)(/.*)?$" {
alias /home/$1/public_html$2;
}
While this might look harmless at first glance, it does however cause
issues with our ETag patch. The alias directive gets broken up by nginx
like this:
*2 http script copy: "/home/"
*2 http script capture: "foo"
*2 http script copy: "/public_html/"
*2 http script capture: "bar.txt"
In our patch however, we use realpath(3) to get the canonicalised path
from ngx_http_core_loc_conf_s.root, which returns the *configured* value
from the root or alias directive. So in the example above, realpath(3)
boils down to the following syscalls:
lstat("/home", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
lstat("/home/$1", 0x7ffd08da6f60) = -1 ENOENT (No such file or directory)
During my review[1] of the initial patch, I didn't actually notice that
what we're doing here is returning NGX_ERROR if the realpath(3) call
fails, which in turn causes an HTTP 500 error.
Since our patch actually made the canonicalisation (and thus additional
syscalls) necessary, we really shouldn't introduce an additional error
so let's - at least for now - silently skip return value if realpath(3)
has failed.
However since we're using the unaltered root from the config we have
another issue, consider this root:
/nix/store/...-abcde/$1
Calling realpath(3) on this path will fail (except if there's a file
called "$1" of course), so even this fix is not enough because it
results in the ETag not being set to the store path hash.
While this is very ugly and we should fix this very soon, it's not as
serious as getting HTTP 500 errors for serving static files.
I added a small NixOS VM test, which uses the example above as a
regression test.
It seems that my memory is failing these days, since apparently I *knew*
about this issue since digging for existing issues in nixpkgs, I found
this similar pull request which I even reviewed:
https://github.com/NixOS/nixpkgs/pull/66532
However, since the comments weren't addressed and the author hasn't
responded to the pull request, I decided to keep this very commit and do
a follow-up pull request.
[1]: https://github.com/NixOS/nixpkgs/pull/48337
Signed-off-by: aszlig <aszlig@nix.build>
Reported-by: @devhell
Acked-by: @7c6f434c
Acked-by: @yorickvP
Merges: https://github.com/NixOS/nixpkgs/pull/80671
Fixes: https://github.com/NixOS/nixpkgs/pull/66532
2020-02-20 19:43:42 +00:00
|
|
|
nginx-pubhtml = handleTest ./nginx-pubhtml.nix {};
|
2023-12-01 18:42:46 +00:00
|
|
|
nginx-redirectcode = handleTest ./nginx-redirectcode.nix {};
|
2018-12-28 10:41:52 +00:00
|
|
|
nginx-sso = handleTest ./nginx-sso.nix {};
|
2023-07-28 17:36:55 +00:00
|
|
|
nginx-status-page = handleTest ./nginx-status-page.nix {};
|
2023-10-06 12:26:06 +00:00
|
|
|
nginx-tmpdir = handleTest ./nginx-tmpdir.nix {};
|
2023-07-07 15:52:37 +00:00
|
|
|
nginx-unix-socket = handleTest ./nginx-unix-socket.nix {};
|
2020-06-02 05:01:03 +00:00
|
|
|
nginx-variants = handleTest ./nginx-variants.nix {};
|
2022-04-10 17:41:30 +00:00
|
|
|
nifi = handleTestOn ["x86_64-linux"] ./web-apps/nifi.nix {};
|
2021-07-26 10:00:05 +00:00
|
|
|
nitter = handleTest ./nitter.nix {};
|
2024-01-01 12:00:00 +00:00
|
|
|
nix-config = handleTest ./nix-config.nix {};
|
2022-04-11 18:51:29 +00:00
|
|
|
nix-ld = handleTest ./nix-ld.nix {};
|
2024-05-30 15:09:46 +00:00
|
|
|
nix-misc = handleTest ./nix/misc.nix {};
|
2024-08-18 04:31:38 +00:00
|
|
|
nix-upgrade = handleTest ./nix/upgrade.nix {inherit (pkgs) nixVersions;};
|
2023-10-17 12:25:17 +00:00
|
|
|
nix-required-mounts = runTest ./nix-required-mounts;
|
2024-09-17 13:01:35 +00:00
|
|
|
nix-serve = runTest ./nix-serve.nix;
|
2021-12-03 16:19:42 +00:00
|
|
|
nix-serve-ssh = handleTest ./nix-serve-ssh.nix {};
|
2021-10-17 22:38:58 +00:00
|
|
|
nixops = handleTest ./nixops/default.nix {};
|
2019-08-07 16:04:18 +00:00
|
|
|
nixos-generate-config = handleTest ./nixos-generate-config.nix {};
|
2023-10-23 10:00:20 +00:00
|
|
|
nixos-rebuild-install-bootloader = handleTestOn ["x86_64-linux"] ./nixos-rebuild-install-bootloader.nix {};
|
2024-09-25 09:37:57 +00:00
|
|
|
nixos-rebuild-specialisations = runTestOn ["x86_64-linux"] ./nixos-rebuild-specialisations.nix;
|
2024-09-25 09:25:04 +00:00
|
|
|
nixos-rebuild-target-host = runTest ./nixos-rebuild-target-host.nix;
|
2021-12-03 12:04:36 +00:00
|
|
|
nixpkgs = pkgs.callPackage ../modules/misc/nixpkgs/test.nix { inherit evalMinimalConfig; };
|
2023-11-29 12:00:00 +00:00
|
|
|
nixseparatedebuginfod = handleTest ./nixseparatedebuginfod.nix {};
|
2021-07-28 10:42:26 +00:00
|
|
|
node-red = handleTest ./node-red.nix {};
|
2021-01-23 22:52:19 +00:00
|
|
|
nomad = handleTest ./nomad.nix {};
|
2022-06-22 02:10:44 +00:00
|
|
|
non-default-filesystems = handleTest ./non-default-filesystems.nix {};
|
2023-10-13 23:29:05 +00:00
|
|
|
non-switchable-system = runTest ./non-switchable-system.nix;
|
2022-01-22 02:06:13 +00:00
|
|
|
noto-fonts = handleTest ./noto-fonts.nix {};
|
2023-03-21 07:59:24 +00:00
|
|
|
noto-fonts-cjk-qt-default-weight = handleTest ./noto-fonts-cjk-qt-default-weight.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
novacomd = handleTestOn ["x86_64-linux"] ./novacomd.nix {};
|
2023-11-02 07:43:20 +00:00
|
|
|
npmrc = handleTest ./npmrc.nix {};
|
2022-10-07 09:40:33 +00:00
|
|
|
nscd = handleTest ./nscd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
nsd = handleTest ./nsd.nix {};
|
2022-09-01 12:36:19 +00:00
|
|
|
ntfy-sh = handleTest ./ntfy-sh.nix {};
|
2024-01-09 21:03:21 +00:00
|
|
|
ntfy-sh-migration = handleTest ./ntfy-sh-migration.nix {};
|
2024-10-19 18:26:27 +00:00
|
|
|
ntpd = handleTest ./ntpd.nix {};
|
2023-10-31 14:28:49 +00:00
|
|
|
ntpd-rs = handleTest ./ntpd-rs.nix {};
|
2024-08-22 17:51:54 +00:00
|
|
|
nvidia-container-toolkit = runTest ./nvidia-container-toolkit.nix;
|
2024-02-01 18:34:05 +00:00
|
|
|
nvmetcfg = handleTest ./nvmetcfg.nix {};
|
2019-04-22 12:06:33 +00:00
|
|
|
nzbget = handleTest ./nzbget.nix {};
|
2020-10-04 14:06:53 +00:00
|
|
|
nzbhydra2 = handleTest ./nzbhydra2.nix {};
|
2024-03-18 12:29:16 +00:00
|
|
|
ocis = handleTest ./ocis.nix {};
|
2024-04-06 21:41:28 +00:00
|
|
|
oddjobd = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./oddjobd.nix {};
|
2024-09-28 17:43:06 +00:00
|
|
|
obs-studio = handleTest ./obs-studio.nix {};
|
2020-11-05 01:37:50 +00:00
|
|
|
oh-my-zsh = handleTest ./oh-my-zsh.nix {};
|
2024-07-13 21:26:29 +00:00
|
|
|
ollama = runTest ./ollama.nix;
|
|
|
|
|
ollama-cuda = runTestOn ["x86_64-linux" "aarch64-linux"] ./ollama-cuda.nix;
|
|
|
|
|
ollama-rocm = runTestOn ["x86_64-linux" "aarch64-linux"] ./ollama-rocm.nix;
|
2021-03-29 14:51:05 +00:00
|
|
|
ombi = handleTest ./ombi.nix {};
|
2019-10-22 14:20:56 +00:00
|
|
|
openarena = handleTest ./openarena.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
openldap = handleTest ./openldap.nix {};
|
2023-02-15 15:11:39 +00:00
|
|
|
opensearch = discoverTests (import ./opensearch.nix);
|
2021-10-07 03:36:02 +00:00
|
|
|
openresty-lua = handleTest ./openresty-lua.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
opensmtpd = handleTest ./opensmtpd.nix {};
|
2021-05-19 20:37:49 +00:00
|
|
|
opensmtpd-rspamd = handleTest ./opensmtpd-rspamd.nix {};
|
2023-08-08 20:00:52 +00:00
|
|
|
opensnitch = handleTest ./opensnitch.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
openssh = handleTest ./openssh.nix {};
|
2023-01-28 19:02:15 +00:00
|
|
|
octoprint = handleTest ./octoprint.nix {};
|
2019-01-28 14:09:48 +00:00
|
|
|
openstack-image-metadata = (handleTestOn ["x86_64-linux"] ./openstack-image.nix {}).metadata or {};
|
2020-11-29 23:00:38 +00:00
|
|
|
openstack-image-userdata = (handleTestOn ["x86_64-linux"] ./openstack-image.nix {}).userdata or {};
|
2021-01-08 16:48:00 +00:00
|
|
|
opentabletdriver = handleTest ./opentabletdriver.nix {};
|
2023-05-09 17:31:47 +00:00
|
|
|
opentelemetry-collector = handleTest ./opentelemetry-collector.nix {};
|
2024-09-16 14:37:49 +00:00
|
|
|
open-web-calendar = handleTest ./web-apps/open-web-calendar.nix {};
|
2023-11-02 00:28:20 +00:00
|
|
|
ocsinventory-agent = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./ocsinventory-agent.nix {};
|
2021-09-23 08:48:29 +00:00
|
|
|
owncast = handleTest ./owncast.nix {};
|
2023-05-17 11:10:57 +00:00
|
|
|
outline = handleTest ./outline.nix {};
|
2020-12-20 20:18:54 +00:00
|
|
|
image-contents = handleTest ./image-contents.nix {};
|
2023-05-15 13:33:37 +00:00
|
|
|
openvscode-server = handleTest ./openvscode-server.nix {};
|
2024-06-04 10:37:06 +00:00
|
|
|
open-webui = runTest ./open-webui.nix;
|
2024-09-26 13:26:10 +00:00
|
|
|
openvswitch = runTest ./openvswitch.nix;
|
2019-08-20 22:27:14 +00:00
|
|
|
orangefs = handleTest ./orangefs.nix {};
|
2019-06-09 18:26:05 +00:00
|
|
|
os-prober = handleTestOn ["x86_64-linux"] ./os-prober.nix {};
|
2023-07-19 09:59:22 +00:00
|
|
|
osquery = handleTestOn ["x86_64-linux"] ./osquery.nix {};
|
2019-01-05 12:13:10 +00:00
|
|
|
osrm-backend = handleTest ./osrm-backend.nix {};
|
2019-01-23 09:19:23 +00:00
|
|
|
overlayfs = handleTest ./overlayfs.nix {};
|
2022-03-08 01:46:26 +00:00
|
|
|
pacemaker = handleTest ./pacemaker.nix {};
|
2019-04-24 08:45:29 +00:00
|
|
|
packagekit = handleTest ./packagekit.nix {};
|
2021-11-27 08:04:28 +00:00
|
|
|
pam-file-contents = handleTest ./pam/pam-file-contents.nix {};
|
|
|
|
|
pam-oath-login = handleTest ./pam/pam-oath-login.nix {};
|
|
|
|
|
pam-u2f = handleTest ./pam/pam-u2f.nix {};
|
2022-03-13 17:20:23 +00:00
|
|
|
pam-ussh = handleTest ./pam/pam-ussh.nix {};
|
2023-05-14 19:30:01 +00:00
|
|
|
pam-zfs-key = handleTest ./pam/zfs-key.nix {};
|
2022-04-16 05:18:57 +00:00
|
|
|
pass-secret-service = handleTest ./pass-secret-service.nix {};
|
2022-11-23 17:53:04 +00:00
|
|
|
patroni = handleTestOn ["x86_64-linux"] ./patroni.nix {};
|
2021-05-30 15:32:41 +00:00
|
|
|
pantalaimon = handleTest ./matrix/pantalaimon.nix {};
|
2019-01-24 22:33:05 +00:00
|
|
|
pantheon = handleTest ./pantheon.nix {};
|
2022-04-12 15:48:53 +00:00
|
|
|
paperless = handleTest ./paperless.nix {};
|
2021-06-02 16:19:37 +00:00
|
|
|
parsedmarc = handleTest ./parsedmarc {};
|
2020-11-29 23:00:38 +00:00
|
|
|
pdns-recursor = handleTest ./pdns-recursor.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
peerflix = handleTest ./peerflix.nix {};
|
2022-12-01 16:32:15 +00:00
|
|
|
peering-manager = handleTest ./web-apps/peering-manager.nix {};
|
2021-05-31 11:23:06 +00:00
|
|
|
peertube = handleTestOn ["x86_64-linux"] ./web-apps/peertube.nix {};
|
2023-01-03 22:05:34 +00:00
|
|
|
peroxide = handleTest ./peroxide.nix {};
|
2021-07-02 12:22:12 +00:00
|
|
|
pgadmin4 = handleTest ./pgadmin4.nix {};
|
2023-07-22 10:49:23 +00:00
|
|
|
pgbouncer = handleTest ./pgbouncer.nix {};
|
2023-11-23 10:59:27 +00:00
|
|
|
pghero = runTest ./pghero.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
pgmanage = handleTest ./pgmanage.nix {};
|
2022-08-02 19:34:37 +00:00
|
|
|
phosh = handleTest ./phosh.nix {};
|
2024-02-06 07:51:17 +00:00
|
|
|
photonvision = handleTest ./photonvision.nix {};
|
2023-01-14 23:16:35 +00:00
|
|
|
photoprism = handleTest ./photoprism.nix {};
|
2020-03-30 20:07:05 +00:00
|
|
|
php = handleTest ./php {};
|
2021-11-25 20:38:19 +00:00
|
|
|
php81 = handleTest ./php { php = pkgs.php81; };
|
2022-11-13 20:14:38 +00:00
|
|
|
php82 = handleTest ./php { php = pkgs.php82; };
|
2023-06-26 18:51:23 +00:00
|
|
|
php83 = handleTest ./php { php = pkgs.php83; };
|
2024-07-05 14:36:46 +00:00
|
|
|
php84 = handleTest ./php { php = pkgs.php84; };
|
2022-06-28 19:17:38 +00:00
|
|
|
phylactery = handleTest ./web-apps/phylactery.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
pict-rs = handleTest ./pict-rs.nix {};
|
2024-02-09 19:06:25 +00:00
|
|
|
pingvin-share = handleTest ./pingvin-share.nix {} ;
|
2020-06-03 21:12:06 +00:00
|
|
|
pinnwand = handleTest ./pinnwand.nix {};
|
2023-11-14 22:09:23 +00:00
|
|
|
plantuml-server = handleTest ./plantuml-server.nix {};
|
2022-09-17 13:02:37 +00:00
|
|
|
plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
plasma5 = handleTest ./plasma5.nix {};
|
2024-02-05 16:04:04 +00:00
|
|
|
plasma6 = handleTest ./plasma6.nix {};
|
2021-10-31 20:34:10 +00:00
|
|
|
plasma5-systemd-start = handleTest ./plasma5-systemd-start.nix {};
|
2021-05-21 21:15:23 +00:00
|
|
|
plausible = handleTest ./plausible.nix {};
|
2024-09-13 09:20:01 +00:00
|
|
|
playwright-python = handleTest ./playwright-python.nix {};
|
2022-09-29 21:12:29 +00:00
|
|
|
please = handleTest ./please.nix {};
|
2020-11-08 14:10:14 +00:00
|
|
|
pleroma = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./pleroma.nix {};
|
2020-11-13 14:00:34 +00:00
|
|
|
plikd = handleTest ./plikd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
plotinus = handleTest ./plotinus.nix {};
|
2021-04-14 17:15:41 +00:00
|
|
|
podgrab = handleTest ./podgrab.nix {};
|
2022-09-24 05:58:15 +00:00
|
|
|
podman = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/default.nix {};
|
|
|
|
|
podman-tls-ghostunnel = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/tls-ghostunnel.nix {};
|
2022-06-17 18:04:54 +00:00
|
|
|
polaris = handleTest ./polaris.nix {};
|
2021-01-08 03:03:00 +00:00
|
|
|
pomerium = handleTestOn ["x86_64-linux"] ./pomerium.nix {};
|
2023-05-21 16:53:52 +00:00
|
|
|
portunus = handleTest ./portunus.nix { };
|
2020-07-06 01:37:56 +00:00
|
|
|
postfix = handleTest ./postfix.nix {};
|
|
|
|
|
postfix-raise-smtpd-tls-security-level = handleTest ./postfix-raise-smtpd-tls-security-level.nix {};
|
2021-05-19 04:34:03 +00:00
|
|
|
postfixadmin = handleTest ./postfixadmin.nix {};
|
2024-11-02 17:58:52 +00:00
|
|
|
postgresql = handleTest ./postgresql {};
|
2018-11-11 11:30:07 +00:00
|
|
|
powerdns = handleTest ./powerdns.nix {};
|
2021-12-17 09:33:40 +00:00
|
|
|
powerdns-admin = handleTest ./powerdns-admin.nix {};
|
2021-10-29 04:15:27 +00:00
|
|
|
power-profiles-daemon = handleTest ./power-profiles-daemon.nix {};
|
2019-10-15 04:26:54 +00:00
|
|
|
pppd = handleTest ./pppd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
predictable-interface-names = handleTest ./predictable-interface-names.nix {};
|
2023-05-13 15:36:03 +00:00
|
|
|
pretalx = runTest ./web-apps/pretalx.nix;
|
2024-03-14 11:43:39 +00:00
|
|
|
pretix = runTest ./web-apps/pretix.nix;
|
2024-08-29 13:12:56 +00:00
|
|
|
printing-socket = handleTest ./printing.nix { socket = true; listenTcp = true; };
|
|
|
|
|
printing-service = handleTest ./printing.nix { socket = false; listenTcp = true; };
|
|
|
|
|
printing-socket-notcp = handleTest ./printing.nix { socket = true; listenTcp = false; };
|
|
|
|
|
printing-service-notcp = handleTest ./printing.nix { socket = false; listenTcp = false; };
|
2024-04-24 13:15:25 +00:00
|
|
|
private-gpt = handleTest ./private-gpt.nix {};
|
2024-09-29 17:27:42 +00:00
|
|
|
privatebin = runTest ./privatebin.nix;
|
2021-03-03 16:18:09 +00:00
|
|
|
privoxy = handleTest ./privoxy.nix {};
|
2024-06-01 23:06:14 +00:00
|
|
|
prometheus = handleTest ./prometheus {};
|
2018-11-11 11:30:07 +00:00
|
|
|
prometheus-exporters = handleTest ./prometheus-exporters.nix {};
|
2019-06-15 09:16:28 +00:00
|
|
|
prosody = handleTest ./xmpp/prosody.nix {};
|
2022-02-18 19:19:31 +00:00
|
|
|
prosody-mysql = handleTest ./xmpp/prosody-mysql.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
proxy = handleTest ./proxy.nix {};
|
2021-10-10 15:54:22 +00:00
|
|
|
prowlarr = handleTest ./prowlarr.nix {};
|
2020-07-29 17:00:33 +00:00
|
|
|
pt2-clone = handleTest ./pt2-clone.nix {};
|
2022-06-26 22:20:04 +00:00
|
|
|
pykms = handleTest ./pykms.nix {};
|
2021-12-01 10:06:18 +00:00
|
|
|
public-inbox = handleTest ./public-inbox.nix {};
|
2023-04-07 06:34:25 +00:00
|
|
|
pufferpanel = handleTest ./pufferpanel.nix {};
|
2021-11-30 13:51:06 +00:00
|
|
|
pulseaudio = discoverTests (import ./pulseaudio.nix);
|
2020-05-22 03:15:32 +00:00
|
|
|
qboot = handleTestOn ["x86_64-linux" "i686-linux"] ./qboot.nix {};
|
2023-01-12 18:50:27 +00:00
|
|
|
qemu-vm-restrictnetwork = handleTest ./qemu-vm-restrictnetwork.nix {};
|
2023-06-20 23:38:27 +00:00
|
|
|
qemu-vm-volatile-root = runTest ./qemu-vm-volatile-root.nix;
|
2023-06-20 22:19:21 +00:00
|
|
|
qemu-vm-external-disk-image = runTest ./qemu-vm-external-disk-image.nix;
|
2024-02-22 23:00:37 +00:00
|
|
|
qemu-vm-store = runTest ./qemu-vm-store.nix;
|
2024-09-16 10:51:21 +00:00
|
|
|
qgis = handleTest ./qgis.nix { package = pkgs.qgis; };
|
|
|
|
|
qgis-ltr = handleTest ./qgis.nix { package = pkgs.qgis-ltr; };
|
2023-06-16 06:19:47 +00:00
|
|
|
qownnotes = handleTest ./qownnotes.nix {};
|
2024-05-31 14:25:21 +00:00
|
|
|
qtile = handleTestOn ["x86_64-linux" "aarch64-linux"] ./qtile/default.nix {};
|
2023-08-28 15:59:16 +00:00
|
|
|
quake3 = handleTest ./quake3.nix {};
|
2023-11-01 18:48:51 +00:00
|
|
|
quicktun = handleTest ./quicktun.nix {};
|
2024-06-04 21:39:48 +00:00
|
|
|
quickwit = handleTest ./quickwit.nix {};
|
2023-08-28 15:59:16 +00:00
|
|
|
quorum = handleTest ./quorum.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rabbitmq = handleTest ./rabbitmq.nix {};
|
2019-01-24 22:09:21 +00:00
|
|
|
radarr = handleTest ./radarr.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
radicale = handleTest ./radicale.nix {};
|
2024-05-25 00:23:48 +00:00
|
|
|
radicle = runTest ./radicle.nix;
|
2023-08-08 09:53:51 +00:00
|
|
|
ragnarwm = handleTest ./ragnarwm.nix {};
|
2021-02-02 00:39:50 +00:00
|
|
|
rasdaemon = handleTest ./rasdaemon.nix {};
|
2024-07-27 22:25:01 +00:00
|
|
|
rathole = handleTest ./rathole.nix {};
|
2023-03-12 19:54:23 +00:00
|
|
|
readarr = handleTest ./readarr.nix {};
|
2024-01-28 04:56:32 +00:00
|
|
|
realm = handleTest ./realm.nix {};
|
2019-08-31 18:17:33 +00:00
|
|
|
redis = handleTest ./redis.nix {};
|
2024-04-22 06:31:53 +00:00
|
|
|
redlib = handleTest ./redlib.nix {};
|
2024-10-13 01:32:49 +00:00
|
|
|
redmine = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./redmine.nix {};
|
2024-06-08 15:56:52 +00:00
|
|
|
renovate = handleTest ./renovate.nix {};
|
2023-12-16 18:02:17 +00:00
|
|
|
replace-dependencies = handleTest ./replace-dependencies {};
|
2021-09-08 19:02:28 +00:00
|
|
|
restartByActivationScript = handleTest ./restart-by-activation-script.nix {};
|
2024-03-16 06:27:14 +00:00
|
|
|
restic-rest-server = handleTest ./restic-rest-server.nix {};
|
2020-01-30 21:31:52 +00:00
|
|
|
restic = handleTest ./restic.nix {};
|
2022-02-04 23:50:11 +00:00
|
|
|
retroarch = handleTest ./retroarch.nix {};
|
2024-05-11 04:50:27 +00:00
|
|
|
rke2 = handleTestOn ["aarch64-linux" "x86_64-linux"] ./rke2 {};
|
2023-10-05 12:32:38 +00:00
|
|
|
rkvm = handleTest ./rkvm {};
|
2024-11-18 13:56:12 +00:00
|
|
|
rmfakecloud = runTest ./rmfakecloud.nix;
|
2020-08-30 16:31:54 +00:00
|
|
|
robustirc-bridge = handleTest ./robustirc-bridge.nix {};
|
2018-11-28 16:33:26 +00:00
|
|
|
roundcube = handleTest ./roundcube.nix {};
|
2023-10-23 17:29:30 +00:00
|
|
|
rosenpass = handleTest ./rosenpass.nix {};
|
2023-05-15 12:09:28 +00:00
|
|
|
rshim = handleTest ./rshim.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rspamd = handleTest ./rspamd.nix {};
|
2023-10-18 09:47:00 +00:00
|
|
|
rspamd-trainer = handleTest ./rspamd-trainer.nix {};
|
2024-07-31 13:17:50 +00:00
|
|
|
rss-bridge = handleTest ./web-apps/rss-bridge.nix {};
|
2018-10-27 09:33:43 +00:00
|
|
|
rss2email = handleTest ./rss2email.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
rstudio-server = handleTest ./rstudio-server.nix {};
|
|
|
|
|
rsyncd = handleTest ./rsyncd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rsyslogd = handleTest ./rsyslogd.nix {};
|
2024-06-23 23:38:41 +00:00
|
|
|
rtorrent = handleTest ./rtorrent.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rxe = handleTest ./rxe.nix {};
|
2021-09-21 11:38:22 +00:00
|
|
|
sabnzbd = handleTest ./sabnzbd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
samba = handleTest ./samba.nix {};
|
2020-11-23 14:13:22 +00:00
|
|
|
samba-wsdd = handleTest ./samba-wsdd.nix {};
|
2024-01-01 12:00:00 +00:00
|
|
|
sane = handleTest ./sane.nix {};
|
2019-10-27 03:37:30 +00:00
|
|
|
sanoid = handleTest ./sanoid.nix {};
|
2024-10-03 09:39:24 +00:00
|
|
|
saunafs = handleTest ./saunafs.nix {};
|
2023-06-26 17:41:28 +00:00
|
|
|
scaphandre = handleTest ./scaphandre.nix {};
|
2022-05-31 15:27:54 +00:00
|
|
|
schleuder = handleTest ./schleuder.nix {};
|
2024-03-24 21:03:03 +00:00
|
|
|
scion-freestanding-deployment = handleTest ./scion/freestanding-deployment {};
|
2024-02-19 09:47:18 +00:00
|
|
|
scrutiny = handleTest ./scrutiny.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
sddm = handleTest ./sddm.nix {};
|
2021-11-07 08:05:36 +00:00
|
|
|
seafile = handleTest ./seafile.nix {};
|
2024-06-19 05:04:30 +00:00
|
|
|
searx = runTest ./searx.nix;
|
2023-08-25 05:29:57 +00:00
|
|
|
seatd = handleTest ./seatd.nix {};
|
2024-10-25 17:50:55 +00:00
|
|
|
send = runTest ./send.nix;
|
2020-02-28 11:17:01 +00:00
|
|
|
service-runner = handleTest ./service-runner.nix {};
|
2023-04-19 13:13:54 +00:00
|
|
|
sftpgo = runTest ./sftpgo.nix;
|
2022-03-20 21:39:04 +00:00
|
|
|
sfxr-qt = handleTest ./sfxr-qt.nix {};
|
2023-10-06 10:36:48 +00:00
|
|
|
sgt-puzzles = handleTest ./sgt-puzzles.nix {};
|
2020-12-23 18:28:30 +00:00
|
|
|
shadow = handleTest ./shadow.nix {};
|
2020-09-08 22:15:59 +00:00
|
|
|
shadowsocks = handleTest ./shadowsocks {};
|
2020-08-09 13:20:17 +00:00
|
|
|
shattered-pixel-dungeon = handleTest ./shattered-pixel-dungeon.nix {};
|
2019-11-08 17:17:08 +00:00
|
|
|
shiori = handleTest ./shiori.nix {};
|
2019-05-22 22:50:51 +00:00
|
|
|
signal-desktop = handleTest ./signal-desktop.nix {};
|
2024-03-16 16:12:16 +00:00
|
|
|
silverbullet = handleTest ./silverbullet.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
simple = handleTest ./simple.nix {};
|
2023-06-27 04:58:10 +00:00
|
|
|
sing-box = handleTest ./sing-box.nix {};
|
2023-11-05 01:43:15 +00:00
|
|
|
slimserver = handleTest ./slimserver.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
slurm = handleTest ./slurm.nix {};
|
2023-12-02 14:05:57 +00:00
|
|
|
snmpd = handleTest ./snmpd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
smokeping = handleTest ./smokeping.nix {};
|
2020-07-28 12:47:36 +00:00
|
|
|
snapcast = handleTest ./snapcast.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
snapper = handleTest ./snapper.nix {};
|
2023-04-26 15:46:15 +00:00
|
|
|
snipe-it = runTest ./web-apps/snipe-it.nix;
|
2022-01-23 11:11:05 +00:00
|
|
|
soapui = handleTest ./soapui.nix {};
|
2023-07-07 23:44:42 +00:00
|
|
|
soft-serve = handleTest ./soft-serve.nix {};
|
2020-05-12 16:32:39 +00:00
|
|
|
sogo = handleTest ./sogo.nix {};
|
2023-10-02 00:56:37 +00:00
|
|
|
soju = handleTest ./soju.nix {};
|
2021-05-20 20:03:39 +00:00
|
|
|
solanum = handleTest ./solanum.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
sonarr = handleTest ./sonarr.nix {};
|
2023-11-10 13:52:15 +00:00
|
|
|
sonic-server = handleTest ./sonic-server.nix {};
|
2023-12-25 02:49:11 +00:00
|
|
|
sourcehut = handleTest ./sourcehut {};
|
2019-05-24 19:17:51 +00:00
|
|
|
spacecookie = handleTest ./spacecookie.nix {};
|
2022-02-08 13:59:23 +00:00
|
|
|
spark = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./spark {};
|
2024-10-21 07:34:20 +00:00
|
|
|
spiped = runTest ./spiped.nix;
|
2022-11-13 19:13:15 +00:00
|
|
|
sqlite3-to-mysql = handleTest ./sqlite3-to-mysql.nix {};
|
2020-01-18 12:00:00 +00:00
|
|
|
sslh = handleTest ./sslh.nix {};
|
2023-11-08 20:47:33 +00:00
|
|
|
ssh-agent-auth = handleTest ./ssh-agent-auth.nix {};
|
2023-10-16 08:31:39 +00:00
|
|
|
ssh-audit = handleTest ./ssh-audit.nix {};
|
2023-10-18 16:25:11 +00:00
|
|
|
sssd = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd.nix {};
|
|
|
|
|
sssd-ldap = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd-ldap.nix {};
|
2023-09-02 18:27:11 +00:00
|
|
|
stalwart-mail = handleTest ./stalwart-mail.nix {};
|
2023-04-16 23:24:06 +00:00
|
|
|
stargazer = runTest ./web-servers/stargazer.nix;
|
2021-12-24 11:24:29 +00:00
|
|
|
starship = handleTest ./starship.nix {};
|
2023-07-01 16:17:39 +00:00
|
|
|
static-web-server = handleTest ./web-servers/static-web-server.nix {};
|
2021-11-12 20:37:11 +00:00
|
|
|
step-ca = handleTestOn ["x86_64-linux"] ./step-ca.nix {};
|
2022-09-12 07:18:11 +00:00
|
|
|
stratis = handleTest ./stratis {};
|
2018-11-11 11:30:07 +00:00
|
|
|
strongswan-swanctl = handleTest ./strongswan-swanctl.nix {};
|
2023-11-24 03:03:03 +00:00
|
|
|
stub-ld = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./stub-ld.nix {};
|
2022-02-22 22:08:43 +00:00
|
|
|
stunnel = handleTest ./stunnel.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
sudo = handleTest ./sudo.nix {};
|
2023-09-07 15:53:18 +00:00
|
|
|
sudo-rs = handleTest ./sudo-rs.nix {};
|
2024-03-31 01:07:35 +00:00
|
|
|
sunshine = handleTest ./sunshine.nix {};
|
2024-05-22 12:45:16 +00:00
|
|
|
suricata = handleTest ./suricata.nix {};
|
2024-01-18 21:11:16 +00:00
|
|
|
suwayomi-server = handleTest ./suwayomi-server.nix {};
|
2022-10-04 03:08:46 +00:00
|
|
|
swap-file-btrfs = handleTest ./swap-file-btrfs.nix {};
|
2022-06-22 02:11:23 +00:00
|
|
|
swap-partition = handleTest ./swap-partition.nix {};
|
2023-05-03 20:11:45 +00:00
|
|
|
swap-random-encryption = handleTest ./swap-random-encryption.nix {};
|
2024-10-26 19:52:53 +00:00
|
|
|
swapspace = handleTestOn ["aarch64-linux" "x86_64-linux"] ./swapspace.nix {};
|
2021-05-27 18:37:24 +00:00
|
|
|
sway = handleTest ./sway.nix {};
|
2024-04-29 19:47:59 +00:00
|
|
|
swayfx = handleTest ./swayfx.nix {};
|
2024-05-03 13:27:42 +00:00
|
|
|
switchTest = handleTest ./switch-test.nix { ng = false; };
|
|
|
|
|
switchTestNg = handleTest ./switch-test.nix { ng = true; };
|
2024-08-10 14:17:06 +00:00
|
|
|
sx = handleTest ./sx.nix {};
|
2019-07-06 18:56:30 +00:00
|
|
|
sympa = handleTest ./sympa.nix {};
|
2020-07-23 07:13:26 +00:00
|
|
|
syncthing = handleTest ./syncthing.nix {};
|
2023-05-23 13:58:38 +00:00
|
|
|
syncthing-no-settings = handleTest ./syncthing-no-settings.nix {};
|
2019-04-21 21:05:07 +00:00
|
|
|
syncthing-init = handleTest ./syncthing-init.nix {};
|
2023-10-14 18:32:24 +00:00
|
|
|
syncthing-many-devices = handleTest ./syncthing-many-devices.nix {};
|
2018-11-17 14:02:00 +00:00
|
|
|
syncthing-relay = handleTest ./syncthing-relay.nix {};
|
2023-11-25 20:31:09 +00:00
|
|
|
sysinit-reactivation = runTest ./sysinit-reactivation.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
systemd = handleTest ./systemd.nix {};
|
2019-11-24 23:03:55 +00:00
|
|
|
systemd-analyze = handleTest ./systemd-analyze.nix {};
|
2020-05-18 09:16:56 +00:00
|
|
|
systemd-binfmt = handleTestOn ["x86_64-linux"] ./systemd-binfmt.nix {};
|
2020-06-14 03:57:52 +00:00
|
|
|
systemd-boot = handleTest ./systemd-boot.nix {};
|
2022-08-21 10:22:16 +00:00
|
|
|
systemd-bpf = handleTest ./systemd-bpf.nix {};
|
2024-04-24 13:04:07 +00:00
|
|
|
systemd-confinement = handleTest ./systemd-confinement {};
|
2022-08-01 16:44:29 +00:00
|
|
|
systemd-coredump = handleTest ./systemd-coredump.nix {};
|
2021-10-04 10:54:13 +00:00
|
|
|
systemd-cryptenroll = handleTest ./systemd-cryptenroll.nix {};
|
2023-02-20 00:07:31 +00:00
|
|
|
systemd-credentials-tpm2 = handleTest ./systemd-credentials-tpm2.nix {};
|
2022-01-09 07:46:55 +00:00
|
|
|
systemd-escaping = handleTest ./systemd-escaping.nix {};
|
2023-08-25 17:11:20 +00:00
|
|
|
systemd-initrd-bridge = handleTest ./systemd-initrd-bridge.nix {};
|
2022-04-17 12:55:48 +00:00
|
|
|
systemd-initrd-btrfs-raid = handleTest ./systemd-initrd-btrfs-raid.nix {};
|
2022-10-03 17:10:03 +00:00
|
|
|
systemd-initrd-luks-fido2 = handleTest ./systemd-initrd-luks-fido2.nix {};
|
2022-04-13 21:27:58 +00:00
|
|
|
systemd-initrd-luks-keyfile = handleTest ./systemd-initrd-luks-keyfile.nix {};
|
2023-03-22 14:17:23 +00:00
|
|
|
systemd-initrd-luks-empty-passphrase = handleTest ./initrd-luks-empty-passphrase.nix { systemdStage1 = true; };
|
2022-04-13 18:45:29 +00:00
|
|
|
systemd-initrd-luks-password = handleTest ./systemd-initrd-luks-password.nix {};
|
2022-09-23 21:47:05 +00:00
|
|
|
systemd-initrd-luks-tpm2 = handleTest ./systemd-initrd-luks-tpm2.nix {};
|
2023-02-26 13:30:25 +00:00
|
|
|
systemd-initrd-luks-unl0kr = handleTest ./systemd-initrd-luks-unl0kr.nix {};
|
2022-10-05 00:37:51 +00:00
|
|
|
systemd-initrd-modprobe = handleTest ./systemd-initrd-modprobe.nix {};
|
2022-04-15 10:23:02 +00:00
|
|
|
systemd-initrd-shutdown = handleTest ./systemd-shutdown.nix { systemdStage1 = true; };
|
2022-03-20 20:11:32 +00:00
|
|
|
systemd-initrd-simple = handleTest ./systemd-initrd-simple.nix {};
|
2022-04-15 15:28:41 +00:00
|
|
|
systemd-initrd-swraid = handleTest ./systemd-initrd-swraid.nix {};
|
2023-02-08 20:24:10 +00:00
|
|
|
systemd-initrd-vconsole = handleTest ./systemd-initrd-vconsole.nix {};
|
2022-06-29 05:01:59 +00:00
|
|
|
systemd-initrd-networkd = handleTest ./systemd-initrd-networkd.nix {};
|
2022-08-03 10:36:11 +00:00
|
|
|
systemd-initrd-networkd-ssh = handleTest ./systemd-initrd-networkd-ssh.nix {};
|
2023-12-20 09:23:08 +00:00
|
|
|
systemd-initrd-networkd-openvpn = handleTestOn [ "x86_64-linux" "i686-linux" ] ./initrd-network-openvpn { systemdStage1 = true; };
|
2023-08-25 03:57:46 +00:00
|
|
|
systemd-initrd-vlan = handleTest ./systemd-initrd-vlan.nix {};
|
2020-11-01 17:48:40 +00:00
|
|
|
systemd-journal = handleTest ./systemd-journal.nix {};
|
2022-09-01 12:54:10 +00:00
|
|
|
systemd-journal-gateway = handleTest ./systemd-journal-gateway.nix {};
|
2022-09-01 12:55:30 +00:00
|
|
|
systemd-journal-upload = handleTest ./systemd-journal-upload.nix {};
|
2023-10-05 14:52:07 +00:00
|
|
|
systemd-lock-handler = runTestOn ["aarch64-linux" "x86_64-linux"] ./systemd-lock-handler.nix;
|
2022-02-17 21:07:05 +00:00
|
|
|
systemd-machinectl = handleTest ./systemd-machinectl.nix {};
|
2020-02-29 18:34:48 +00:00
|
|
|
systemd-networkd = handleTest ./systemd-networkd.nix {};
|
2024-04-11 07:56:18 +00:00
|
|
|
systemd-networkd-bridge = handleTest ./systemd-networkd-bridge.nix {};
|
2019-11-16 11:13:51 +00:00
|
|
|
systemd-networkd-dhcpserver = handleTest ./systemd-networkd-dhcpserver.nix {};
|
2021-11-30 08:57:15 +00:00
|
|
|
systemd-networkd-dhcpserver-static-leases = handleTest ./systemd-networkd-dhcpserver-static-leases.nix {};
|
2020-05-01 13:12:19 +00:00
|
|
|
systemd-networkd-ipv6-prefix-delegation = handleTest ./systemd-networkd-ipv6-prefix-delegation.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
systemd-networkd-vrf = handleTest ./systemd-networkd-vrf.nix {};
|
2022-10-04 16:19:38 +00:00
|
|
|
systemd-no-tainted = handleTest ./systemd-no-tainted.nix {};
|
2019-11-02 18:55:41 +00:00
|
|
|
systemd-nspawn = handleTest ./systemd-nspawn.nix {};
|
2023-06-07 09:34:33 +00:00
|
|
|
systemd-nspawn-configfile = handleTest ./systemd-nspawn-configfile.nix {};
|
2022-04-21 17:54:50 +00:00
|
|
|
systemd-oomd = handleTest ./systemd-oomd.nix {};
|
2022-09-29 10:57:18 +00:00
|
|
|
systemd-portabled = handleTest ./systemd-portabled.nix {};
|
2023-01-19 19:04:29 +00:00
|
|
|
systemd-repart = handleTest ./systemd-repart.nix {};
|
2024-05-20 23:37:01 +00:00
|
|
|
systemd-resolved = handleTest ./systemd-resolved.nix {};
|
2022-04-15 10:23:02 +00:00
|
|
|
systemd-shutdown = handleTest ./systemd-shutdown.nix {};
|
2023-07-17 15:20:32 +00:00
|
|
|
systemd-sysupdate = runTest ./systemd-sysupdate.nix;
|
2023-11-19 22:16:14 +00:00
|
|
|
systemd-sysusers-mutable = runTest ./systemd-sysusers-mutable.nix;
|
|
|
|
|
systemd-sysusers-immutable = runTest ./systemd-sysusers-immutable.nix;
|
2020-11-29 23:00:38 +00:00
|
|
|
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
|
2023-06-22 12:17:42 +00:00
|
|
|
systemd-timesyncd-nscd-dnssec = handleTest ./systemd-timesyncd-nscd-dnssec.nix {};
|
2024-03-21 23:51:05 +00:00
|
|
|
systemd-user-linger = handleTest ./systemd-user-linger.nix {};
|
2022-12-23 20:22:49 +00:00
|
|
|
systemd-user-tmpfiles-rules = handleTest ./systemd-user-tmpfiles-rules.nix {};
|
2021-08-11 18:28:30 +00:00
|
|
|
systemd-misc = handleTest ./systemd-misc.nix {};
|
2022-12-08 00:31:05 +00:00
|
|
|
systemd-userdbd = handleTest ./systemd-userdbd.nix {};
|
2022-12-08 08:49:12 +00:00
|
|
|
systemd-homed = handleTest ./systemd-homed.nix {};
|
2024-01-09 18:38:02 +00:00
|
|
|
systemtap = handleTest ./systemtap.nix {};
|
2022-09-17 14:36:39 +00:00
|
|
|
tandoor-recipes = handleTest ./tandoor-recipes.nix {};
|
2024-06-19 11:55:33 +00:00
|
|
|
tandoor-recipes-script-name = handleTest ./tandoor-recipes-script-name.nix {};
|
2023-10-16 11:10:15 +00:00
|
|
|
tang = handleTest ./tang.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
taskserver = handleTest ./taskserver.nix {};
|
2024-06-10 17:15:18 +00:00
|
|
|
taskchampion-sync-server = handleTest ./taskchampion-sync-server.nix {};
|
2022-10-12 19:16:02 +00:00
|
|
|
tayga = handleTest ./tayga.nix {};
|
2024-04-04 06:35:07 +00:00
|
|
|
technitium-dns-server = handleTest ./technitium-dns-server.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
teeworlds = handleTest ./teeworlds.nix {};
|
2019-01-21 11:30:11 +00:00
|
|
|
telegraf = handleTest ./telegraf.nix {};
|
2022-01-10 12:46:47 +00:00
|
|
|
teleport = handleTest ./teleport.nix {};
|
2024-07-04 18:36:22 +00:00
|
|
|
teleports = runTest ./teleports.nix;
|
2022-01-11 02:29:04 +00:00
|
|
|
thelounge = handleTest ./thelounge.nix {};
|
2020-11-13 18:41:14 +00:00
|
|
|
terminal-emulators = handleTest ./terminal-emulators.nix {};
|
2024-06-01 23:01:02 +00:00
|
|
|
thanos = handleTest ./thanos.nix {};
|
2019-04-29 20:46:00 +00:00
|
|
|
tiddlywiki = handleTest ./tiddlywiki.nix {};
|
2020-04-13 03:56:20 +00:00
|
|
|
tigervnc = handleTest ./tigervnc.nix {};
|
2024-07-12 10:59:00 +00:00
|
|
|
tika = runTest ./tika.nix;
|
2019-12-02 22:28:53 +00:00
|
|
|
timezone = handleTest ./timezone.nix {};
|
2024-10-24 09:46:02 +00:00
|
|
|
timidity = handleTestOn ["aarch64-linux" "x86_64-linux"] ./timidity {};
|
2020-12-06 15:05:21 +00:00
|
|
|
tinc = handleTest ./tinc {};
|
2019-05-16 21:42:02 +00:00
|
|
|
tinydns = handleTest ./tinydns.nix {};
|
2023-05-05 19:02:11 +00:00
|
|
|
tinyproxy = handleTest ./tinyproxy.nix {};
|
2021-12-28 20:32:26 +00:00
|
|
|
tinywl = handleTest ./tinywl.nix {};
|
2022-10-05 16:34:30 +00:00
|
|
|
tmate-ssh-server = handleTest ./tmate-ssh-server.nix { };
|
2022-03-13 13:31:43 +00:00
|
|
|
tomcat = handleTest ./tomcat.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
tor = handleTest ./tor.nix {};
|
2022-09-24 07:43:38 +00:00
|
|
|
traefik = handleTestOn ["aarch64-linux" "x86_64-linux"] ./traefik.nix {};
|
2021-04-09 16:48:51 +00:00
|
|
|
trafficserver = handleTest ./trafficserver.nix {};
|
2024-01-25 04:23:53 +00:00
|
|
|
transfer-sh = handleTest ./transfer-sh.nix {};
|
2024-06-10 07:54:49 +00:00
|
|
|
transmission_3 = handleTest ./transmission.nix { transmission = pkgs.transmission_3; };
|
2023-09-23 11:27:17 +00:00
|
|
|
transmission_4 = handleTest ./transmission.nix { transmission = pkgs.transmission_4; };
|
2022-10-02 10:43:54 +00:00
|
|
|
# tracee requires bpf
|
|
|
|
|
tracee = handleTestOn ["x86_64-linux"] ./tracee.nix {};
|
2019-08-16 15:00:07 +00:00
|
|
|
trezord = handleTest ./trezord.nix {};
|
2019-11-01 10:03:23 +00:00
|
|
|
trickster = handleTest ./trickster.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
trilium-server = handleTestOn ["x86_64-linux"] ./trilium-server.nix {};
|
2021-12-18 08:21:57 +00:00
|
|
|
tsm-client-gui = handleTest ./tsm-client-gui.nix {};
|
2024-01-20 16:33:00 +00:00
|
|
|
ttyd = handleTest ./web-servers/ttyd.nix {};
|
2021-06-24 21:34:03 +00:00
|
|
|
txredisapi = handleTest ./txredisapi.nix {};
|
2020-03-24 22:45:49 +00:00
|
|
|
tuptime = handleTest ./tuptime.nix {};
|
2021-03-14 05:13:41 +00:00
|
|
|
turbovnc-headless-server = handleTest ./turbovnc-headless-server.nix {};
|
2024-09-11 02:51:45 +00:00
|
|
|
turn-rs = handleTest ./turn-rs.nix {};
|
2021-07-23 14:02:20 +00:00
|
|
|
tuxguitar = handleTest ./tuxguitar.nix {};
|
2023-07-07 16:50:29 +00:00
|
|
|
twingate = runTest ./twingate.nix;
|
2023-07-18 22:29:30 +00:00
|
|
|
typesense = handleTest ./typesense.nix {};
|
2021-06-13 20:00:25 +00:00
|
|
|
ucarp = handleTest ./ucarp.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
udisks2 = handleTest ./udisks2.nix {};
|
2023-09-17 22:09:25 +00:00
|
|
|
ulogd = handleTest ./ulogd/ulogd.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
unbound = handleTest ./unbound.nix {};
|
2021-12-17 23:55:13 +00:00
|
|
|
unifi = handleTest ./unifi.nix {};
|
2020-04-16 20:08:00 +00:00
|
|
|
unit-php = handleTest ./web-servers/unit-php.nix {};
|
2024-09-08 17:45:16 +00:00
|
|
|
unit-perl = handleTest ./web-servers/unit-perl.nix {};
|
2023-06-21 17:08:31 +00:00
|
|
|
upnp.iptables = handleTest ./upnp.nix { useNftables = false; };
|
|
|
|
|
upnp.nftables = handleTest ./upnp.nix { useNftables = true; };
|
2022-03-17 16:57:23 +00:00
|
|
|
uptermd = handleTest ./uptermd.nix {};
|
2022-09-23 05:04:23 +00:00
|
|
|
uptime-kuma = handleTest ./uptime-kuma.nix {};
|
2024-02-04 18:59:22 +00:00
|
|
|
urn-timer = handleTest ./urn-timer.nix {};
|
2021-01-16 22:15:52 +00:00
|
|
|
usbguard = handleTest ./usbguard.nix {};
|
2024-08-07 12:56:05 +00:00
|
|
|
userborn = runTest ./userborn.nix;
|
|
|
|
|
userborn-mutable-users = runTest ./userborn-mutable-users.nix;
|
|
|
|
|
userborn-immutable-users = runTest ./userborn-immutable-users.nix;
|
|
|
|
|
userborn-mutable-etc = runTest ./userborn-mutable-etc.nix;
|
|
|
|
|
userborn-immutable-etc = runTest ./userborn-immutable-etc.nix;
|
2021-02-15 22:40:54 +00:00
|
|
|
user-activation-scripts = handleTest ./user-activation-scripts.nix {};
|
2023-08-02 11:51:06 +00:00
|
|
|
user-expiry = runTest ./user-expiry.nix;
|
2022-04-10 19:06:19 +00:00
|
|
|
user-home-mode = handleTest ./user-home-mode.nix {};
|
2024-03-21 03:30:37 +00:00
|
|
|
ustreamer = handleTest ./ustreamer.nix {};
|
2019-05-27 21:03:22 +00:00
|
|
|
uwsgi = handleTest ./uwsgi.nix {};
|
2020-06-12 08:12:51 +00:00
|
|
|
v2ray = handleTest ./v2ray.nix {};
|
2022-09-27 19:22:21 +00:00
|
|
|
varnish60 = handleTest ./varnish.nix { package = pkgs.varnish60; };
|
2024-05-03 19:03:01 +00:00
|
|
|
varnish75 = handleTest ./varnish.nix { package = pkgs.varnish75; };
|
2018-11-11 11:30:07 +00:00
|
|
|
vault = handleTest ./vault.nix {};
|
2023-04-25 13:58:30 +00:00
|
|
|
vault-agent = handleTest ./vault-agent.nix {};
|
2022-07-05 08:54:11 +00:00
|
|
|
vault-dev = handleTest ./vault-dev.nix {};
|
2021-01-04 16:54:03 +00:00
|
|
|
vault-postgresql = handleTest ./vault-postgresql.nix {};
|
2023-07-27 19:13:55 +00:00
|
|
|
vaultwarden = discoverTests (import ./vaultwarden.nix);
|
2024-05-21 16:13:35 +00:00
|
|
|
vector = handleTest ./vector {};
|
2021-11-21 17:09:17 +00:00
|
|
|
vengi-tools = handleTest ./vengi-tools.nix {};
|
2024-11-22 01:53:13 +00:00
|
|
|
victoriametrics = handleTest ./victoriametrics {};
|
2021-06-26 12:26:17 +00:00
|
|
|
vikunja = handleTest ./vikunja.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
virtualbox = handleTestOn ["x86_64-linux"] ./virtualbox.nix {};
|
2022-03-13 07:16:34 +00:00
|
|
|
vscode-remote-ssh = handleTestOn ["x86_64-linux"] ./vscode-remote-ssh.nix {};
|
2021-11-19 20:21:20 +00:00
|
|
|
vscodium = discoverTests (import ./vscodium.nix);
|
2022-03-01 03:03:47 +00:00
|
|
|
vsftpd = handleTest ./vsftpd.nix {};
|
2024-10-22 09:28:04 +00:00
|
|
|
wakapi = handleTest ./wakapi.nix {};
|
2022-11-24 19:46:05 +00:00
|
|
|
warzone2100 = handleTest ./warzone2100.nix {};
|
2020-06-18 12:19:13 +00:00
|
|
|
wasabibackend = handleTest ./wasabibackend.nix {};
|
2024-04-01 00:55:15 +00:00
|
|
|
wastebin = handleTest ./wastebin.nix {};
|
2024-01-19 22:38:27 +00:00
|
|
|
watchdogd = handleTest ./watchdogd.nix {};
|
2020-03-22 11:49:51 +00:00
|
|
|
webhook = runTest ./webhook.nix;
|
2024-07-22 15:11:49 +00:00
|
|
|
weblate = handleTest ./web-apps/weblate.nix {};
|
2021-03-18 11:33:40 +00:00
|
|
|
wiki-js = handleTest ./wiki-js.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
wine = handleTest ./wine.nix {};
|
2019-03-17 12:20:38 +00:00
|
|
|
wireguard = handleTest ./wireguard {};
|
2024-03-09 16:20:01 +00:00
|
|
|
wg-access-server = handleTest ./wg-access-server.nix {};
|
2021-04-24 21:02:15 +00:00
|
|
|
without-nix = handleTest ./without-nix.nix {};
|
2021-01-27 14:44:27 +00:00
|
|
|
wmderland = handleTest ./wmderland.nix {};
|
2024-03-16 08:56:22 +00:00
|
|
|
workout-tracker = handleTest ./workout-tracker.nix {};
|
2024-08-22 17:27:20 +00:00
|
|
|
wpa_supplicant = import ./wpa_supplicant.nix { inherit pkgs runTest; };
|
2018-11-11 11:30:07 +00:00
|
|
|
wordpress = handleTest ./wordpress.nix {};
|
2022-11-05 11:38:11 +00:00
|
|
|
wrappers = handleTest ./wrappers.nix {};
|
2022-06-26 05:08:43 +00:00
|
|
|
writefreely = handleTest ./web-apps/writefreely.nix {};
|
2024-06-15 14:32:52 +00:00
|
|
|
wstunnel = runTest ./wstunnel.nix;
|
2019-12-14 00:17:49 +00:00
|
|
|
xandikos = handleTest ./xandikos.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
xautolock = handleTest ./xautolock.nix {};
|
|
|
|
|
xfce = handleTest ./xfce.nix {};
|
|
|
|
|
xmonad = handleTest ./xmonad.nix {};
|
2021-06-18 13:10:26 +00:00
|
|
|
xmonad-xdg-autostart = handleTest ./xmonad-xdg-autostart.nix {};
|
2022-09-20 23:39:13 +00:00
|
|
|
xpadneo = handleTest ./xpadneo.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
xrdp = handleTest ./xrdp.nix {};
|
2024-01-08 19:19:30 +00:00
|
|
|
xrdp-with-audio-pulseaudio = handleTest ./xrdp-with-audio-pulseaudio.nix {};
|
2023-11-23 20:31:50 +00:00
|
|
|
xscreensaver = handleTest ./xscreensaver.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
xss-lock = handleTest ./xss-lock.nix {};
|
2020-11-17 03:13:13 +00:00
|
|
|
xterm = handleTest ./xterm.nix {};
|
2022-01-01 21:16:13 +00:00
|
|
|
xxh = handleTest ./xxh.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
yabar = handleTest ./yabar.nix {};
|
2024-05-08 15:58:21 +00:00
|
|
|
ydotool = handleTest ./ydotool.nix {};
|
2019-06-27 15:56:10 +00:00
|
|
|
yggdrasil = handleTest ./yggdrasil.nix {};
|
2024-04-13 08:59:11 +00:00
|
|
|
your_spotify = handleTest ./your_spotify.nix {};
|
2022-02-16 05:49:51 +00:00
|
|
|
zammad = handleTest ./zammad.nix {};
|
2022-06-10 12:54:16 +00:00
|
|
|
zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};
|
2020-02-03 17:33:26 +00:00
|
|
|
zfs = handleTest ./zfs.nix {};
|
2020-08-03 10:43:13 +00:00
|
|
|
zigbee2mqtt = handleTest ./zigbee2mqtt.nix {};
|
2020-04-11 17:28:52 +00:00
|
|
|
zoneminder = handleTest ./zoneminder.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
zookeeper = handleTest ./zookeeper.nix {};
|
2023-01-18 14:40:42 +00:00
|
|
|
zram-generator = handleTest ./zram-generator.nix {};
|
2022-03-29 18:44:07 +00:00
|
|
|
zrepl = handleTest ./zrepl.nix {};
|
2020-04-11 17:28:52 +00:00
|
|
|
zsh-history = handleTest ./zsh-history.nix {};
|
2023-05-13 21:42:00 +00:00
|
|
|
zwave-js = handleTest ./zwave-js.nix {};
|
2022-06-06 17:24:30 +00:00
|
|
|
}
|