nixpkgs/nixos/tests/all-tests.nix

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

774 lines
37 KiB
Nix
Raw Normal View History

{ system,
pkgs,
# Projects the test configuration into a the desired value; usually
# the test runner: `config: config.test`.
callTest,
}:
# 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
# `passthru.tests` can contain links to those without breaking on architectures
# 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:
if isAttrs val
then
if hasAttr "test" val then callTest val
else mapAttrs (n: s: discoverTests s) val
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;
handleTest = path: args:
discoverTests (import path ({ inherit system pkgs; } // args));
handleTestOn = systems: path: args:
if elem system systems then handleTest path args
else {};
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 = {};
};
evalMinimalConfig = module: nixosLib.evalModules { modules = [ module ]; };
inherit
(rec {
doRunTest = arg: ((import ../lib/testing-python.nix { inherit system pkgs; }).evalTest {
imports = [ arg ];
}).config.result;
findTests = tree:
if tree?recurseForDerivations && tree.recurseForDerivations
then
mapAttrs
(k: findTests)
(builtins.removeAttrs tree ["recurseForDerivations"])
else callTest tree;
runTest = arg: let r = doRunTest arg; in findTests r;
runTestOn = systems: arg:
if elem system systems then runTest arg
else {};
})
runTest
runTestOn
;
in {
_3proxy = runTest ./3proxy.nix;
acme = runTest ./acme.nix;
adguardhome = runTest ./adguardhome.nix;
aesmd = runTestOn ["x86_64-linux"] ./aesmd.nix;
agate = runTest ./web-servers/agate.nix;
2020-04-19 18:01:37 +00:00
agda = handleTest ./agda.nix {};
2021-05-03 15:38:02 +00:00
airsonic = handleTest ./airsonic.nix {};
akkoma = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix {};
akkoma-confined = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix { confined = true; };
allTerminfo = handleTest ./all-terminfo.nix {};
alps = handleTest ./alps.nix {};
amazon-init-shell = handleTest ./amazon-init-shell.nix {};
apcupsd = handleTest ./apcupsd.nix {};
apfs = handleTest ./apfs.nix {};
apparmor = handleTest ./apparmor.nix {};
atd = handleTest ./atd.nix {};
atop = handleTest ./atop.nix {};
2022-12-16 03:07:15 +00:00
atuin = handleTest ./atuin.nix {};
2022-07-31 21:40:48 +00:00
auth-mysql = handleTest ./auth-mysql.nix {};
avahi = handleTest ./avahi.nix {};
avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };
2019-10-11 23:30:55 +00:00
babeld = handleTest ./babeld.nix {};
2020-05-10 10:54:09 +00:00
bazarr = handleTest ./bazarr.nix {};
bcachefs = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bcachefs.nix {};
beanstalkd = handleTest ./beanstalkd.nix {};
2019-11-24 00:10:17 +00:00
bees = handleTest ./bees.nix {};
2022-10-04 04:06:28 +00:00
binary-cache = handleTest ./binary-cache.nix {};
bind = handleTest ./bind.nix {};
2022-01-25 14:15:52 +00:00
bird = handleTest ./bird.nix {};
2020-07-21 11:43:32 +00:00
bitcoind = handleTest ./bitcoind.nix {};
bittorrent = handleTest ./bittorrent.nix {};
2020-06-23 11:09:03 +00:00
blockbook-frontend = handleTest ./blockbook-frontend.nix {};
2022-02-10 22:44:18 +00:00
blocky = handleTest ./blocky.nix {};
2021-05-25 18:13:29 +00:00
boot = handleTestOn ["x86_64-linux" "aarch64-linux"] ./boot.nix {};
bootspec = handleTestOn ["x86_64-linux"] ./bootspec.nix {};
boot-stage1 = handleTest ./boot-stage1.nix {};
borgbackup = handleTest ./borgbackup.nix {};
2021-05-04 12:30:25 +00:00
botamusique = handleTest ./botamusique.nix {};
bpf = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bpf.nix {};
2022-01-26 13:03:05 +00:00
breitbandmessung = handleTest ./breitbandmessung.nix {};
brscan5 = handleTest ./brscan5.nix {};
2021-05-30 12:00:00 +00:00
btrbk = handleTest ./btrbk.nix {};
btrbk-no-timer = handleTest ./btrbk-no-timer.nix {};
btrbk-section-order = handleTest ./btrbk-section-order.nix {};
buildbot = handleTest ./buildbot.nix {};
2020-11-29 23:00:38 +00:00
buildkite-agents = handleTest ./buildkite-agents.nix {};
2019-10-09 11:32:03 +00:00
caddy = handleTest ./caddy.nix {};
cadvisor = handleTestOn ["x86_64-linux"] ./cadvisor.nix {};
cage = handleTest ./cage.nix {};
cagebreak = handleTest ./cagebreak.nix {};
2021-02-23 11:23:20 +00:00
calibre-web = handleTest ./calibre-web.nix {};
2020-12-09 12:01:56 +00:00
cassandra_3_0 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_0; };
cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; };
2022-04-06 11:03:07 +00:00
cassandra_4 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_4; };
ceph-multi-node = handleTestOn ["x86_64-linux"] ./ceph-multi-node.nix {};
2020-11-29 23:00:38 +00:00
ceph-single-node = handleTestOn ["x86_64-linux"] ./ceph-single-node.nix {};
ceph-single-node-bluestore = handleTestOn ["x86_64-linux"] ./ceph-single-node-bluestore.nix {};
certmgr = handleTest ./certmgr.nix {};
cfssl = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cfssl.nix {};
charliecloud = handleTest ./charliecloud.nix {};
chromium = (handleTestOn ["aarch64-linux" "x86_64-linux"] ./chromium.nix {}).stable or {};
2023-01-15 13:06:58 +00:00
chrony-ptp = handleTestOn ["aarch64-linux" "x86_64-linux"] ./chrony-ptp.nix {};
2022-09-05 07:40:17 +00:00
cinnamon = handleTest ./cinnamon.nix {};
cjdns = handleTest ./cjdns.nix {};
clickhouse = handleTest ./clickhouse.nix {};
cloud-init = handleTest ./cloud-init.nix {};
cloud-init-hostname = handleTest ./cloud-init-hostname.nix {};
2023-01-01 23:19:37 +00:00
cloudlog = handleTest ./cloudlog.nix {};
cntr = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cntr.nix {};
cockpit = handleTest ./cockpit.nix {};
2020-11-29 23:00:38 +00:00
cockroachdb = handleTestOn ["x86_64-linux"] ./cockroachdb.nix {};
2022-10-24 20:08:00 +00:00
coder = handleTest ./coder.nix {};
2021-12-22 12:00:00 +00:00
collectd = handleTest ./collectd.nix {};
2023-01-25 23:22:21 +00:00
connman = handleTest ./connman.nix {};
2019-11-24 14:08:53 +00:00
consul = handleTest ./consul.nix {};
containers-bridge = handleTest ./containers-bridge.nix {};
containers-custom-pkgs.nix = handleTest ./containers-custom-pkgs.nix {};
containers-ephemeral = handleTest ./containers-ephemeral.nix {};
containers-extra_veth = handleTest ./containers-extra_veth.nix {};
containers-hosts = handleTest ./containers-hosts.nix {};
containers-imperative = handleTest ./containers-imperative.nix {};
containers-ip = handleTest ./containers-ip.nix {};
containers-macvlans = handleTest ./containers-macvlans.nix {};
containers-names = handleTest ./containers-names.nix {};
2021-02-24 13:02:57 +00:00
containers-nested = handleTest ./containers-nested.nix {};
containers-physical_interfaces = handleTest ./containers-physical_interfaces.nix {};
containers-portforward = handleTest ./containers-portforward.nix {};
containers-reloadable = handleTest ./containers-reloadable.nix {};
containers-restart_networking = handleTest ./containers-restart_networking.nix {};
containers-tmpfs = handleTest ./containers-tmpfs.nix {};
containers-unified-hierarchy = handleTest ./containers-unified-hierarchy.nix {};
2020-06-05 12:54:29 +00:00
convos = handleTest ./convos.nix {};
2020-01-07 16:52:32 +00:00
corerad = handleTest ./corerad.nix {};
coturn = handleTest ./coturn.nix {};
couchdb = handleTest ./couchdb.nix {};
cri-o = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cri-o.nix {};
2022-07-20 18:14:06 +00:00
cups-pdf = handleTest ./cups-pdf.nix {};
custom-ca = handleTest ./custom-ca.nix {};
2020-07-22 08:34:57 +00:00
croc = handleTest ./croc.nix {};
deluge = handleTest ./deluge.nix {};
dendrite = handleTest ./matrix/dendrite.nix {};
2021-09-19 23:43:54 +00:00
dex-oidc = handleTest ./dex-oidc.nix {};
dhparams = handleTest ./dhparams.nix {};
disable-installer-tools = handleTest ./disable-installer-tools.nix {};
2021-03-14 14:44:34 +00:00
discourse = handleTest ./discourse.nix {};
dnscrypt-proxy2 = handleTestOn ["x86_64-linux"] ./dnscrypt-proxy2.nix {};
2020-04-23 23:33:33 +00:00
dnscrypt-wrapper = handleTestOn ["x86_64-linux"] ./dnscrypt-wrapper {};
2022-01-18 07:59:57 +00:00
dnsdist = handleTest ./dnsdist.nix {};
doas = handleTest ./doas.nix {};
docker = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker.nix {};
docker-rootless = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker-rootless.nix {};
docker-registry = handleTest ./docker-registry.nix {};
docker-tools = handleTestOn ["x86_64-linux"] ./docker-tools.nix {};
docker-tools-cross = handleTestOn ["x86_64-linux" "aarch64-linux"] ./docker-tools-cross.nix {};
docker-tools-overlay = handleTestOn ["x86_64-linux"] ./docker-tools-overlay.nix {};
documize = handleTest ./documize.nix {};
2022-07-14 09:57:37 +00:00
documentation = pkgs.callPackage ../modules/misc/documentation/test.nix { inherit nixosLib; };
doh-proxy-rust = handleTest ./doh-proxy-rust.nix {};
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 {};
dovecot = handleTest ./dovecot.nix {};
2021-11-30 20:42:29 +00:00
drbd = handleTest ./drbd.nix {};
earlyoom = handleTestOn ["x86_64-linux"] ./earlyoom.nix {};
ec2-config = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-config or {};
ec2-nixops = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-nixops or {};
ecryptfs = handleTest ./ecryptfs.nix {};
fscrypt = handleTest ./fscrypt.nix {};
ejabberd = handleTest ./xmpp/ejabberd.nix {};
elk = handleTestOn ["x86_64-linux"] ./elk.nix {};
emacs-daemon = handleTest ./emacs-daemon.nix {};
2022-10-22 12:53:35 +00:00
endlessh = handleTest ./endlessh.nix {};
2022-09-23 20:39:38 +00:00
endlessh-go = handleTest ./endlessh-go.nix {};
2020-05-24 12:20:58 +00:00
engelsystem = handleTest ./engelsystem.nix {};
enlightenment = handleTest ./enlightenment.nix {};
env = handleTest ./env.nix {};
2022-12-28 14:09:54 +00:00
envfs = handleTest ./envfs.nix {};
2021-08-28 02:28:27 +00:00
envoy = handleTest ./envoy.nix {};
2020-05-24 18:39:23 +00:00
ergo = handleTest ./ergo.nix {};
2022-01-12 20:47:27 +00:00
ergochat = handleTest ./ergochat.nix {};
etc = pkgs.callPackage ../modules/system/etc/test.nix { inherit evalMinimalConfig; };
activation = pkgs.callPackage ../modules/system/activation/test.nix { };
etcd = handleTestOn ["x86_64-linux"] ./etcd.nix {};
etcd-cluster = handleTestOn ["x86_64-linux"] ./etcd-cluster.nix {};
2021-03-28 21:49:45 +00:00
etebase-server = handleTest ./etebase-server.nix {};
2020-11-30 21:10:07 +00:00
etesync-dav = handleTest ./etesync-dav.nix {};
extra-python-packages = handleTest ./extra-python-packages.nix {};
2021-07-27 13:14:24 +00:00
evcc = handleTest ./evcc.nix {};
fancontrol = handleTest ./fancontrol.nix {};
fcitx = handleTest ./fcitx {};
fenics = handleTest ./fenics.nix {};
ferm = handleTest ./ferm.nix {};
2021-08-09 09:57:57 +00:00
firefox = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox; };
firefox-esr = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr; }; # used in `tested` job
firefox-esr-102 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-102; };
2020-08-07 16:45:20 +00:00
firejail = handleTest ./firejail.nix {};
firewall = handleTest ./firewall.nix { nftables = false; };
firewall-nftables = handleTest ./firewall.nix { nftables = true; };
fish = handleTest ./fish.nix {};
flannel = handleTestOn ["x86_64-linux"] ./flannel.nix {};
2019-07-29 15:35:27 +00:00
fluentd = handleTest ./fluentd.nix {};
fluidd = handleTest ./fluidd.nix {};
fontconfig-default-fonts = handleTest ./fontconfig-default-fonts.nix {};
forgejo = handleTest ./gitea.nix { giteaPackage = pkgs.forgejo; };
2022-11-29 17:30:00 +00:00
freenet = handleTest ./freenet.nix {};
2020-01-07 14:53:34 +00:00
freeswitch = handleTest ./freeswitch.nix {};
freshrss-sqlite = handleTest ./freshrss-sqlite.nix {};
freshrss-pgsql = handleTest ./freshrss-pgsql.nix {};
frr = handleTest ./frr.nix {};
fsck = handleTest ./fsck.nix {};
2020-07-29 17:40:38 +00:00
ft2-clone = handleTest ./ft2-clone.nix {};
2022-06-07 10:53:15 +00:00
mimir = handleTest ./mimir.nix {};
garage = handleTest ./garage {};
2022-08-11 10:10:58 +00:00
gemstash = handleTest ./gemstash.nix {};
gerrit = handleTest ./gerrit.nix {};
geth = handleTest ./geth.nix {};
2021-05-19 23:15:28 +00:00
ghostunnel = handleTest ./ghostunnel.nix {};
gitdaemon = handleTest ./gitdaemon.nix {};
gitea = handleTest ./gitea.nix { giteaPackage = pkgs.gitea; };
2023-02-26 12:50:49 +00:00
github-runner = handleTest ./github-runner.nix {};
gitlab = handleTest ./gitlab.nix {};
gitolite = handleTest ./gitolite.nix {};
gitolite-fcgiwrap = handleTest ./gitolite-fcgiwrap.nix {};
2019-08-16 23:28:43 +00:00
glusterfs = handleTest ./glusterfs.nix {};
gnome = handleTest ./gnome.nix {};
2022-12-28 21:45:22 +00:00
gnome-flashback = handleTest ./gnome-flashback.nix {};
gnome-xorg = handleTest ./gnome-xorg.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 14:57:33 +00:00
gobgpd = handleTest ./gobgpd.nix {};
gocd-agent = handleTest ./gocd-agent.nix {};
gocd-server = handleTest ./gocd-server.nix {};
2022-09-10 16:01:37 +00:00
gollum = handleTest ./gollum.nix {};
2019-05-17 01:29:17 +00:00
google-oslogin = handleTest ./google-oslogin {};
2020-11-29 23:00:38 +00:00
gotify-server = handleTest ./gotify-server.nix {};
grafana = handleTest ./grafana {};
grafana-agent = handleTest ./grafana-agent.nix {};
graphite = handleTest ./graphite.nix {};
graylog = handleTest ./graylog.nix {};
2020-11-29 23:00:38 +00:00
grocy = handleTest ./grocy.nix {};
grub = handleTest ./grub.nix {};
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; };
haka = handleTest ./haka.nix {};
2022-03-02 17:00:16 +00:00
haste-server = handleTest ./haste-server.nix {};
haproxy = handleTest ./haproxy.nix {};
hardened = handleTest ./hardened.nix {};
headscale = handleTest ./headscale.nix {};
2022-06-10 12:31:00 +00:00
healthchecks = handleTest ./web-apps/healthchecks.nix {};
2022-03-28 20:19:17 +00:00
hbase2 = handleTest ./hbase.nix { package=pkgs.hbase2; };
hbase_2_4 = handleTest ./hbase.nix { package=pkgs.hbase_2_4; };
2022-03-28 20:19:17 +00:00
hbase3 = handleTest ./hbase.nix { package=pkgs.hbase3; };
hedgedoc = handleTest ./hedgedoc.nix {};
2020-11-27 19:20:36 +00:00
herbstluftwm = handleTest ./herbstluftwm.nix {};
2020-11-29 23:00:38 +00:00
installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});
2021-09-07 17:44:12 +00:00
invidious = handleTest ./invidious.nix {};
oci-containers = handleTestOn ["aarch64-linux" "x86_64-linux"] ./oci-containers.nix {};
2021-11-02 00:48:47 +00:00
odoo = handleTest ./odoo.nix {};
# 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 {};
hibernate-systemd-stage-1 = handleTestOn ["x86_64-linux"] ./hibernate.nix { systemdStage1 = true; };
hitch = handleTest ./hitch {};
hledger-web = handleTest ./hledger-web.nix {};
hocker-fetchdocker = handleTest ./hocker-fetchdocker {};
2021-07-18 07:51:49 +00:00
hockeypuck = handleTest ./hockeypuck.nix { };
home-assistant = handleTest ./home-assistant.nix {};
hostname = handleTest ./hostname.nix {};
hound = handleTest ./hound.nix {};
2020-12-29 16:13:26 +00:00
hub = handleTest ./git/hub.nix {};
hydra = handleTest ./hydra {};
i3wm = handleTest ./i3wm.nix {};
icingaweb2 = handleTest ./icingaweb2.nix {};
iftop = handleTest ./iftop.nix {};
2021-10-10 12:00:00 +00:00
ihatemoney = handleTest ./ihatemoney {};
incron = handleTest ./incron.nix {};
influxdb = handleTest ./influxdb.nix {};
initrd-network-openvpn = handleTest ./initrd-network-openvpn {};
2020-11-29 23:00:38 +00:00
initrd-network-ssh = handleTest ./initrd-network-ssh {};
initrdNetwork = handleTest ./initrd-network.nix {};
initrd-secrets = handleTest ./initrd-secrets.nix {};
input-remapper = handleTest ./input-remapper.nix {};
inspircd = handleTest ./inspircd.nix {};
installer = handleTest ./installer.nix {};
installer-systemd-stage-1 = handleTest ./installer-systemd-stage-1.nix {};
invoiceplane = handleTest ./invoiceplane.nix {};
2020-02-02 12:00:00 +00:00
iodine = handleTest ./iodine.nix {};
ipv6 = handleTest ./ipv6.nix {};
iscsi-multipath-root = handleTest ./iscsi-multipath-root.nix {};
iscsi-root = handleTest ./iscsi-root.nix {};
isso = handleTest ./isso.nix {};
jackett = handleTest ./jackett.nix {};
jellyfin = handleTest ./jellyfin.nix {};
jenkins = handleTest ./jenkins.nix {};
jenkins-cli = handleTest ./jenkins-cli.nix {};
2021-10-15 18:00:24 +00:00
jibri = handleTest ./jibri.nix {};
jirafeau = handleTest ./jirafeau.nix {};
2020-03-18 03:23:15 +00:00
jitsi-meet = handleTest ./jitsi-meet.nix {};
k3s = handleTest ./k3s {};
kafka = handleTest ./kafka.nix {};
kanidm = handleTest ./kanidm.nix {};
2022-10-10 05:16:25 +00:00
karma = handleTest ./karma.nix {};
kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};
kbd-update-search-paths-patch = handleTest ./kbd-update-search-paths-patch.nix {};
kea = handleTest ./kea.nix {};
2019-12-22 07:45:31 +00:00
keepalived = handleTest ./keepalived.nix {};
keepassxc = handleTest ./keepassxc.nix {};
2019-01-11 04:36:51 +00:00
kerberos = handleTest ./kerberos/default.nix {};
2021-04-07 15:57:58 +00:00
kernel-generic = handleTest ./kernel-generic.nix {};
kernel-latest-ath-user-regd = handleTest ./kernel-latest-ath-user-regd.nix {};
nixos/keter: init Enable keter module Keter is an apploader which: 1. has the old app running on a port. 2. loads a new one, and wait for that to complete 3. switches the old with the new one once the new one finished loading. It supports more functionality but this use case is the primary one being used by supercede. Adds keter as a module to nixos. Currently keter is unusable with nix, because it relies on bundeling of a tar and uploading that to a specific folder. These expressions automate these devops tasks, with especially nixops in mind. This will work with versions above 1.8 The test seems to work. This uses a new version of keter which has good support for status code on error pages. We're using this config at production at supercede so it should be fine. Squash log: ========== mention keter in changelog Update generated release notes Always restart keter on failure This is a little bit of extra stability in case keter crashes. Which can happen under extreme conditions (DoS attacks). Update nixos/doc/manual/release-notes/rl-2205.section.md Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> Update nixos/modules/module-list.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> Remove sanitization don't put domain in as a string Update nixos/tests/keter.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> add jappie as module maintainer Use type path instead of two seperate options Fix generated docs added test machinery to figure out why it's failing Fix the test, use console output run nixpkgs-fmt on all modules Inline config file. This get's rid of a lot of inderection as well. Run nix format remove comment simplify executable for test delete config file add config for keter root Remove after redis clause set keter root by default to /var/lib/keter Update nixos/modules/services/web-servers/keter/default.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> Update nixos/modules/services/web-servers/keter/default.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> Update nixos/modules/services/web-servers/keter/default.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> fix nit add newlines add default text and move description in a long description Delete rather obvious comment fix release db thing remove longDescription and put it in a comment instead change description of mkEnalbeOption explain what keter does by using the hackage synopsis set domain to keterDomain and same for executable move comment to where it's happening fix type error add formatting better comment try add seperate user for keter Revert "try add seperate user for keter" This reverts commit d3522d36c96117335bfa072e6f453406c244e940. Doing this breaks the setup set default to avoid needing cap_net_bind_service remove weird comment use example fields eleborated on process leakage Update nixos/modules/services/web-servers/keter/default.nix Co-authored-by: ckie <25263210+ckiee@users.noreply.github.com> run nixpkgs-fmt update docs Fix formatting, set keter package by default format our little nixexpr replace '' -> " where possible drop indent for multiline string make description much shorter regen docs database
2022-05-18 13:41:54 +00:00
keter = handleTest ./keter.nix {};
2021-10-24 22:20:46 +00:00
kexec = handleTest ./kexec.nix {};
keycloak = discoverTests (import ./keycloak.nix);
keymap = handleTest ./keymap.nix {};
2019-03-13 00:12:56 +00:00
knot = handleTest ./knot.nix {};
2022-08-12 21:52:52 +00:00
komga = handleTest ./komga.nix {};
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 18:46:03 +00:00
kthxbye = handleTest ./kthxbye.nix {};
kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};
kubo = handleTest ./kubo.nix {};
2022-08-16 13:03:37 +00:00
ladybird = handleTest ./ladybird.nix {};
2022-08-16 18:33:08 +00:00
languagetool = handleTest ./languagetool.nix {};
latestKernel.login = handleTest ./login.nix { latestKernel = true; };
leaps = handleTest ./leaps.nix {};
lemmy = handleTest ./lemmy.nix {};
2021-11-15 11:46:20 +00:00
libinput = handleTest ./libinput.nix {};
2021-04-18 23:05:25 +00:00
libreddit = handleTest ./libreddit.nix {};
2021-11-18 18:10:48 +00:00
libresprite = handleTest ./libresprite.nix {};
2021-05-15 21:22:03 +00:00
libreswan = handleTest ./libreswan.nix {};
librewolf = handleTest ./firefox.nix { firefoxPackage = pkgs.librewolf; };
2022-07-15 20:00:28 +00:00
libuiohook = handleTest ./libuiohook.nix {};
2022-08-22 03:17:06 +00:00
libvirtd = handleTest ./libvirtd.nix {};
2021-11-15 11:46:20 +00:00
lidarr = handleTest ./lidarr.nix {};
lightdm = handleTest ./lightdm.nix {};
2022-07-24 15:04:12 +00:00
lighttpd = handleTest ./lighttpd.nix {};
2019-03-16 12:24:23 +00:00
limesurvey = handleTest ./limesurvey.nix {};
2022-08-30 11:15:41 +00:00
listmonk = handleTest ./listmonk.nix {};
2021-07-30 15:41:54 +00:00
litestream = handleTest ./litestream.nix {};
2020-11-24 01:53:21 +00:00
locate = handleTest ./locate.nix {};
login = handleTest ./login.nix {};
logrotate = handleTest ./logrotate.nix {};
2019-06-27 16:11:09 +00:00
loki = handleTest ./loki.nix {};
luks = handleTest ./luks.nix {};
2022-02-01 17:21:11 +00:00
lvm2 = handleTest ./lvm2 {};
2020-06-08 19:33:21 +00:00
lxd = handleTest ./lxd.nix {};
lxd-nftables = handleTest ./lxd-nftables.nix {};
2021-10-20 21:39:53 +00:00
lxd-image-server = handleTest ./lxd-image-server.nix {};
#logstash = handleTest ./logstash.nix {};
lorri = handleTest ./lorri/default.nix {};
maddy = handleTest ./maddy.nix {};
2022-04-01 02:41:31 +00:00
maestral = handleTest ./maestral.nix {};
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 {};
man = handleTest ./man.nix {};
mariadb-galera = handleTest ./mysql/mariadb-galera.nix {};
mastodon = discoverTests (import ./web-apps/mastodon { inherit handleTestOn; });
2023-01-08 15:44:00 +00:00
mate = handleTest ./mate.nix {};
2019-10-04 20:38:58 +00:00
matomo = handleTest ./matomo.nix {};
matrix-appservice-irc = handleTest ./matrix/appservice-irc.nix {};
matrix-conduit = handleTest ./matrix/conduit.nix {};
matrix-synapse = handleTest ./matrix/synapse.nix {};
mattermost = handleTest ./mattermost.nix {};
mediatomb = handleTest ./mediatomb.nix {};
mediawiki = handleTest ./mediawiki.nix {};
meilisearch = handleTest ./meilisearch.nix {};
memcached = handleTest ./memcached.nix {};
2022-10-19 08:49:57 +00:00
merecat = handleTest ./merecat.nix {};
2019-08-18 07:28:16 +00:00
metabase = handleTest ./metabase.nix {};
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 {};
minio = handleTest ./minio.nix {};
2023-02-04 01:23:14 +00:00
miriway = handleTest ./miriway.nix {};
misc = handleTest ./misc.nix {};
2021-05-30 15:33:09 +00:00
mjolnir = handleTest ./matrix/mjolnir.nix {};
2021-08-13 18:55:15 +00:00
mod_perl = handleTest ./mod_perl.nix {};
molly-brown = handleTest ./molly-brown.nix {};
mongodb = handleTest ./mongodb.nix {};
2019-06-21 14:09:15 +00:00
moodle = handleTest ./moodle.nix {};
2022-03-22 22:35:39 +00:00
moonraker = handleTest ./moonraker.nix {};
morty = handleTest ./morty.nix {};
2019-04-24 08:23:13 +00:00
mosquitto = handleTest ./mosquitto.nix {};
2021-10-06 19:51:07 +00:00
moosefs = handleTest ./moosefs.nix {};
mpd = handleTest ./mpd.nix {};
mpv = handleTest ./mpv.nix {};
mtp = handleTest ./mtp.nix {};
2023-02-03 09:28:48 +00:00
multipass = handleTest ./multipass.nix {};
mumble = handleTest ./mumble.nix {};
# Fails on aarch64-linux at the PDF creation step - need to debug this on an
# aarch64 machine..
musescore = handleTestOn ["x86_64-linux"] ./musescore.nix {};
munin = handleTest ./munin.nix {};
mutableUsers = handleTest ./mutable-users.nix {};
2019-05-18 20:18:01 +00:00
mxisd = handleTest ./mxisd.nix {};
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 {};
nar-serve = handleTest ./nar-serve.nix {};
nat.firewall = handleTest ./nat.nix { withFirewall = true; };
nat.standalone = handleTest ./nat.nix { withFirewall = false; };
nat.nftables.firewall = handleTest ./nat.nix { withFirewall = true; nftables = true; };
nat.nftables.standalone = handleTest ./nat.nix { withFirewall = false; nftables = true; };
2021-06-26 11:58:40 +00:00
nats = handleTest ./nats.nix {};
navidrome = handleTest ./navidrome.nix {};
nbd = handleTest ./nbd.nix {};
2020-06-07 21:59:12 +00:00
ncdns = handleTest ./ncdns.nix {};
2019-02-03 15:47:01 +00:00
ndppd = handleTest ./ndppd.nix {};
nebula = handleTest ./nebula.nix {};
2022-08-14 16:59:15 +00:00
netbird = handleTest ./netbird.nix {};
2019-02-01 13:29:54 +00:00
neo4j = handleTest ./neo4j.nix {};
netdata = handleTest ./netdata.nix {};
networking.networkd = handleTest ./networking.nix { networkd = true; };
networking.scripted = handleTest ./networking.nix { networkd = false; };
2022-03-06 16:02:14 +00:00
netbox = handleTest ./web-apps/netbox.nix {};
# TODO: put in networking.nix after the test becomes more complete
networkingProxy = handleTest ./networking-proxy.nix {};
nextcloud = handleTest ./nextcloud {};
nexus = handleTest ./nexus.nix {};
# TODO: Test nfsv3 + Kerberos
nfs3 = handleTest ./nfs { version = 3; };
nfs4 = handleTest ./nfs { version = 4; };
nghttpx = handleTest ./nghttpx.nix {};
nginx = handleTest ./nginx.nix {};
2020-10-20 16:05:41 +00:00
nginx-auth = handleTest ./nginx-auth.nix {};
nginx: Clear Last-Modified if ETag is from store This is what I've suspected a while ago[1]: > Heads-up everyone: After testing this in a few production instances, > it seems that some browsers still get cache hits for new store paths > (and changed contents) for some reason. I highly suspect that it might > be due to the last-modified header (as mentioned in [2]). > > Going to test this with last-modified disabled for a little while and > if this is the case I think we should improve that patch by disabling > last-modified if serving from a store path. Much earlier[2] when I reviewed the patch, I wrote this: > Other than that, it looks good to me. > > However, I'm not sure what we should do with Last-Modified header. > From RFC 2616, section 13.3.4: > > - If both an entity tag and a Last-Modified value have been > provided by the origin server, SHOULD use both validators in > cache-conditional requests. This allows both HTTP/1.0 and > HTTP/1.1 caches to respond appropriately. > > I'm a bit nervous about the SHOULD here, as user agents in the wild > could possibly just use Last-Modified and use the cached content > instead. Unfortunately, I didn't pursue this any further back then because @pbogdan noted[3] the following: > Hmm, could they (assuming they are conforming): > > * If an entity tag has been provided by the origin server, MUST > use that entity tag in any cache-conditional request (using If- > Match or If-None-Match). Since running with this patch in some deployments, I found that both Firefox and Chrome/Chromium do NOT re-validate against the ETag if the Last-Modified header is still the same. So I wrote a small NixOS VM test with Geckodriver to have a test case which is closer to the real world and I indeed was able to reproduce this. Whether this is actually a bug in Chrome or Firefox is an entirely different issue and even IF it is the fault of the browsers and it is fixed at some point, we'd still need to handle this for older browser versions. Apart from clearing the header, I also recreated the patch by using a plain "git diff" with a small description on top. This should make it easier for future authors to work on that patch. [1]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-495072764 [2]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-451644084 [3]: https://github.com/NixOS/nixpkgs/pull/48337#issuecomment-451646135 Signed-off-by: aszlig <aszlig@nix.build>
2019-12-30 13:06:00 +00:00
nginx-etag = handleTest ./nginx-etag.nix {};
nginx-globalredirect = handleTest ./nginx-globalredirect.nix {};
2022-04-18 10:22:39 +00:00
nginx-http3 = handleTest ./nginx-http3.nix {};
2022-02-14 23:10:37 +00:00
nginx-modsecurity = handleTest ./nginx-modsecurity.nix {};
2022-09-18 12:54:04 +00:00
nginx-njs = handleTest ./nginx-njs.nix {};
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 {};
2020-04-23 19:00:27 +00:00
nginx-sandbox = handleTestOn ["x86_64-linux"] ./nginx-sandbox.nix {};
nginx-sso = handleTest ./nginx-sso.nix {};
nginx-variants = handleTest ./nginx-variants.nix {};
2022-04-10 17:41:30 +00:00
nifi = handleTestOn ["x86_64-linux"] ./web-apps/nifi.nix {};
2021-07-26 10:00:05 +00:00
nitter = handleTest ./nitter.nix {};
2022-04-11 18:51:29 +00:00
nix-ld = handleTest ./nix-ld.nix {};
nix-serve = handleTest ./nix-serve.nix {};
nix-serve-ssh = handleTest ./nix-serve-ssh.nix {};
2021-10-17 22:38:58 +00:00
nixops = handleTest ./nixops/default.nix {};
nixos-generate-config = handleTest ./nixos-generate-config.nix {};
nixos-rebuild-specialisations = handleTest ./nixos-rebuild-specialisations.nix {};
nixpkgs = pkgs.callPackage ../modules/misc/nixpkgs/test.nix { inherit evalMinimalConfig; };
2021-07-28 10:42:26 +00:00
node-red = handleTest ./node-red.nix {};
nomad = handleTest ./nomad.nix {};
non-default-filesystems = handleTest ./non-default-filesystems.nix {};
2022-01-22 02:06:13 +00:00
noto-fonts = handleTest ./noto-fonts.nix {};
novacomd = handleTestOn ["x86_64-linux"] ./novacomd.nix {};
nscd = handleTest ./nscd.nix {};
nsd = handleTest ./nsd.nix {};
2022-09-01 12:36:19 +00:00
ntfy-sh = handleTest ./ntfy-sh.nix {};
nzbget = handleTest ./nzbget.nix {};
2020-10-04 14:06:53 +00:00
nzbhydra2 = handleTest ./nzbhydra2.nix {};
2020-11-05 01:37:50 +00:00
oh-my-zsh = handleTest ./oh-my-zsh.nix {};
ombi = handleTest ./ombi.nix {};
2019-10-22 14:20:56 +00:00
openarena = handleTest ./openarena.nix {};
openldap = handleTest ./openldap.nix {};
opensearch = discoverTests (import ./opensearch.nix);
openresty-lua = handleTest ./openresty-lua.nix {};
opensmtpd = handleTest ./opensmtpd.nix {};
opensmtpd-rspamd = handleTest ./opensmtpd-rspamd.nix {};
openssh = handleTest ./openssh.nix {};
octoprint = handleTest ./octoprint.nix {};
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 {};
2021-09-23 08:48:29 +00:00
owncast = handleTest ./owncast.nix {};
2020-12-20 20:18:54 +00:00
image-contents = handleTest ./image-contents.nix {};
2019-08-20 22:27:14 +00:00
orangefs = handleTest ./orangefs.nix {};
os-prober = handleTestOn ["x86_64-linux"] ./os-prober.nix {};
2019-01-05 12:13:10 +00:00
osrm-backend = handleTest ./osrm-backend.nix {};
2019-01-23 09:19:23 +00:00
overlayfs = handleTest ./overlayfs.nix {};
2022-03-08 01:46:26 +00:00
pacemaker = handleTest ./pacemaker.nix {};
2019-04-24 08:45:29 +00:00
packagekit = handleTest ./packagekit.nix {};
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 {};
pam-ussh = handleTest ./pam/pam-ussh.nix {};
pass-secret-service = handleTest ./pass-secret-service.nix {};
patroni = handleTestOn ["x86_64-linux"] ./patroni.nix {};
pantalaimon = handleTest ./matrix/pantalaimon.nix {};
pantheon = handleTest ./pantheon.nix {};
paperless = handleTest ./paperless.nix {};
2021-06-02 16:19:37 +00:00
parsedmarc = handleTest ./parsedmarc {};
2020-11-29 23:00:38 +00:00
pdns-recursor = handleTest ./pdns-recursor.nix {};
peerflix = handleTest ./peerflix.nix {};
2022-12-01 16:32:15 +00:00
peering-manager = handleTest ./web-apps/peering-manager.nix {};
2021-05-31 11:23:06 +00:00
peertube = handleTestOn ["x86_64-linux"] ./web-apps/peertube.nix {};
pgadmin4 = handleTest ./pgadmin4.nix {};
pgjwt = handleTest ./pgjwt.nix {};
pgmanage = handleTest ./pgmanage.nix {};
2022-08-02 19:34:37 +00:00
phosh = handleTest ./phosh.nix {};
2023-01-14 23:16:35 +00:00
photoprism = handleTest ./photoprism.nix {};
php = handleTest ./php {};
php80 = handleTest ./php { php = pkgs.php80; };
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; };
2022-06-28 19:17:38 +00:00
phylactery = handleTest ./web-apps/phylactery.nix {};
pict-rs = handleTest ./pict-rs.nix {};
2020-06-03 21:12:06 +00:00
pinnwand = handleTest ./pinnwand.nix {};
plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};
plasma5 = handleTest ./plasma5.nix {};
2021-10-31 20:34:10 +00:00
plasma5-systemd-start = handleTest ./plasma5-systemd-start.nix {};
2021-05-21 21:15:23 +00:00
plausible = handleTest ./plausible.nix {};
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 {};
plotinus = handleTest ./plotinus.nix {};
2021-04-14 17:15:41 +00:00
podgrab = handleTest ./podgrab.nix {};
podman = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/default.nix {};
podman-tls-ghostunnel = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/tls-ghostunnel.nix {};
2022-06-17 18:04:54 +00:00
polaris = handleTest ./polaris.nix {};
2021-01-08 03:03:00 +00:00
pomerium = handleTestOn ["x86_64-linux"] ./pomerium.nix {};
postfix = handleTest ./postfix.nix {};
postfix-raise-smtpd-tls-security-level = handleTest ./postfix-raise-smtpd-tls-security-level.nix {};
2021-05-19 04:34:03 +00:00
postfixadmin = handleTest ./postfixadmin.nix {};
postgis = handleTest ./postgis.nix {};
postgresql = handleTest ./postgresql.nix {};
postgresql-wal-receiver = handleTest ./postgresql-wal-receiver.nix {};
powerdns = handleTest ./powerdns.nix {};
powerdns-admin = handleTest ./powerdns-admin.nix {};
power-profiles-daemon = handleTest ./power-profiles-daemon.nix {};
pppd = handleTest ./pppd.nix {};
predictable-interface-names = handleTest ./predictable-interface-names.nix {};
printing-socket = handleTest ./printing.nix { socket = true; };
printing-service = handleTest ./printing.nix { socket = false; };
2020-04-21 11:37:00 +00:00
privacyidea = handleTest ./privacyidea.nix {};
2021-03-03 16:18:09 +00:00
privoxy = handleTest ./privoxy.nix {};
prometheus = handleTest ./prometheus.nix {};
prometheus-exporters = handleTest ./prometheus-exporters.nix {};
prosody = handleTest ./xmpp/prosody.nix {};
prosody-mysql = handleTest ./xmpp/prosody-mysql.nix {};
proxy = handleTest ./proxy.nix {};
2021-10-10 15:54:22 +00:00
prowlarr = handleTest ./prowlarr.nix {};
2020-07-29 17:00:33 +00:00
pt2-clone = handleTest ./pt2-clone.nix {};
pykms = handleTest ./pykms.nix {};
2021-12-01 10:06:18 +00:00
public-inbox = handleTest ./public-inbox.nix {};
2021-11-30 13:51:06 +00:00
pulseaudio = discoverTests (import ./pulseaudio.nix);
qboot = handleTestOn ["x86_64-linux" "i686-linux"] ./qboot.nix {};
qemu-vm-restrictnetwork = handleTest ./qemu-vm-restrictnetwork.nix {};
2020-03-22 16:26:55 +00:00
quorum = handleTest ./quorum.nix {};
2022-09-21 20:26:03 +00:00
quake3 = handleTest ./quake3.nix {};
rabbitmq = handleTest ./rabbitmq.nix {};
radarr = handleTest ./radarr.nix {};
radicale = handleTest ./radicale.nix {};
rasdaemon = handleTest ./rasdaemon.nix {};
2019-08-31 18:17:33 +00:00
redis = handleTest ./redis.nix {};
redmine = handleTest ./redmine.nix {};
restartByActivationScript = handleTest ./restart-by-activation-script.nix {};
2020-01-30 21:31:52 +00:00
restic = handleTest ./restic.nix {};
retroarch = handleTest ./retroarch.nix {};
2020-08-30 16:31:54 +00:00
robustirc-bridge = handleTest ./robustirc-bridge.nix {};
roundcube = handleTest ./roundcube.nix {};
rspamd = handleTest ./rspamd.nix {};
rss2email = handleTest ./rss2email.nix {};
rstudio-server = handleTest ./rstudio-server.nix {};
rsyncd = handleTest ./rsyncd.nix {};
rsyslogd = handleTest ./rsyslogd.nix {};
rxe = handleTest ./rxe.nix {};
2021-09-21 11:38:22 +00:00
sabnzbd = handleTest ./sabnzbd.nix {};
samba = handleTest ./samba.nix {};
samba-wsdd = handleTest ./samba-wsdd.nix {};
sanoid = handleTest ./sanoid.nix {};
schleuder = handleTest ./schleuder.nix {};
sddm = handleTest ./sddm.nix {};
seafile = handleTest ./seafile.nix {};
2020-11-02 00:34:53 +00:00
searx = handleTest ./searx.nix {};
service-runner = handleTest ./service-runner.nix {};
2022-03-20 21:39:04 +00:00
sfxr-qt = handleTest ./sfxr-qt.nix {};
2020-12-23 18:28:30 +00:00
shadow = handleTest ./shadow.nix {};
shadowsocks = handleTest ./shadowsocks {};
shattered-pixel-dungeon = handleTest ./shattered-pixel-dungeon.nix {};
shiori = handleTest ./shiori.nix {};
2019-05-22 22:50:51 +00:00
signal-desktop = handleTest ./signal-desktop.nix {};
simple = handleTest ./simple.nix {};
slurm = handleTest ./slurm.nix {};
smokeping = handleTest ./smokeping.nix {};
snapcast = handleTest ./snapcast.nix {};
snapper = handleTest ./snapper.nix {};
soapui = handleTest ./soapui.nix {};
2020-05-12 16:32:39 +00:00
sogo = handleTest ./sogo.nix {};
2021-05-20 20:03:39 +00:00
solanum = handleTest ./solanum.nix {};
solr = handleTest ./solr.nix {};
2020-11-29 23:00:38 +00:00
sonarr = handleTest ./sonarr.nix {};
2021-08-28 17:46:05 +00:00
sourcehut = handleTest ./sourcehut.nix {};
spacecookie = handleTest ./spacecookie.nix {};
spark = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./spark {};
sqlite3-to-mysql = handleTest ./sqlite3-to-mysql.nix {};
2020-01-18 12:00:00 +00:00
sslh = handleTest ./sslh.nix {};
sssd = handleTestOn ["x86_64-linux"] ./sssd.nix {};
2020-09-01 05:03:20 +00:00
sssd-ldap = handleTestOn ["x86_64-linux"] ./sssd-ldap.nix {};
2021-12-24 11:24:29 +00:00
starship = handleTest ./starship.nix {};
2021-11-12 20:37:11 +00:00
step-ca = handleTestOn ["x86_64-linux"] ./step-ca.nix {};
stratis = handleTest ./stratis {};
strongswan-swanctl = handleTest ./strongswan-swanctl.nix {};
2022-02-22 22:08:43 +00:00
stunnel = handleTest ./stunnel.nix {};
sudo = handleTest ./sudo.nix {};
2022-10-04 03:08:46 +00:00
swap-file-btrfs = handleTest ./swap-file-btrfs.nix {};
2022-06-22 02:11:23 +00:00
swap-partition = handleTest ./swap-partition.nix {};
sway = handleTest ./sway.nix {};
switchTest = handleTest ./switch-test.nix {};
2019-07-06 18:56:30 +00:00
sympa = handleTest ./sympa.nix {};
2020-07-23 07:13:26 +00:00
syncthing = handleTest ./syncthing.nix {};
syncthing-init = handleTest ./syncthing-init.nix {};
2018-11-17 14:02:00 +00:00
syncthing-relay = handleTest ./syncthing-relay.nix {};
systemd = handleTest ./systemd.nix {};
2019-11-24 23:03:55 +00:00
systemd-analyze = handleTest ./systemd-analyze.nix {};
systemd-binfmt = handleTestOn ["x86_64-linux"] ./systemd-binfmt.nix {};
systemd-boot = handleTest ./systemd-boot.nix {};
systemd-bpf = handleTest ./systemd-bpf.nix {};
systemd-confinement = handleTest ./systemd-confinement.nix {};
systemd-coredump = handleTest ./systemd-coredump.nix {};
systemd-cryptenroll = handleTest ./systemd-cryptenroll.nix {};
systemd-credentials-tpm2 = handleTest ./systemd-credentials-tpm2.nix {};
systemd-escaping = handleTest ./systemd-escaping.nix {};
systemd-initrd-btrfs-raid = handleTest ./systemd-initrd-btrfs-raid.nix {};
systemd-initrd-luks-fido2 = handleTest ./systemd-initrd-luks-fido2.nix {};
systemd-initrd-luks-keyfile = handleTest ./systemd-initrd-luks-keyfile.nix {};
systemd-initrd-luks-password = handleTest ./systemd-initrd-luks-password.nix {};
systemd-initrd-luks-tpm2 = handleTest ./systemd-initrd-luks-tpm2.nix {};
systemd-initrd-modprobe = handleTest ./systemd-initrd-modprobe.nix {};
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 {};
systemd-initrd-swraid = handleTest ./systemd-initrd-swraid.nix {};
systemd-initrd-vconsole = handleTest ./systemd-initrd-vconsole.nix {};
systemd-journal = handleTest ./systemd-journal.nix {};
systemd-machinectl = handleTest ./systemd-machinectl.nix {};
systemd-networkd = handleTest ./systemd-networkd.nix {};
2019-11-16 11:13:51 +00:00
systemd-networkd-dhcpserver = handleTest ./systemd-networkd-dhcpserver.nix {};
systemd-networkd-dhcpserver-static-leases = handleTest ./systemd-networkd-dhcpserver-static-leases.nix {};
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 {};
systemd-no-tainted = handleTest ./systemd-no-tainted.nix {};
systemd-nspawn = handleTest ./systemd-nspawn.nix {};
systemd-oomd = handleTest ./systemd-oomd.nix {};
systemd-portabled = handleTest ./systemd-portabled.nix {};
2023-01-19 19:04:29 +00:00
systemd-repart = handleTest ./systemd-repart.nix {};
systemd-shutdown = handleTest ./systemd-shutdown.nix {};
2020-11-29 23:00:38 +00:00
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
systemd-user-tmpfiles-rules = handleTest ./systemd-user-tmpfiles-rules.nix {};
systemd-misc = handleTest ./systemd-misc.nix {};
systemd-userdbd = handleTest ./systemd-userdbd.nix {};
systemd-homed = handleTest ./systemd-homed.nix {};
2022-09-17 14:36:39 +00:00
tandoor-recipes = handleTest ./tandoor-recipes.nix {};
taskserver = handleTest ./taskserver.nix {};
2022-10-12 19:16:02 +00:00
tayga = handleTest ./tayga.nix {};
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 {};
terminal-emulators = handleTest ./terminal-emulators.nix {};
tiddlywiki = handleTest ./tiddlywiki.nix {};
tigervnc = handleTest ./tigervnc.nix {};
timescaledb = handleTest ./timescaledb.nix {};
2019-12-02 22:28:53 +00:00
timezone = handleTest ./timezone.nix {};
tinc = handleTest ./tinc {};
2019-05-16 21:42:02 +00:00
tinydns = handleTest ./tinydns.nix {};
tinywl = handleTest ./tinywl.nix {};
tmate-ssh-server = handleTest ./tmate-ssh-server.nix { };
tomcat = handleTest ./tomcat.nix {};
tor = handleTest ./tor.nix {};
traefik = handleTestOn ["aarch64-linux" "x86_64-linux"] ./traefik.nix {};
2021-04-09 16:48:51 +00:00
trafficserver = handleTest ./trafficserver.nix {};
transmission = handleTest ./transmission.nix {};
# tracee requires bpf
tracee = handleTestOn ["x86_64-linux"] ./tracee.nix {};
2019-08-16 15:00:07 +00:00
trezord = handleTest ./trezord.nix {};
2019-11-01 10:03:23 +00:00
trickster = handleTest ./trickster.nix {};
2020-11-29 23:00:38 +00:00
trilium-server = handleTestOn ["x86_64-linux"] ./trilium-server.nix {};
tsm-client-gui = handleTest ./tsm-client-gui.nix {};
txredisapi = handleTest ./txredisapi.nix {};
2020-03-24 22:45:49 +00:00
tuptime = handleTest ./tuptime.nix {};
turbovnc-headless-server = handleTest ./turbovnc-headless-server.nix {};
tuxguitar = handleTest ./tuxguitar.nix {};
2021-06-13 20:00:25 +00:00
ucarp = handleTest ./ucarp.nix {};
udisks2 = handleTest ./udisks2.nix {};
ulogd = handleTest ./ulogd.nix {};
2020-11-29 23:00:38 +00:00
unbound = handleTest ./unbound.nix {};
2021-12-17 23:55:13 +00:00
unifi = handleTest ./unifi.nix {};
2020-04-16 20:08:00 +00:00
unit-php = handleTest ./web-servers/unit-php.nix {};
upnp = handleTest ./upnp.nix {};
2022-03-17 16:57:23 +00:00
uptermd = handleTest ./uptermd.nix {};
2022-09-23 05:04:23 +00:00
uptime-kuma = handleTest ./uptime-kuma.nix {};
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 {};
user-home-mode = handleTest ./user-home-mode.nix {};
2019-05-27 21:03:22 +00:00
uwsgi = handleTest ./uwsgi.nix {};
2020-06-12 08:12:51 +00:00
v2ray = handleTest ./v2ray.nix {};
2022-09-27 19:22:21 +00:00
varnish60 = handleTest ./varnish.nix { package = pkgs.varnish60; };
varnish72 = handleTest ./varnish.nix { package = pkgs.varnish72; };
vault = handleTest ./vault.nix {};
vault-dev = handleTest ./vault-dev.nix {};
2021-01-04 16:54:03 +00:00
vault-postgresql = handleTest ./vault-postgresql.nix {};
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 12:26:17 +00:00
vikunja = handleTest ./vikunja.nix {};
virtualbox = handleTestOn ["x86_64-linux"] ./virtualbox.nix {};
vscodium = discoverTests (import ./vscodium.nix);
vsftpd = handleTest ./vsftpd.nix {};
2022-11-24 19:46:05 +00:00
warzone2100 = handleTest ./warzone2100.nix {};
2020-06-18 12:19:13 +00:00
wasabibackend = handleTest ./wasabibackend.nix {};
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 {};
wine = handleTest ./wine.nix {};
wireguard = handleTest ./wireguard {};
without-nix = handleTest ./without-nix.nix {};
2021-01-27 14:44:27 +00:00
wmderland = handleTest ./wmderland.nix {};
2021-09-24 11:25:16 +00:00
wpa_supplicant = handleTest ./wpa_supplicant.nix {};
wordpress = handleTest ./wordpress.nix {};
wrappers = handleTest ./wrappers.nix {};
2022-06-26 05:08:43 +00:00
writefreely = handleTest ./web-apps/writefreely.nix {};
2019-12-14 00:17:49 +00:00
xandikos = handleTest ./xandikos.nix {};
xautolock = handleTest ./xautolock.nix {};
xfce = handleTest ./xfce.nix {};
xmonad = handleTest ./xmonad.nix {};
xmonad-xdg-autostart = handleTest ./xmonad-xdg-autostart.nix {};
2022-09-20 23:39:13 +00:00
xpadneo = handleTest ./xpadneo.nix {};
xrdp = handleTest ./xrdp.nix {};
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 {};
yabar = handleTest ./yabar.nix {};
2019-06-27 15:56:10 +00:00
yggdrasil = handleTest ./yggdrasil.nix {};
2022-02-16 05:49:51 +00:00
zammad = handleTest ./zammad.nix {};
2022-06-10 12:54:16 +00:00
zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};
2020-02-03 17:33:26 +00:00
zfs = handleTest ./zfs.nix {};
zigbee2mqtt = handleTest ./zigbee2mqtt.nix {};
2020-04-11 17:28:52 +00:00
zoneminder = handleTest ./zoneminder.nix {};
zookeeper = handleTest ./zookeeper.nix {};
2023-01-18 14:40:42 +00:00
zram-generator = handleTest ./zram-generator.nix {};
zrepl = handleTest ./zrepl.nix {};
2020-04-11 17:28:52 +00:00
zsh-history = handleTest ./zsh-history.nix {};
}