2022-06-25 11:47:50 +01: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 20:26:50 +01:00
|
|
|
if isAttrs val
|
|
|
|
|
then
|
|
|
|
|
if hasAttr "test" val then callTest val
|
2023-08-06 14:40:10 +01:00
|
|
|
else mapAttrs (n: s: if n == "passthru" then s else discoverTests s) val
|
2022-06-25 20:26:50 +01: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 13:34:29 +01:00
|
|
|
|
2022-06-06 19:19:59 +01:00
|
|
|
inherit
|
|
|
|
|
(rec {
|
2022-09-29 09:32:31 +01:00
|
|
|
doRunTest = arg: ((import ../lib/testing-python.nix { inherit system pkgs; }).evalTest {
|
2023-05-07 18:25:33 +01:00
|
|
|
imports = [ arg readOnlyPkgs ];
|
2022-09-29 09:32:31 +01:00
|
|
|
}).config.result;
|
2022-06-06 19:19:59 +01:00
|
|
|
findTests = tree:
|
|
|
|
|
if tree?recurseForDerivations && tree.recurseForDerivations
|
2022-06-25 11:47:50 +01:00
|
|
|
then
|
|
|
|
|
mapAttrs
|
|
|
|
|
(k: findTests)
|
|
|
|
|
(builtins.removeAttrs tree ["recurseForDerivations"])
|
|
|
|
|
else callTest tree;
|
|
|
|
|
|
2022-06-06 19:19:59 +01: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 14:44:54 +01: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."
|
|
|
|
|
{
|
|
|
|
|
_class = "nixosTest";
|
2023-05-07 16:10:40 +01:00
|
|
|
node.pkgs = pkgs;
|
2023-05-07 14:44:54 +01:00
|
|
|
};
|
|
|
|
|
|
2022-06-06 18:24:30 +01:00
|
|
|
in {
|
2023-04-25 10:59:14 +01:00
|
|
|
|
|
|
|
|
# Testing the test driver
|
|
|
|
|
nixos-test-driver = {
|
|
|
|
|
extra-python-packages = handleTest ./nixos-test-driver/extra-python-packages.nix {};
|
2023-06-04 04:10:20 +01:00
|
|
|
lib-extend = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./nixos-test-driver/lib-extend.nix {};
|
2023-04-25 11:21:38 +01:00
|
|
|
node-name = runTest ./nixos-test-driver/node-name.nix;
|
2023-07-07 09:58:13 +01:00
|
|
|
busybox = runTest ./nixos-test-driver/busybox.nix;
|
2023-10-27 12:32:04 +01: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 10:59:14 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
# NixOS vm tests and non-vm unit tests
|
|
|
|
|
|
2022-06-06 20:19:22 +01:00
|
|
|
_3proxy = runTest ./3proxy.nix;
|
2023-04-04 19:18:38 +01:00
|
|
|
aaaaxy = runTest ./aaaaxy.nix;
|
2022-06-06 22:49:59 +01:00
|
|
|
acme = runTest ./acme.nix;
|
2023-05-31 14:08:39 +01:00
|
|
|
acme-dns = handleTest ./acme-dns.nix {};
|
2022-06-09 16:43:22 +01:00
|
|
|
adguardhome = runTest ./adguardhome.nix;
|
2022-11-25 18:20:39 +00:00
|
|
|
aesmd = runTestOn ["x86_64-linux"] ./aesmd.nix;
|
2022-06-09 16:46:51 +01:00
|
|
|
agate = runTest ./web-servers/agate.nix;
|
2020-04-19 19:01:37 +01:00
|
|
|
agda = handleTest ./agda.nix {};
|
2021-05-03 16:38:02 +01:00
|
|
|
airsonic = handleTest ./airsonic.nix {};
|
2022-09-24 14:52:36 +01: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 16:55:16 +01:00
|
|
|
alice-lg = handleTest ./alice-lg.nix {};
|
2021-10-05 12:33:18 +01:00
|
|
|
allTerminfo = handleTest ./all-terminfo.nix {};
|
2022-11-16 16:56:44 +00:00
|
|
|
alps = handleTest ./alps.nix {};
|
2021-04-18 10:19:06 +01:00
|
|
|
amazon-init-shell = handleTest ./amazon-init-shell.nix {};
|
2023-10-25 10:29:11 +01:00
|
|
|
amazon-ssm-agent = handleTest ./amazon-ssm-agent.nix {};
|
2023-08-10 19:42:41 +01: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 14:01:02 +01:00
|
|
|
anki-sync-server = handleTest ./anki-sync-server.nix {};
|
2023-06-27 11:30:06 +01:00
|
|
|
anuko-time-tracker = handleTest ./anuko-time-tracker.nix {};
|
2022-12-29 12:43:50 +00:00
|
|
|
apcupsd = handleTest ./apcupsd.nix {};
|
2023-04-04 19:12:51 +01:00
|
|
|
apfs = runTest ./apfs.nix;
|
2023-07-16 21:16:55 +01:00
|
|
|
appliance-repart-image = runTest ./appliance-repart-image.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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
atd = handleTest ./atd.nix {};
|
2021-05-14 01:11:05 +01:00
|
|
|
atop = handleTest ./atop.nix {};
|
2022-12-16 03:07:15 +00:00
|
|
|
atuin = handleTest ./atuin.nix {};
|
2023-09-29 10:46:13 +01:00
|
|
|
audiobookshelf = handleTest ./audiobookshelf.nix {};
|
2022-07-31 22:40:48 +01: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 19:45:25 +01:00
|
|
|
avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };
|
2023-10-20 10:50:27 +01:00
|
|
|
ayatana-indicators = handleTest ./ayatana-indicators.nix {};
|
2019-10-12 00:30:55 +01:00
|
|
|
babeld = handleTest ./babeld.nix {};
|
2020-05-10 11:54:09 +01: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 {};
|
2022-10-04 05:06:28 +01: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 08:20:16 +01:00
|
|
|
birdwatcher = handleTest ./birdwatcher.nix {};
|
2020-07-21 12:43:32 +01:00
|
|
|
bitcoind = handleTest ./bitcoind.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
bittorrent = handleTest ./bittorrent.nix {};
|
2020-06-23 12:09:03 +01:00
|
|
|
blockbook-frontend = handleTest ./blockbook-frontend.nix {};
|
2022-02-10 22:44:18 +00:00
|
|
|
blocky = handleTest ./blocky.nix {};
|
2021-05-25 19:13:29 +01: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 {};
|
2021-05-04 13:30:25 +01: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 03:43:06 +01: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 13:00:00 +01:00
|
|
|
btrbk = handleTest ./btrbk.nix {};
|
2022-10-02 11:42:57 +01: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 16:50:44 +01: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 21:09:53 +01:00
|
|
|
c2fmzq = handleTest ./c2fmzq.nix {};
|
2019-10-09 12:32:03 +01:00
|
|
|
caddy = handleTest ./caddy.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
cadvisor = handleTestOn ["x86_64-linux"] ./cadvisor.nix {};
|
2021-05-27 19:37:24 +01: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 13:06:47 +01:00
|
|
|
calibre-server = handleTest ./calibre-server.nix {};
|
2023-04-07 14:36:13 +01: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 12:03:07 +01:00
|
|
|
cassandra_4 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_4; };
|
2023-08-15 04:34:32 +01: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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
certmgr = handleTest ./certmgr.nix {};
|
2022-09-24 08:38:37 +01:00
|
|
|
cfssl = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cfssl.nix {};
|
2022-04-05 01:02:11 +01:00
|
|
|
cgit = handleTest ./cgit.nix {};
|
2020-08-25 08:44:27 +01:00
|
|
|
charliecloud = handleTest ./charliecloud.nix {};
|
2022-10-09 22:29:45 +01:00
|
|
|
chromium = (handleTestOn ["aarch64-linux" "x86_64-linux"] ./chromium.nix {}).stable or {};
|
2023-08-10 01:02:33 +01: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 08:40:17 +01: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 {};
|
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 15:08:49 +01:00
|
|
|
cloud-init-hostname = handleTest ./cloud-init-hostname.nix {};
|
2023-01-01 23:19:37 +00:00
|
|
|
cloudlog = handleTest ./cloudlog.nix {};
|
2022-09-24 07:15:39 +01: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 21:08:00 +01:00
|
|
|
coder = handleTest ./coder.nix {};
|
2021-12-22 12:00:00 +00:00
|
|
|
collectd = handleTest ./collectd.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 15:54:08 +01:00
|
|
|
consul-template = handleTest ./consul-template.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
containers-bridge = handleTest ./containers-bridge.nix {};
|
2020-04-19 14:41:18 +01:00
|
|
|
containers-custom-pkgs.nix = handleTest ./containers-custom-pkgs.nix {};
|
2019-08-18 20:37:38 +01: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 10:00:09 +01:00
|
|
|
containers-reloadable = handleTest ./containers-reloadable.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 21:22:57 +01:00
|
|
|
containers-unified-hierarchy = handleTest ./containers-unified-hierarchy.nix {};
|
2020-06-05 13:54:29 +01:00
|
|
|
convos = handleTest ./convos.nix {};
|
2020-01-07 16:52:32 +00:00
|
|
|
corerad = handleTest ./corerad.nix {};
|
2021-07-03 08:32:03 +01:00
|
|
|
coturn = handleTest ./coturn.nix {};
|
2019-07-24 19:48:43 +01:00
|
|
|
couchdb = handleTest ./couchdb.nix {};
|
2022-09-24 08:39:15 +01:00
|
|
|
cri-o = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cri-o.nix {};
|
2022-07-20 19:14:06 +01:00
|
|
|
cups-pdf = handleTest ./cups-pdf.nix {};
|
2023-07-21 19:37:48 +01:00
|
|
|
curl-impersonate = handleTest ./curl-impersonate.nix {};
|
2021-01-10 17:28:29 +00:00
|
|
|
custom-ca = handleTest ./custom-ca.nix {};
|
2020-07-22 09:34:57 +01:00
|
|
|
croc = handleTest ./croc.nix {};
|
2023-05-02 00:39:19 +01:00
|
|
|
darling = handleTest ./darling.nix {};
|
2023-09-02 19:30:30 +01:00
|
|
|
dae = handleTest ./dae.nix {};
|
2023-06-14 09:27:19 +01:00
|
|
|
dconf = handleTest ./dconf.nix {};
|
2023-09-17 19:04:28 +01:00
|
|
|
deconz = handleTest ./deconz.nix {};
|
2023-04-25 04:34:09 +01:00
|
|
|
deepin = handleTest ./deepin.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
deluge = handleTest ./deluge.nix {};
|
2022-05-13 08:46:01 +01:00
|
|
|
dendrite = handleTest ./matrix/dendrite.nix {};
|
2021-09-20 00:43:54 +01:00
|
|
|
dex-oidc = handleTest ./dex-oidc.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
dhparams = handleTest ./dhparams.nix {};
|
2021-09-12 07:06:34 +01: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-07-21 11:02:48 +01:00
|
|
|
dnscrypt-wrapper = runTestOn ["x86_64-linux"] ./dnscrypt-wrapper;
|
2022-01-18 07:59:57 +00:00
|
|
|
dnsdist = handleTest ./dnsdist.nix {};
|
2020-04-14 04:13:36 +01:00
|
|
|
doas = handleTest ./doas.nix {};
|
2022-09-24 08:40:42 +01: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 {};
|
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 10:57:37 +01: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 {};
|
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 12:07:08 +01: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 19:16:22 +01:00
|
|
|
fscrypt = handleTest ./fscrypt.nix {};
|
2023-10-18 03:13:16 +01:00
|
|
|
fastnetmon-advanced = runTest ./fastnetmon-advanced.nix;
|
2019-06-15 10:16:28 +01: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 13:53:35 +01:00
|
|
|
endlessh = handleTest ./endlessh.nix {};
|
2022-09-23 21:39:38 +01:00
|
|
|
endlessh-go = handleTest ./endlessh-go.nix {};
|
2020-05-24 13:20:58 +01:00
|
|
|
engelsystem = handleTest ./engelsystem.nix {};
|
2020-05-02 15:28:50 +01: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 03:28:27 +01:00
|
|
|
envoy = handleTest ./envoy.nix {};
|
2020-05-24 19:39:23 +01:00
|
|
|
ergo = handleTest ./ergo.nix {};
|
2022-01-12 20:47:27 +00:00
|
|
|
ergochat = handleTest ./ergochat.nix {};
|
2023-07-29 11:20:37 +01: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 { };
|
2023-10-17 16:35:16 +01:00
|
|
|
activation-var = runTest ./activation/var.nix;
|
2023-10-17 20:39:51 +01:00
|
|
|
activation-nix-channel = runTest ./activation/nix-channel.nix;
|
2018-11-11 11:30:07 +00:00
|
|
|
etcd = handleTestOn ["x86_64-linux"] ./etcd.nix {};
|
2019-07-10 00:46:21 +01:00
|
|
|
etcd-cluster = handleTestOn ["x86_64-linux"] ./etcd-cluster.nix {};
|
2021-03-28 22:49:45 +01:00
|
|
|
etebase-server = handleTest ./etebase-server.nix {};
|
2020-11-30 21:10:07 +00:00
|
|
|
etesync-dav = handleTest ./etesync-dav.nix {};
|
2021-07-27 14:14:24 +01:00
|
|
|
evcc = handleTest ./evcc.nix {};
|
2022-11-19 12:13:56 +00:00
|
|
|
fail2ban = handleTest ./fail2ban.nix { };
|
2023-06-18 01:59:06 +01:00
|
|
|
fakeroute = handleTest ./fakeroute.nix {};
|
2019-10-29 14:06:32 +00:00
|
|
|
fancontrol = handleTest ./fancontrol.nix {};
|
2023-07-25 18:45:54 +01:00
|
|
|
fanout = handleTest ./fanout.nix {};
|
2023-03-12 06:19:03 +00:00
|
|
|
fcitx5 = handleTest ./fcitx5 {};
|
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 09:40:11 +01:00
|
|
|
ferretdb = handleTest ./ferretdb.nix {};
|
2021-08-09 10:57:57 +01: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 15:15:57 +01: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 01:39:20 +01:00
|
|
|
firefox-esr-115 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-115; };
|
2020-08-07 17:45:20 +01: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 {};
|
2023-10-23 09:22:11 +01:00
|
|
|
floorp = handleTest ./firefox.nix { firefoxPackage = pkgs.floorp; };
|
2019-07-29 16:35:27 +01:00
|
|
|
fluentd = handleTest ./fluentd.nix {};
|
2021-08-21 21:51:01 +01:00
|
|
|
fluidd = handleTest ./fluidd.nix {};
|
2019-08-29 13:02:20 +01:00
|
|
|
fontconfig-default-fonts = handleTest ./fontconfig-default-fonts.nix {};
|
2023-08-06 17:41:37 +01:00
|
|
|
forgejo = handleTest ./forgejo.nix { };
|
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);
|
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 {};
|
2023-03-30 12:06:31 +01:00
|
|
|
frigate = handleTest ./frigate.nix {};
|
2023-09-13 14:24:47 +01:00
|
|
|
frp = handleTest ./frp.nix {};
|
2021-06-08 20:37:03 +01: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 18:40:38 +01:00
|
|
|
ft2-clone = handleTest ./ft2-clone.nix {};
|
2023-05-24 13:48:02 +01:00
|
|
|
legit = handleTest ./legit.nix {};
|
2022-06-07 11:53:15 +01:00
|
|
|
mimir = handleTest ./mimir.nix {};
|
2022-10-15 21:40:34 +01:00
|
|
|
garage = handleTest ./garage {};
|
2022-08-11 11:10:58 +01: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-20 00:15:28 +01: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 08:07:37 +01: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 {};
|
2019-08-17 00:28:43 +01:00
|
|
|
glusterfs = handleTest ./glusterfs.nix {};
|
2021-05-07 22:18:14 +01:00
|
|
|
gnome = handleTest ./gnome.nix {};
|
2023-10-15 14:57:54 +01:00
|
|
|
gnome-extensions = handleTest ./gnome-extensions.nix {};
|
2022-12-28 21:45:22 +00:00
|
|
|
gnome-flashback = handleTest ./gnome-flashback.nix {};
|
2021-05-07 22:18:14 +01:00
|
|
|
gnome-xorg = handleTest ./gnome-xorg.nix {};
|
2023-10-22 22:04:25 +01:00
|
|
|
gns3-server = handleTest ./gns3-server.nix {};
|
2023-02-02 17:17:40 +00:00
|
|
|
gnupg = handleTest ./gnupg.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
go-neb = handleTest ./go-neb.nix {};
|
2021-04-09 15:57:33 +01: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 17:01:37 +01:00
|
|
|
gollum = handleTest ./gollum.nix {};
|
2022-12-21 00:08:48 +00:00
|
|
|
gonic = handleTest ./gonic.nix {};
|
2019-05-17 02:29:17 +01:00
|
|
|
google-oslogin = handleTest ./google-oslogin {};
|
2023-10-25 12:54:47 +01:00
|
|
|
goss = handleTest ./goss.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
gotify-server = handleTest ./gotify-server.nix {};
|
2023-05-19 19:18:17 +01:00
|
|
|
gotosocial = runTest ./web-apps/gotosocial.nix;
|
2022-09-18 10:35:07 +01:00
|
|
|
grafana = handleTest ./grafana {};
|
2022-06-15 11:11:03 +01:00
|
|
|
grafana-agent = handleTest ./grafana-agent.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
graphite = handleTest ./graphite.nix {};
|
2019-07-09 01:01:43 +01:00
|
|
|
graylog = handleTest ./graylog.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
grocy = handleTest ./grocy.nix {};
|
2023-10-16 17:58:19 +01:00
|
|
|
grow-partition = runTest ./grow-partition.nix;
|
2020-06-13 11:06:26 +01:00
|
|
|
grub = handleTest ./grub.nix {};
|
2023-06-16 18:12:42 +01: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; };
|
|
|
|
|
hadoop_3_2 = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop_3_2; };
|
|
|
|
|
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 17:41:25 +01:00
|
|
|
harmonia = runTest ./harmonia.nix;
|
2022-12-01 15:47:24 +00:00
|
|
|
headscale = handleTest ./headscale.nix {};
|
2022-06-10 13:31:00 +01:00
|
|
|
healthchecks = handleTest ./web-apps/healthchecks.nix {};
|
2022-03-28 21:19:17 +01:00
|
|
|
hbase2 = handleTest ./hbase.nix { package=pkgs.hbase2; };
|
2022-09-30 17:43:14 +01:00
|
|
|
hbase_2_4 = handleTest ./hbase.nix { package=pkgs.hbase_2_4; };
|
2022-03-28 21:19:17 +01:00
|
|
|
hbase3 = handleTest ./hbase.nix { package=pkgs.hbase3; };
|
2023-06-25 17:35:47 +01: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 {};
|
2023-07-12 16:46:28 +01:00
|
|
|
homepage-dashboard = handleTest ./homepage-dashboard.nix {};
|
2023-08-17 17:08:48 +01:00
|
|
|
honk = runTest ./honk.nix;
|
2020-11-29 23:00:38 +00:00
|
|
|
installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});
|
2021-09-07 18:44:12 +01:00
|
|
|
invidious = handleTest ./invidious.nix {};
|
2023-10-24 17:53:12 +01:00
|
|
|
livebook-service = handleTest ./livebook-service.nix {};
|
2022-09-24 06:58:01 +01:00
|
|
|
oci-containers = handleTestOn ["aarch64-linux" "x86_64-linux"] ./oci-containers.nix {};
|
2021-11-02 00:48:47 +00:00
|
|
|
odoo = handleTest ./odoo.nix {};
|
2023-08-24 21:04:40 +01: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 12:48:20 +01: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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
hocker-fetchdocker = handleTest ./hocker-fetchdocker {};
|
2021-07-18 08:51:49 +01:00
|
|
|
hockeypuck = handleTest ./hockeypuck.nix { };
|
2018-11-11 11:30:07 +00:00
|
|
|
home-assistant = handleTest ./home-assistant.nix {};
|
2020-05-12 22:48:27 +01: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 02:03:59 +01:00
|
|
|
icingaweb2 = handleTest ./icingaweb2.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
iftop = handleTest ./iftop.nix {};
|
2018-11-14 22:51:15 +00:00
|
|
|
incron = handleTest ./incron.nix {};
|
2023-10-20 05:10:59 +01:00
|
|
|
incus = pkgs.recurseIntoAttrs (handleTest ./incus { inherit handleTestOn; });
|
2018-11-11 11:30:07 +00:00
|
|
|
influxdb = handleTest ./influxdb.nix {};
|
2023-08-14 23:26:41 +01: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 22:24:13 +01:00
|
|
|
installer-systemd-stage-1 = handleTest ./installer-systemd-stage-1.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 18:55:42 +01: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 10:57:34 +01: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 19:00:24 +01: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 17:50:08 +01:00
|
|
|
jool = import ./jool.nix { inherit pkgs runTest; };
|
2022-07-22 07:13:20 +01:00
|
|
|
k3s = handleTest ./k3s {};
|
2019-04-01 13:39:25 +01:00
|
|
|
kafka = handleTest ./kafka.nix {};
|
2022-05-05 11:09:42 +01:00
|
|
|
kanidm = handleTest ./kanidm.nix {};
|
2022-10-10 06:16:25 +01:00
|
|
|
karma = handleTest ./karma.nix {};
|
2023-04-30 04:27:25 +01:00
|
|
|
kavita = handleTest ./kavita.nix {};
|
2021-05-30 19:37:14 +01:00
|
|
|
kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};
|
2021-07-19 20:21:02 +01:00
|
|
|
kbd-update-search-paths-patch = handleTest ./kbd-update-search-paths-patch.nix {};
|
2021-07-13 23:43:17 +01: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 16:57:58 +01: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 {};
|
2022-05-18 14:41:54 +01:00
|
|
|
keter = handleTest ./keter.nix {};
|
2021-10-24 23:20:46 +01: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 {};
|
2019-03-13 00:12:56 +00:00
|
|
|
knot = handleTest ./knot.nix {};
|
2022-08-12 22:52:52 +01:00
|
|
|
komga = handleTest ./komga.nix {};
|
2020-02-14 08:56:43 +00:00
|
|
|
krb5 = discoverTests (import ./krb5 {});
|
2021-02-26 12:06:18 +00:00
|
|
|
ksm = handleTest ./ksm.nix {};
|
2022-09-25 19:46:03 +01:00
|
|
|
kthxbye = handleTest ./kthxbye.nix {};
|
2021-07-30 16:16:23 +01:00
|
|
|
kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};
|
2023-10-08 17:56:05 +01:00
|
|
|
kubo = import ./kubo { inherit recurseIntoAttrs runTest; };
|
2022-08-16 14:03:37 +01:00
|
|
|
ladybird = handleTest ./ladybird.nix {};
|
2022-08-16 19:33:08 +01:00
|
|
|
languagetool = handleTest ./languagetool.nix {};
|
2023-09-17 16:12:55 +01: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 10:02:51 +01:00
|
|
|
lemmy = handleTest ./lemmy.nix {};
|
2021-11-15 11:46:20 +00:00
|
|
|
libinput = handleTest ./libinput.nix {};
|
2021-04-19 00:05:25 +01:00
|
|
|
libreddit = handleTest ./libreddit.nix {};
|
2023-10-05 15:09:58 +01:00
|
|
|
librenms = handleTest ./librenms.nix {};
|
2021-11-18 18:10:48 +00:00
|
|
|
libresprite = handleTest ./libresprite.nix {};
|
2021-05-15 22:22:03 +01:00
|
|
|
libreswan = handleTest ./libreswan.nix {};
|
2022-07-09 01:40:24 +01:00
|
|
|
librewolf = handleTest ./firefox.nix { firefoxPackage = pkgs.librewolf; };
|
2022-07-15 21:00:28 +01:00
|
|
|
libuiohook = handleTest ./libuiohook.nix {};
|
2022-08-22 04:17:06 +01:00
|
|
|
libvirtd = handleTest ./libvirtd.nix {};
|
2021-11-15 11:46:20 +00:00
|
|
|
lidarr = handleTest ./lidarr.nix {};
|
2019-08-06 23:29:50 +01:00
|
|
|
lightdm = handleTest ./lightdm.nix {};
|
2022-07-24 16:04:12 +01:00
|
|
|
lighttpd = handleTest ./lighttpd.nix {};
|
2019-03-16 12:24:23 +00:00
|
|
|
limesurvey = handleTest ./limesurvey.nix {};
|
2023-08-23 16:50:28 +01:00
|
|
|
listmonk = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./listmonk.nix {};
|
2021-07-30 16:41:54 +01:00
|
|
|
litestream = handleTest ./litestream.nix {};
|
2023-04-27 14:26:57 +01:00
|
|
|
lldap = handleTest ./lldap.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 17:11:09 +01: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 {};
|
2023-09-04 20:19:34 +01:00
|
|
|
lxd = pkgs.recurseIntoAttrs (handleTest ./lxd { inherit handleTestOn; });
|
2021-10-20 22:39:53 +01:00
|
|
|
lxd-image-server = handleTest ./lxd-image-server.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
#logstash = handleTest ./logstash.nix {};
|
2019-11-05 10:57:05 +00:00
|
|
|
lorri = handleTest ./lorri/default.nix {};
|
2023-04-21 07:59:13 +01:00
|
|
|
maddy = discoverTests (import ./maddy { inherit handleTest; });
|
2022-04-01 03:41:31 +01:00
|
|
|
maestral = handleTest ./maestral.nix {};
|
2020-03-30 12:30:05 +01: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 {};
|
2023-02-09 17:56:56 +00:00
|
|
|
mailman = handleTest ./mailman.nix {};
|
2021-09-24 19:54:08 +01:00
|
|
|
man = handleTest ./man.nix {};
|
2021-12-08 09:47:07 +00:00
|
|
|
mariadb-galera = handleTest ./mysql/mariadb-galera.nix {};
|
2022-03-22 07:52:13 +00:00
|
|
|
mastodon = discoverTests (import ./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 {};
|
2019-10-04 21:38:58 +01:00
|
|
|
matomo = handleTest ./matomo.nix {};
|
2022-05-13 08:46:01 +01:00
|
|
|
matrix-appservice-irc = handleTest ./matrix/appservice-irc.nix {};
|
|
|
|
|
matrix-conduit = handleTest ./matrix/conduit.nix {};
|
|
|
|
|
matrix-synapse = handleTest ./matrix/synapse.nix {};
|
2023-07-07 10:27:55 +01:00
|
|
|
matrix-synapse-workers = handleTest ./matrix/synapse-workers.nix {};
|
2021-04-12 02:29:29 +01:00
|
|
|
mattermost = handleTest ./mattermost.nix {};
|
2023-08-10 19:43:26 +01:00
|
|
|
mediamtx = handleTest ./mediamtx.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
mediatomb = handleTest ./mediatomb.nix {};
|
2019-06-06 02:19:11 +01:00
|
|
|
mediawiki = handleTest ./mediawiki.nix {};
|
2020-04-07 10:00:43 +01:00
|
|
|
meilisearch = handleTest ./meilisearch.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
memcached = handleTest ./memcached.nix {};
|
2022-10-19 09:49:57 +01:00
|
|
|
merecat = handleTest ./merecat.nix {};
|
2019-08-18 08:28:16 +01:00
|
|
|
metabase = handleTest ./metabase.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 {};
|
2023-02-04 01:23:14 +00:00
|
|
|
miriway = handleTest ./miriway.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
misc = handleTest ./misc.nix {};
|
2021-05-30 16:33:09 +01:00
|
|
|
mjolnir = handleTest ./matrix/mjolnir.nix {};
|
2023-09-05 16:53:09 +01:00
|
|
|
mobilizon = handleTest ./mobilizon.nix {};
|
2021-08-13 19:55:15 +01:00
|
|
|
mod_perl = handleTest ./mod_perl.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
molly-brown = handleTest ./molly-brown.nix {};
|
2023-04-16 10:21:57 +01:00
|
|
|
monica = handleTest ./web-apps/monica.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
mongodb = handleTest ./mongodb.nix {};
|
2019-06-21 15:09:15 +01:00
|
|
|
moodle = handleTest ./moodle.nix {};
|
2022-03-22 22:35:39 +00:00
|
|
|
moonraker = handleTest ./moonraker.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
morty = handleTest ./morty.nix {};
|
2019-04-24 09:23:13 +01:00
|
|
|
mosquitto = handleTest ./mosquitto.nix {};
|
2021-10-06 20:51:07 +01:00
|
|
|
moosefs = handleTest ./moosefs.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
mpd = handleTest ./mpd.nix {};
|
2021-07-31 23:44:02 +01: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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
munin = handleTest ./munin.nix {};
|
|
|
|
|
mutableUsers = handleTest ./mutable-users.nix {};
|
2019-05-18 21:18:01 +01:00
|
|
|
mxisd = handleTest ./mxisd.nix {};
|
2023-12-18 21:31:29 +00:00
|
|
|
mympd = handleTest ./mympd.nix {};
|
2020-04-02 21:40:55 +01: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 {};
|
2019-12-30 12:00:00 +00:00
|
|
|
nagios = handleTest ./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 12:58:40 +01: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 22:59:12 +01:00
|
|
|
ncdns = handleTest ./ncdns.nix {};
|
2019-02-03 15:47:01 +00:00
|
|
|
ndppd = handleTest ./ndppd.nix {};
|
2021-03-05 05:28:58 +00:00
|
|
|
nebula = handleTest ./nebula.nix {};
|
2022-08-14 17:59:15 +01:00
|
|
|
netbird = handleTest ./netbird.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 {};
|
|
|
|
|
networking.networkd = handleTest ./networking.nix { networkd = true; };
|
|
|
|
|
networking.scripted = handleTest ./networking.nix { networkd = false; };
|
2023-09-24 08:51:26 +01:00
|
|
|
netbox_3_5 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_5; };
|
2023-09-24 09:06:08 +01:00
|
|
|
netbox_3_6 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_6; };
|
2023-07-31 13:56:05 +01: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 {};
|
|
|
|
|
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 17:05:41 +01: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 11:22:39 +01:00
|
|
|
nginx-http3 = handleTest ./nginx-http3.nix {};
|
2022-02-14 23:10:37 +00:00
|
|
|
nginx-modsecurity = handleTest ./nginx-modsecurity.nix {};
|
2022-09-18 13:54:04 +01:00
|
|
|
nginx-njs = handleTest ./nginx-njs.nix {};
|
2023-07-28 19:30:43 +01: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 18:36:55 +01:00
|
|
|
nginx-status-page = handleTest ./nginx-status-page.nix {};
|
2023-10-06 13:26:06 +01:00
|
|
|
nginx-tmpdir = handleTest ./nginx-tmpdir.nix {};
|
2023-07-07 16:52:37 +01:00
|
|
|
nginx-unix-socket = handleTest ./nginx-unix-socket.nix {};
|
2020-06-02 06:01:03 +01:00
|
|
|
nginx-variants = handleTest ./nginx-variants.nix {};
|
2022-04-10 18:41:30 +01:00
|
|
|
nifi = handleTestOn ["x86_64-linux"] ./web-apps/nifi.nix {};
|
2021-07-26 11:00:05 +01:00
|
|
|
nitter = handleTest ./nitter.nix {};
|
2022-04-11 19:51:29 +01:00
|
|
|
nix-ld = handleTest ./nix-ld.nix {};
|
2021-12-03 16:19:42 +00:00
|
|
|
nix-serve = handleTest ./nix-serve.nix {};
|
|
|
|
|
nix-serve-ssh = handleTest ./nix-serve-ssh.nix {};
|
2021-10-17 23:38:58 +01:00
|
|
|
nixops = handleTest ./nixops/default.nix {};
|
2019-08-07 17:04:18 +01:00
|
|
|
nixos-generate-config = handleTest ./nixos-generate-config.nix {};
|
2023-10-23 11:00:20 +01:00
|
|
|
nixos-rebuild-install-bootloader = handleTestOn ["x86_64-linux"] ./nixos-rebuild-install-bootloader.nix {};
|
2023-10-23 22:32:37 +01:00
|
|
|
nixos-rebuild-specialisations = handleTestOn ["x86_64-linux"] ./nixos-rebuild-specialisations.nix {};
|
2024-01-03 10:51:08 +00:00
|
|
|
nixos-rebuild-target-host = handleTest ./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 11:42:26 +01:00
|
|
|
node-red = handleTest ./node-red.nix {};
|
2021-01-23 22:52:19 +00:00
|
|
|
nomad = handleTest ./nomad.nix {};
|
2022-06-22 03:10:44 +01:00
|
|
|
non-default-filesystems = handleTest ./non-default-filesystems.nix {};
|
2023-10-14 00:29:05 +01: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 10:40:33 +01:00
|
|
|
nscd = handleTest ./nscd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
nsd = handleTest ./nsd.nix {};
|
2022-09-01 13:36:19 +01:00
|
|
|
ntfy-sh = handleTest ./ntfy-sh.nix {};
|
2024-01-09 21:03:21 +00:00
|
|
|
ntfy-sh-migration = handleTest ./ntfy-sh-migration.nix {};
|
2023-10-31 14:28:49 +00:00
|
|
|
ntpd-rs = handleTest ./ntpd-rs.nix {};
|
2019-04-22 13:06:33 +01:00
|
|
|
nzbget = handleTest ./nzbget.nix {};
|
2020-10-04 15:06:53 +01:00
|
|
|
nzbhydra2 = handleTest ./nzbhydra2.nix {};
|
2020-11-05 01:37:50 +00:00
|
|
|
oh-my-zsh = handleTest ./oh-my-zsh.nix {};
|
2021-03-29 15:51:05 +01:00
|
|
|
ombi = handleTest ./ombi.nix {};
|
2019-10-22 15:20:56 +01: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 04:36:02 +01:00
|
|
|
openresty-lua = handleTest ./openresty-lua.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
opensmtpd = handleTest ./opensmtpd.nix {};
|
2021-05-19 21:37:49 +01:00
|
|
|
opensmtpd-rspamd = handleTest ./opensmtpd-rspamd.nix {};
|
2023-08-08 21:00:52 +01: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 18:31:47 +01:00
|
|
|
opentelemetry-collector = handleTest ./opentelemetry-collector.nix {};
|
2023-11-02 00:28:20 +00:00
|
|
|
ocsinventory-agent = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./ocsinventory-agent.nix {};
|
2021-09-23 09:48:29 +01:00
|
|
|
owncast = handleTest ./owncast.nix {};
|
2023-05-17 12:10:57 +01:00
|
|
|
outline = handleTest ./outline.nix {};
|
2020-12-20 20:18:54 +00:00
|
|
|
image-contents = handleTest ./image-contents.nix {};
|
2023-05-15 14:33:37 +01:00
|
|
|
openvscode-server = handleTest ./openvscode-server.nix {};
|
2019-08-20 23:27:14 +01:00
|
|
|
orangefs = handleTest ./orangefs.nix {};
|
2019-06-09 19:26:05 +01:00
|
|
|
os-prober = handleTestOn ["x86_64-linux"] ./os-prober.nix {};
|
2023-07-19 10:59:22 +01: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 09:45:29 +01: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 20:30:01 +01:00
|
|
|
pam-zfs-key = handleTest ./pam/zfs-key.nix {};
|
2022-04-16 06:18:57 +01: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 16:32:41 +01:00
|
|
|
pantalaimon = handleTest ./matrix/pantalaimon.nix {};
|
2019-01-24 22:33:05 +00:00
|
|
|
pantheon = handleTest ./pantheon.nix {};
|
2022-04-12 16:48:53 +01:00
|
|
|
paperless = handleTest ./paperless.nix {};
|
2021-06-02 17:19:37 +01: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 12:23:06 +01: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 13:22:12 +01:00
|
|
|
pgadmin4 = handleTest ./pgadmin4.nix {};
|
2023-07-22 11:49:23 +01:00
|
|
|
pgbouncer = handleTest ./pgbouncer.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
pgjwt = handleTest ./pgjwt.nix {};
|
|
|
|
|
pgmanage = handleTest ./pgmanage.nix {};
|
2022-08-02 20:34:37 +01:00
|
|
|
phosh = handleTest ./phosh.nix {};
|
2023-01-14 23:16:35 +00:00
|
|
|
photoprism = handleTest ./photoprism.nix {};
|
2020-03-30 21:07:05 +01: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 19:51:23 +01:00
|
|
|
php83 = handleTest ./php { php = pkgs.php83; };
|
2022-06-28 20:17:38 +01:00
|
|
|
phylactery = handleTest ./web-apps/phylactery.nix {};
|
2022-01-23 11:11:05 +00:00
|
|
|
pict-rs = handleTest ./pict-rs.nix {};
|
2020-06-03 22:12:06 +01:00
|
|
|
pinnwand = handleTest ./pinnwand.nix {};
|
2023-11-14 22:09:23 +00:00
|
|
|
plantuml-server = handleTest ./plantuml-server.nix {};
|
2022-09-17 14:02:37 +01:00
|
|
|
plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
plasma5 = handleTest ./plasma5.nix {};
|
2021-10-31 20:34:10 +00:00
|
|
|
plasma5-systemd-start = handleTest ./plasma5-systemd-start.nix {};
|
2021-05-21 22:15:23 +01:00
|
|
|
plausible = handleTest ./plausible.nix {};
|
2022-09-29 22:12:29 +01: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 18:15:41 +01:00
|
|
|
podgrab = handleTest ./podgrab.nix {};
|
2022-09-24 06:58:15 +01: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 19:04:54 +01:00
|
|
|
polaris = handleTest ./polaris.nix {};
|
2021-01-08 03:03:00 +00:00
|
|
|
pomerium = handleTestOn ["x86_64-linux"] ./pomerium.nix {};
|
2023-05-21 17:53:52 +01:00
|
|
|
portunus = handleTest ./portunus.nix { };
|
2020-07-06 02:37:56 +01:00
|
|
|
postfix = handleTest ./postfix.nix {};
|
|
|
|
|
postfix-raise-smtpd-tls-security-level = handleTest ./postfix-raise-smtpd-tls-security-level.nix {};
|
2021-05-19 05:34:03 +01:00
|
|
|
postfixadmin = handleTest ./postfixadmin.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
postgis = handleTest ./postgis.nix {};
|
2023-05-30 10:39:25 +01:00
|
|
|
apache_datasketches = handleTest ./apache_datasketches.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
postgresql = handleTest ./postgresql.nix {};
|
postgresql: implement opt-in JIT support
Closes #150801
Note: I decided against resuming directly on #150801 because the
conflict was too big (and resolving it seemed too error-prone to me).
Also the `this`-refactoring could be done in an easier manner, i.e. by
exposing JIT attributes with the correct configuration. More on that
below.
This patch creates variants of the `postgresql*`-packages with JIT[1]
support. Please note that a lot of the work was derived from previous
patches filed by other contributors, namely dasJ, andir and abbradar,
hence the co-authored-by tags below.
Effectively, the following things have changed:
* For JIT variants an LLVM-backed stdenv with clang is now used as
suggested by dasJ[2]. We need LLVM and CLang[3] anyways to build the
JIT-part, so no need to mix this up with GCC's stdenv. Also, using the
`dev`-output of LLVM and clang's stdenv for building (and adding llvm
libs as build-inputs) seems more cross friendly to me (which will
become useful when cross-building for JIT-variants will actually be
supported).
* Plugins inherit the build flags from the Makefiles in
`$out/lib/pgxs/src` (e.g. `-Werror=unguarded-availability-new`). Since
some of the flags are clang-specific (and stem from the use of the
CLang stdenv) and don't work on gcc, the stdenv of `pkgs.postgresql`
is passed to the plugins. I.e., plugins for non-JIT variants are built
with a gcc stdenv on Linux and plugins for JIT variants with a clang
stdenv.
Since `plv8` hard-codes `gcc` as `$CC` in its Makefile[4], I marked it
as broken for JIT-variants of postgresql only.
* Added a test-matrix to confirm that JIT works fine on each
`pkgs.postgresql_*_jit` (thanks Andi for the original test in
#124804!).
* For each postgresql version, a new attribute
`postgresql_<version>_jit` (and a corresponding
`postgresqlPackages<version>JitPackages`) are now exposed for better
discoverability and prebuilt artifacts in the binary cache.
* In #150801 the `this`-argument was replaced by an internal recursion.
I decided against this approach because it'd blow up the diff even
more which makes the readability way harder and also harder to revert
this if necessary.
Instead, it is made sure that `this` always points to the correct
variant of `postgresql` and re-using that in an additional
`.override {}`-expression is trivial because the JIT-variant is
exposed in `all-packages.nix`.
* I think the changes are sufficiently big to actually add myself as
maintainer here.
* Added `libxcrypt` to `buildInputs` for versions <v13. While
building things with an LLVM stdenv, these versions complained that
the extern `crypt()` symbol can't be found. Not sure what this is
exactly about, but since we want to switch to libxcrypt for `crypt()`
usage anyways[5] I decided to add it. For >=13 it's not relevant
anymore anyways[6].
* JIT support doesn't work with cross-compilation. It is attempted to
build LLVM-bytecode (`%.bc` is the corresponding `make(1)`-rule) for
each sub-directory in `backend/` for the JIT apparently, but with a
$(CLANG) that can produce binaries for the build, not the host-platform.
I managed to get a cross-build with JIT support working with
`depsBuildBuild = [ llvmPackages.clang ] ++ buildInputs`, but
considering that the resulting LLVM IR isn't platform-independent this
doesn't give you much. In fact, I tried to test the result in a VM-test,
but as soon as JIT was used to optimize a query, postgres would
coredump with `Illegal instruction`.
A common concern of the original approach - with llvm as build input -
was the massive increase of closure size. With the new approach of using
the LLVM stdenv directly and patching out references to the clang drv in
`$out` the effective closure size changes are:
$ nix path-info -Sh $(nix-build -A postgresql_14)
/nix/store/kssxxqycwa3c7kmwmykwxqvspxxa6r1w-postgresql-14.7 306.4M
$ nix path-info -Sh $(nix-build -A postgresql_14_jit)
/nix/store/xc7qmgqrn4h5yr4vmdwy56gs4bmja9ym-postgresql-14.7 689.2M
Most of the increase in closure-size stems from the `lib`-output of
LLVM
$ nix path-info -Sh /nix/store/5r97sbs5j6mw7qnbg8nhnq1gad9973ap-llvm-11.1.0-lib
/nix/store/5r97sbs5j6mw7qnbg8nhnq1gad9973ap-llvm-11.1.0-lib 349.8M
which is why this shouldn't be enabled by default.
While this is quite much because of LLVM, it's still a massive
improvement over the simple approach of adding llvm/clang as
build-inputs and building with `--with-llvm`:
$ nix path-info -Sh $(nix-build -E '
with import ./. {};
postgresql.overrideAttrs ({ configureFlags ? [], buildInputs ? [], ... }: {
configureFlags = configureFlags ++ [ "--with-llvm" ];
buildInputs = buildInputs ++ [ llvm clang ];
})' -j0)
/nix/store/i3bd2r21c6c3428xb4gavjnplfqxn27p-postgresql-14.7 1.6G
Co-authored-by: Andreas Rammhold <andreas@rammhold.de>
Co-authored-by: Janne Heß <janne@hess.ooo>
Co-authored-by: Nikolay Amiantov <ab@fmap.me>
[1] https://www.postgresql.org/docs/current/jit-reason.html
[2] https://github.com/NixOS/nixpkgs/pull/124804#issuecomment-864616931
& https://github.com/NixOS/nixpkgs/pull/150801#issuecomment-1467868321
[3] This fails with the following error otherwise:
```
configure: error: clang not found, but required when compiling --with-llvm, specify with CLANG=
```
[4] https://github.com/plv8/plv8/blob/v3.1.5/Makefile#L14
[5] https://github.com/NixOS/nixpkgs/pull/181764
[6] https://github.com/postgres/postgres/commit/c45643d618e35ec2fe91438df15abd4f3c0d85ca
2023-03-18 08:54:54 +00:00
|
|
|
postgresql-jit = handleTest ./postgresql-jit.nix {};
|
2019-08-11 18:09:42 +01:00
|
|
|
postgresql-wal-receiver = handleTest ./postgresql-wal-receiver.nix {};
|
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 05:15:27 +01:00
|
|
|
power-profiles-daemon = handleTest ./power-profiles-daemon.nix {};
|
2019-10-15 05:26:54 +01:00
|
|
|
pppd = handleTest ./pppd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
predictable-interface-names = handleTest ./predictable-interface-names.nix {};
|
2022-12-07 14:52:08 +00:00
|
|
|
printing-socket = handleTest ./printing.nix { socket = true; };
|
|
|
|
|
printing-service = handleTest ./printing.nix { socket = false; };
|
2021-03-03 16:18:09 +00:00
|
|
|
privoxy = handleTest ./privoxy.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
prometheus = handleTest ./prometheus.nix {};
|
|
|
|
|
prometheus-exporters = handleTest ./prometheus-exporters.nix {};
|
2019-06-15 10:16:28 +01: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 16:54:22 +01:00
|
|
|
prowlarr = handleTest ./prowlarr.nix {};
|
2020-07-29 18:00:33 +01:00
|
|
|
pt2-clone = handleTest ./pt2-clone.nix {};
|
2022-06-26 23:20:04 +01:00
|
|
|
pykms = handleTest ./pykms.nix {};
|
2021-12-01 10:06:18 +00:00
|
|
|
public-inbox = handleTest ./public-inbox.nix {};
|
2023-04-07 07:34:25 +01:00
|
|
|
pufferpanel = handleTest ./pufferpanel.nix {};
|
2021-11-30 13:51:06 +00:00
|
|
|
pulseaudio = discoverTests (import ./pulseaudio.nix);
|
2020-05-22 04:15:32 +01: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-21 00:38:27 +01:00
|
|
|
qemu-vm-volatile-root = runTest ./qemu-vm-volatile-root.nix;
|
2023-06-20 23:19:21 +01:00
|
|
|
qemu-vm-external-disk-image = runTest ./qemu-vm-external-disk-image.nix;
|
2023-08-28 16:59:16 +01:00
|
|
|
qgis = handleTest ./qgis.nix { qgisPackage = pkgs.qgis; };
|
|
|
|
|
qgis-ltr = handleTest ./qgis.nix { qgisPackage = pkgs.qgis-ltr; };
|
2023-06-16 07:19:47 +01:00
|
|
|
qownnotes = handleTest ./qownnotes.nix {};
|
2023-08-28 16:59:16 +01:00
|
|
|
quake3 = handleTest ./quake3.nix {};
|
2023-11-01 18:48:51 +00:00
|
|
|
quicktun = handleTest ./quicktun.nix {};
|
2023-08-28 16:59:16 +01: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 {};
|
2023-08-08 10:53:51 +01:00
|
|
|
ragnarwm = handleTest ./ragnarwm.nix {};
|
2021-02-02 00:39:50 +00:00
|
|
|
rasdaemon = handleTest ./rasdaemon.nix {};
|
2023-03-12 19:54:23 +00:00
|
|
|
readarr = handleTest ./readarr.nix {};
|
2019-08-31 19:17:33 +01:00
|
|
|
redis = handleTest ./redis.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
redmine = handleTest ./redmine.nix {};
|
2021-09-08 20:02:28 +01:00
|
|
|
restartByActivationScript = handleTest ./restart-by-activation-script.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 {};
|
2023-10-05 13:32:38 +01:00
|
|
|
rkvm = handleTest ./rkvm {};
|
2020-08-30 17:31:54 +01:00
|
|
|
robustirc-bridge = handleTest ./robustirc-bridge.nix {};
|
2018-11-28 16:33:26 +00:00
|
|
|
roundcube = handleTest ./roundcube.nix {};
|
2023-10-23 18:29:30 +01:00
|
|
|
rosenpass = handleTest ./rosenpass.nix {};
|
2023-05-15 13:09:28 +01:00
|
|
|
rshim = handleTest ./rshim.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rspamd = handleTest ./rspamd.nix {};
|
2023-10-18 10:47:00 +01:00
|
|
|
rspamd-trainer = handleTest ./rspamd-trainer.nix {};
|
2018-10-27 10:33:43 +01: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 {};
|
|
|
|
|
rxe = handleTest ./rxe.nix {};
|
2021-09-21 12:38:22 +01: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 {};
|
2019-10-27 03:37:30 +00:00
|
|
|
sanoid = handleTest ./sanoid.nix {};
|
2023-06-26 18:41:28 +01:00
|
|
|
scaphandre = handleTest ./scaphandre.nix {};
|
2022-05-31 16:27:54 +01:00
|
|
|
schleuder = handleTest ./schleuder.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 {};
|
2020-11-02 00:34:53 +00:00
|
|
|
searx = handleTest ./searx.nix {};
|
2023-08-25 06:29:57 +01:00
|
|
|
seatd = handleTest ./seatd.nix {};
|
2020-02-28 11:17:01 +00:00
|
|
|
service-runner = handleTest ./service-runner.nix {};
|
2023-04-19 14:13:54 +01:00
|
|
|
sftpgo = runTest ./sftpgo.nix;
|
2022-03-20 21:39:04 +00:00
|
|
|
sfxr-qt = handleTest ./sfxr-qt.nix {};
|
2023-10-06 11:36:48 +01:00
|
|
|
sgt-puzzles = handleTest ./sgt-puzzles.nix {};
|
2020-12-23 18:28:30 +00:00
|
|
|
shadow = handleTest ./shadow.nix {};
|
2020-09-08 23:15:59 +01:00
|
|
|
shadowsocks = handleTest ./shadowsocks {};
|
2020-08-09 14:20:17 +01:00
|
|
|
shattered-pixel-dungeon = handleTest ./shattered-pixel-dungeon.nix {};
|
2019-11-08 17:17:08 +00:00
|
|
|
shiori = handleTest ./shiori.nix {};
|
2019-05-22 23:50:51 +01:00
|
|
|
signal-desktop = handleTest ./signal-desktop.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
simple = handleTest ./simple.nix {};
|
2023-06-27 05:58:10 +01: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 13:47:36 +01:00
|
|
|
snapcast = handleTest ./snapcast.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
snapper = handleTest ./snapper.nix {};
|
2023-04-26 16:46:15 +01:00
|
|
|
snipe-it = runTest ./web-apps/snipe-it.nix;
|
2022-01-23 11:11:05 +00:00
|
|
|
soapui = handleTest ./soapui.nix {};
|
2023-07-08 00:44:42 +01:00
|
|
|
soft-serve = handleTest ./soft-serve.nix {};
|
2020-05-12 17:32:39 +01:00
|
|
|
sogo = handleTest ./sogo.nix {};
|
2021-05-20 21:03:39 +01: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 {};
|
2021-08-28 18:46:05 +01:00
|
|
|
sourcehut = handleTest ./sourcehut.nix {};
|
2019-05-24 20:17:51 +01:00
|
|
|
spacecookie = handleTest ./spacecookie.nix {};
|
2022-02-08 13:59:23 +00:00
|
|
|
spark = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./spark {};
|
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 09:31:39 +01:00
|
|
|
ssh-audit = handleTest ./ssh-audit.nix {};
|
2023-10-18 17:25:11 +01:00
|
|
|
sssd = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd.nix {};
|
|
|
|
|
sssd-ldap = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd-ldap.nix {};
|
2023-09-02 19:27:11 +01:00
|
|
|
stalwart-mail = handleTest ./stalwart-mail.nix {};
|
2023-04-17 00:24:06 +01:00
|
|
|
stargazer = runTest ./web-servers/stargazer.nix;
|
2021-12-24 11:24:29 +00:00
|
|
|
starship = handleTest ./starship.nix {};
|
2023-07-01 17:17:39 +01: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 08:18:11 +01: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 16:53:18 +01:00
|
|
|
sudo-rs = handleTest ./sudo-rs.nix {};
|
2022-10-04 04:08:46 +01:00
|
|
|
swap-file-btrfs = handleTest ./swap-file-btrfs.nix {};
|
2022-06-22 03:11:23 +01:00
|
|
|
swap-partition = handleTest ./swap-partition.nix {};
|
2023-05-03 21:11:45 +01:00
|
|
|
swap-random-encryption = handleTest ./swap-random-encryption.nix {};
|
2021-05-27 19:37:24 +01:00
|
|
|
sway = handleTest ./sway.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
switchTest = handleTest ./switch-test.nix {};
|
2019-07-06 19:56:30 +01:00
|
|
|
sympa = handleTest ./sympa.nix {};
|
2020-07-23 08:13:26 +01:00
|
|
|
syncthing = handleTest ./syncthing.nix {};
|
2023-05-23 14:58:38 +01:00
|
|
|
syncthing-no-settings = handleTest ./syncthing-no-settings.nix {};
|
2019-04-21 22:05:07 +01:00
|
|
|
syncthing-init = handleTest ./syncthing-init.nix {};
|
2023-10-14 19:32:24 +01: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 10:16:56 +01:00
|
|
|
systemd-binfmt = handleTestOn ["x86_64-linux"] ./systemd-binfmt.nix {};
|
2020-06-14 04:57:52 +01:00
|
|
|
systemd-boot = handleTest ./systemd-boot.nix {};
|
2022-08-21 11:22:16 +01:00
|
|
|
systemd-bpf = handleTest ./systemd-bpf.nix {};
|
2019-03-14 14:26:10 +00:00
|
|
|
systemd-confinement = handleTest ./systemd-confinement.nix {};
|
2022-08-01 17:44:29 +01:00
|
|
|
systemd-coredump = handleTest ./systemd-coredump.nix {};
|
2021-10-04 11:54:13 +01: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 18:11:20 +01:00
|
|
|
systemd-initrd-bridge = handleTest ./systemd-initrd-bridge.nix {};
|
2022-04-17 13:55:48 +01:00
|
|
|
systemd-initrd-btrfs-raid = handleTest ./systemd-initrd-btrfs-raid.nix {};
|
2022-10-03 18:10:03 +01:00
|
|
|
systemd-initrd-luks-fido2 = handleTest ./systemd-initrd-luks-fido2.nix {};
|
2022-04-13 22:27:58 +01: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 19:45:29 +01:00
|
|
|
systemd-initrd-luks-password = handleTest ./systemd-initrd-luks-password.nix {};
|
2022-09-23 22:47:05 +01: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 01:37:51 +01:00
|
|
|
systemd-initrd-modprobe = handleTest ./systemd-initrd-modprobe.nix {};
|
2022-04-15 11:23:02 +01: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 16:28:41 +01: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 06:01:59 +01:00
|
|
|
systemd-initrd-networkd = handleTest ./systemd-initrd-networkd.nix {};
|
2022-08-03 11:36:11 +01: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 04:57:46 +01: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 13:54:10 +01:00
|
|
|
systemd-journal-gateway = handleTest ./systemd-journal-gateway.nix {};
|
2022-09-01 13:55:30 +01:00
|
|
|
systemd-journal-upload = handleTest ./systemd-journal-upload.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 {};
|
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 14:12:19 +01: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 17:19:38 +01: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 10:34:33 +01:00
|
|
|
systemd-nspawn-configfile = handleTest ./systemd-nspawn-configfile.nix {};
|
2022-04-21 18:54:50 +01:00
|
|
|
systemd-oomd = handleTest ./systemd-oomd.nix {};
|
2022-09-29 11:57:18 +01:00
|
|
|
systemd-portabled = handleTest ./systemd-portabled.nix {};
|
2023-01-19 19:04:29 +00:00
|
|
|
systemd-repart = handleTest ./systemd-repart.nix {};
|
2022-04-15 11:23:02 +01:00
|
|
|
systemd-shutdown = handleTest ./systemd-shutdown.nix {};
|
2023-07-17 16:20:32 +01:00
|
|
|
systemd-sysupdate = runTest ./systemd-sysupdate.nix;
|
2020-11-29 23:00:38 +00:00
|
|
|
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
|
2023-06-22 13:17:42 +01:00
|
|
|
systemd-timesyncd-nscd-dnssec = handleTest ./systemd-timesyncd-nscd-dnssec.nix {};
|
2022-12-23 20:22:49 +00:00
|
|
|
systemd-user-tmpfiles-rules = handleTest ./systemd-user-tmpfiles-rules.nix {};
|
2021-08-11 19:28:30 +01: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 15:36:39 +01:00
|
|
|
tandoor-recipes = handleTest ./tandoor-recipes.nix {};
|
2023-10-16 12:10:15 +01:00
|
|
|
tang = handleTest ./tang.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
taskserver = handleTest ./taskserver.nix {};
|
2022-10-12 20:16:02 +01:00
|
|
|
tayga = handleTest ./tayga.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 {};
|
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 {};
|
2019-04-29 21:46:00 +01:00
|
|
|
tiddlywiki = handleTest ./tiddlywiki.nix {};
|
2020-04-13 04:56:20 +01:00
|
|
|
tigervnc = handleTest ./tigervnc.nix {};
|
2022-10-31 08:21:18 +00:00
|
|
|
timescaledb = handleTest ./timescaledb.nix {};
|
2023-03-20 08:13:09 +00:00
|
|
|
promscale = handleTest ./promscale.nix {};
|
2019-12-02 22:28:53 +00:00
|
|
|
timezone = handleTest ./timezone.nix {};
|
2020-12-06 15:05:21 +00:00
|
|
|
tinc = handleTest ./tinc {};
|
2019-05-16 22:42:02 +01:00
|
|
|
tinydns = handleTest ./tinydns.nix {};
|
2023-05-05 20:02:11 +01:00
|
|
|
tinyproxy = handleTest ./tinyproxy.nix {};
|
2021-12-28 20:32:26 +00:00
|
|
|
tinywl = handleTest ./tinywl.nix {};
|
2022-10-05 17:34:30 +01: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 08:43:38 +01:00
|
|
|
traefik = handleTestOn ["aarch64-linux" "x86_64-linux"] ./traefik.nix {};
|
2021-04-09 17:48:51 +01:00
|
|
|
trafficserver = handleTest ./trafficserver.nix {};
|
2023-09-23 12:27:17 +01:00
|
|
|
transmission = handleTest ./transmission.nix { transmission = pkgs.transmission; };
|
|
|
|
|
transmission_4 = handleTest ./transmission.nix { transmission = pkgs.transmission_4; };
|
2022-10-02 11:43:54 +01:00
|
|
|
# tracee requires bpf
|
|
|
|
|
tracee = handleTestOn ["x86_64-linux"] ./tracee.nix {};
|
2019-08-16 16:00:07 +01: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 {};
|
2023-10-20 08:41:34 +01:00
|
|
|
tsja = handleTest ./tsja.nix {};
|
2021-12-18 08:21:57 +00:00
|
|
|
tsm-client-gui = handleTest ./tsm-client-gui.nix {};
|
2021-06-24 22:34:03 +01: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 {};
|
2021-07-23 15:02:20 +01:00
|
|
|
tuxguitar = handleTest ./tuxguitar.nix {};
|
2023-07-07 17:50:29 +01:00
|
|
|
twingate = runTest ./twingate.nix;
|
2023-07-18 23:29:30 +01:00
|
|
|
typesense = handleTest ./typesense.nix {};
|
2021-06-13 21:00:25 +01:00
|
|
|
ucarp = handleTest ./ucarp.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
udisks2 = handleTest ./udisks2.nix {};
|
2023-09-17 23:09:25 +01: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 21:08:00 +01:00
|
|
|
unit-php = handleTest ./web-servers/unit-php.nix {};
|
2023-06-21 18:08:31 +01: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 06:04:23 +01:00
|
|
|
uptime-kuma = handleTest ./uptime-kuma.nix {};
|
2021-01-16 22:15:52 +00:00
|
|
|
usbguard = handleTest ./usbguard.nix {};
|
2021-02-15 22:40:54 +00:00
|
|
|
user-activation-scripts = handleTest ./user-activation-scripts.nix {};
|
2023-08-02 12:51:06 +01:00
|
|
|
user-expiry = runTest ./user-expiry.nix;
|
2022-04-10 20:06:19 +01:00
|
|
|
user-home-mode = handleTest ./user-home-mode.nix {};
|
2019-05-27 22:03:22 +01:00
|
|
|
uwsgi = handleTest ./uwsgi.nix {};
|
2020-06-12 09:12:51 +01:00
|
|
|
v2ray = handleTest ./v2ray.nix {};
|
2022-09-27 20:22:21 +01:00
|
|
|
varnish60 = handleTest ./varnish.nix { package = pkgs.varnish60; };
|
2023-10-09 13:14:21 +01:00
|
|
|
varnish74 = handleTest ./varnish.nix { package = pkgs.varnish74; };
|
2018-11-11 11:30:07 +00:00
|
|
|
vault = handleTest ./vault.nix {};
|
2023-04-25 14:58:30 +01:00
|
|
|
vault-agent = handleTest ./vault-agent.nix {};
|
2022-07-05 09:54:11 +01:00
|
|
|
vault-dev = handleTest ./vault-dev.nix {};
|
2021-01-04 16:54:03 +00:00
|
|
|
vault-postgresql = handleTest ./vault-postgresql.nix {};
|
2021-07-01 10:14:51 +01:00
|
|
|
vaultwarden = handleTest ./vaultwarden.nix {};
|
2020-11-30 07:22:08 +00:00
|
|
|
vector = handleTest ./vector.nix {};
|
2021-11-21 17:09:17 +00:00
|
|
|
vengi-tools = handleTest ./vengi-tools.nix {};
|
2020-01-19 17:55:56 +00:00
|
|
|
victoriametrics = handleTest ./victoriametrics.nix {};
|
2021-06-26 13:26:17 +01: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 {};
|
2022-11-24 19:46:05 +00:00
|
|
|
warzone2100 = handleTest ./warzone2100.nix {};
|
2020-06-18 13:19:13 +01:00
|
|
|
wasabibackend = handleTest ./wasabibackend.nix {};
|
2020-03-22 11:49:51 +00:00
|
|
|
webhook = runTest ./webhook.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 {};
|
2021-04-24 22:02:15 +01:00
|
|
|
without-nix = handleTest ./without-nix.nix {};
|
2021-01-27 14:44:27 +00:00
|
|
|
wmderland = handleTest ./wmderland.nix {};
|
2021-09-24 12:25:16 +01:00
|
|
|
wpa_supplicant = handleTest ./wpa_supplicant.nix {};
|
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 06:08:43 +01:00
|
|
|
writefreely = handleTest ./web-apps/writefreely.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 14:10:26 +01:00
|
|
|
xmonad-xdg-autostart = handleTest ./xmonad-xdg-autostart.nix {};
|
2022-09-21 00:39:13 +01: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 {};
|
2019-06-27 16:56:10 +01:00
|
|
|
yggdrasil = handleTest ./yggdrasil.nix {};
|
2022-02-16 05:49:51 +00:00
|
|
|
zammad = handleTest ./zammad.nix {};
|
2022-06-10 13:54:16 +01:00
|
|
|
zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};
|
2020-02-03 17:33:26 +00:00
|
|
|
zfs = handleTest ./zfs.nix {};
|
2020-08-03 11:43:13 +01:00
|
|
|
zigbee2mqtt = handleTest ./zigbee2mqtt.nix {};
|
2020-04-11 18:28:52 +01: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 19:44:07 +01:00
|
|
|
zrepl = handleTest ./zrepl.nix {};
|
2020-04-11 18:28:52 +01:00
|
|
|
zsh-history = handleTest ./zsh-history.nix {};
|
2023-05-13 22:42:00 +01:00
|
|
|
zwave-js = handleTest ./zwave-js.nix {};
|
2022-06-06 18:24:30 +01:00
|
|
|
}
|
