2018-11-11 11:30:07 +00:00
|
|
|
{ system, pkgs, 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
|
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:
|
|
|
|
|
if !isAttrs val then val
|
|
|
|
|
else if hasAttr "test" val then callTest val
|
|
|
|
|
else mapAttrs (n: s: discoverTests s) val;
|
|
|
|
|
handleTest = path: args:
|
|
|
|
|
discoverTests (import path ({ inherit system pkgs; } // args));
|
|
|
|
|
handleTestOn = systems: path: args:
|
|
|
|
|
if elem system systems then handleTest path args
|
|
|
|
|
else {};
|
|
|
|
|
in
|
|
|
|
|
{
|
2019-10-10 12:56:05 +01:00
|
|
|
_3proxy = handleTest ./3proxy.nix {};
|
2020-03-23 22:12:15 +00:00
|
|
|
acme = handleTest ./acme.nix {};
|
2022-01-17 00:39:27 +00:00
|
|
|
adguardhome = handleTest ./adguardhome.nix {};
|
2021-12-04 14:13:26 +00:00
|
|
|
aesmd = handleTest ./aesmd.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 {};
|
2021-04-18 10:19:06 +01:00
|
|
|
amazon-init-shell = handleTest ./amazon-init-shell.nix {};
|
2021-02-28 21:18:01 +00:00
|
|
|
apparmor = handleTest ./apparmor.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 {};
|
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; };
|
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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
bind = handleTest ./bind.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 {};
|
2021-05-25 19:13:29 +01:00
|
|
|
boot = handleTestOn ["x86_64-linux" "aarch64-linux"] ./boot.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 {};
|
2021-05-30 13:00:00 +01:00
|
|
|
btrbk = handleTest ./btrbk.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
buildbot = handleTest ./buildbot.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
buildkite-agents = handleTest ./buildkite-agents.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 {};
|
2020-12-09 12:01:56 +00:00
|
|
|
cassandra_2_1 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_2_1; };
|
|
|
|
|
cassandra_2_2 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_2_2; };
|
|
|
|
|
cassandra_3_0 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_0; };
|
|
|
|
|
cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; };
|
2019-11-01 12:12:18 +00:00
|
|
|
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 {};
|
2021-02-14 17:59:29 +00:00
|
|
|
ceph-single-node-bluestore = handleTestOn ["x86_64-linux"] ./ceph-single-node-bluestore.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
certmgr = handleTest ./certmgr.nix {};
|
|
|
|
|
cfssl = handleTestOn ["x86_64-linux"] ./cfssl.nix {};
|
2020-08-25 08:44:27 +01:00
|
|
|
charliecloud = handleTest ./charliecloud.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
chromium = (handleTestOn ["x86_64-linux"] ./chromium.nix {}).stable or {};
|
|
|
|
|
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 {};
|
2021-02-24 13:10:22 +00:00
|
|
|
cntr = handleTest ./cntr.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
cockroachdb = handleTestOn ["x86_64-linux"] ./cockroachdb.nix {};
|
2021-12-22 12:00:00 +00:00
|
|
|
collectd = handleTest ./collectd.nix {};
|
2019-11-24 14:08:53 +00:00
|
|
|
consul = handleTest ./consul.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 {};
|
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 {};
|
2020-08-23 15:08:10 +01:00
|
|
|
cri-o = handleTestOn ["x86_64-linux"] ./cri-o.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 {};
|
2021-08-10 12:04:07 +01:00
|
|
|
cryptpad = handleTest ./cryptpad.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
deluge = handleTest ./deluge.nix {};
|
2021-05-14 12:11:22 +01:00
|
|
|
dendrite = handleTest ./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 {};
|
2020-04-24 00:33:33 +01:00
|
|
|
dnscrypt-wrapper = handleTestOn ["x86_64-linux"] ./dnscrypt-wrapper {};
|
2020-04-14 04:13:36 +01:00
|
|
|
doas = handleTest ./doas.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
docker = handleTestOn ["x86_64-linux"] ./docker.nix {};
|
2021-12-14 22:07:58 +00:00
|
|
|
docker-rootless = handleTestOn ["x86_64-linux"] ./docker-rootless.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
docker-edge = handleTestOn ["x86_64-linux"] ./docker-edge.nix {};
|
|
|
|
|
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 {};
|
2019-12-25 22:04:55 +00:00
|
|
|
dokuwiki = handleTest ./dokuwiki.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 {};
|
2021-11-30 20:42:29 +00:00
|
|
|
drbd = handleTest ./drbd.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 {};
|
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 {};
|
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 {};
|
2020-05-24 19:39:23 +01:00
|
|
|
ergo = handleTest ./ergo.nix {};
|
2022-01-12 20:47:27 +00:00
|
|
|
ergochat = handleTest ./ergochat.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 {};
|
2019-10-29 14:06:32 +00:00
|
|
|
fancontrol = handleTest ./fancontrol.nix {};
|
2020-08-26 13:58:37 +01:00
|
|
|
fcitx = handleTest ./fcitx {};
|
2018-11-11 11:30:07 +00:00
|
|
|
ferm = handleTest ./ferm.nix {};
|
2021-08-09 10:57:57 +01:00
|
|
|
firefox = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox; };
|
2021-08-10 15:15:57 +01:00
|
|
|
firefox-esr = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr; }; # used in `tested` job
|
2021-08-09 10:57:57 +01:00
|
|
|
firefox-esr-91 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-91; };
|
2020-08-07 17:45:20 +01:00
|
|
|
firejail = handleTest ./firejail.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
firewall = handleTest ./firewall.nix {};
|
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 {};
|
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 {};
|
2020-01-07 14:53:34 +00:00
|
|
|
freeswitch = handleTest ./freeswitch.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 {};
|
2020-07-29 18:40:38 +01:00
|
|
|
ft2-clone = handleTest ./ft2-clone.nix {};
|
2020-03-05 21:11:28 +00:00
|
|
|
gerrit = handleTest ./gerrit.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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
gitea = handleTest ./gitea.nix {};
|
|
|
|
|
gitlab = handleTest ./gitlab.nix {};
|
|
|
|
|
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 {};
|
|
|
|
|
gnome-xorg = handleTest ./gnome-xorg.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 {};
|
2019-05-17 02:29:17 +01:00
|
|
|
google-oslogin = handleTest ./google-oslogin {};
|
2020-11-29 23:00:38 +00:00
|
|
|
gotify-server = handleTest ./gotify-server.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
grafana = handleTest ./grafana.nix {};
|
|
|
|
|
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 {};
|
2020-06-13 11:06:26 +01:00
|
|
|
grub = handleTest ./grub.nix {};
|
2019-11-27 07:01:46 +00:00
|
|
|
gvisor = handleTest ./gvisor.nix {};
|
2021-10-20 21:33:56 +01:00
|
|
|
hadoop.all = handleTestOn [ "x86_64-linux" ] ./hadoop/hadoop.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
hadoop.hdfs = handleTestOn [ "x86_64-linux" ] ./hadoop/hdfs.nix {};
|
|
|
|
|
hadoop.yarn = handleTestOn [ "x86_64-linux" ] ./hadoop/yarn.nix {};
|
2018-11-12 06:45:00 +00:00
|
|
|
handbrake = handleTestOn ["x86_64-linux"] ./handbrake.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 {};
|
2020-11-29 17:51:50 +00:00
|
|
|
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 18:44:12 +01:00
|
|
|
invidious = handleTest ./invidious.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
oci-containers = handleTestOn ["x86_64-linux"] ./oci-containers.nix {};
|
2021-11-02 00:48:47 +00:00
|
|
|
odoo = handleTest ./odoo.nix {};
|
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 {};
|
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 {};
|
2021-10-10 13:00:00 +01:00
|
|
|
ihatemoney = handleTest ./ihatemoney {};
|
2018-11-14 22:51:15 +00:00
|
|
|
incron = handleTest ./incron.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
influxdb = handleTest ./influxdb.nix {};
|
2020-06-30 23:02:56 +01:00
|
|
|
initrd-network-openvpn = handleTest ./initrd-network-openvpn {};
|
2020-11-29 23:00:38 +00:00
|
|
|
initrd-network-ssh = handleTest ./initrd-network-ssh {};
|
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 {};
|
2021-03-22 13:32:46 +00:00
|
|
|
inspircd = handleTest ./inspircd.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
installer = handleTest ./installer.nix {};
|
2020-02-02 12:00:00 +00:00
|
|
|
iodine = handleTest ./iodine.nix {};
|
2020-05-08 10:48:47 +01:00
|
|
|
ipfs = handleTest ./ipfs.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
ipv6 = handleTest ./ipv6.nix {};
|
2020-10-18 18:55:42 +01:00
|
|
|
iscsi-root = handleTest ./iscsi-root.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 {};
|
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 {};
|
2020-04-17 15:39:54 +01:00
|
|
|
k3s = handleTest ./k3s.nix {};
|
2019-04-01 13:39:25 +01:00
|
|
|
kafka = handleTest ./kafka.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 {};
|
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);
|
2018-11-11 11:30:07 +00:00
|
|
|
keymap = handleTest ./keymap.nix {};
|
2019-03-13 00:12:56 +00:00
|
|
|
knot = handleTest ./knot.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 {};
|
2021-07-30 16:16:23 +01:00
|
|
|
kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};
|
2018-11-11 11:30:07 +00:00
|
|
|
latestKernel.login = handleTest ./login.nix { latestKernel = true; };
|
|
|
|
|
leaps = handleTest ./leaps.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 {};
|
2021-11-18 18:10:48 +00:00
|
|
|
libresprite = handleTest ./libresprite.nix {};
|
2021-05-15 22:22:03 +01:00
|
|
|
libreswan = handleTest ./libreswan.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 {};
|
2019-03-16 12:24:23 +00:00
|
|
|
limesurvey = handleTest ./limesurvey.nix {};
|
2021-07-30 16:41:54 +01:00
|
|
|
litestream = handleTest ./litestream.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 {};
|
2019-06-27 17:11:09 +01:00
|
|
|
loki = handleTest ./loki.nix {};
|
2020-06-08 20:33:21 +01:00
|
|
|
lxd = handleTest ./lxd.nix {};
|
2021-10-19 16:27:01 +01:00
|
|
|
lxd-image = handleTest ./lxd-image.nix {};
|
2020-06-08 20:33:21 +01:00
|
|
|
lxd-nftables = handleTest ./lxd-nftables.nix {};
|
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 {};
|
2021-09-10 12:08:58 +01:00
|
|
|
maddy = handleTest ./maddy.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 {};
|
2021-09-24 19:54:08 +01:00
|
|
|
man = handleTest ./man.nix {};
|
2020-04-05 19:39:35 +01:00
|
|
|
mariadb-galera-mariabackup = handleTest ./mysql/mariadb-galera-mariabackup.nix {};
|
2020-04-05 19:58:27 +01:00
|
|
|
mariadb-galera-rsync = handleTest ./mysql/mariadb-galera-rsync.nix {};
|
2019-10-04 21:38:58 +01:00
|
|
|
matomo = handleTest ./matomo.nix {};
|
2020-08-30 08:42:21 +01:00
|
|
|
matrix-appservice-irc = handleTest ./matrix-appservice-irc.nix {};
|
2021-09-02 10:55:51 +01:00
|
|
|
matrix-conduit = handleTest ./matrix-conduit.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
matrix-synapse = handleTest ./matrix-synapse.nix {};
|
2021-04-12 02:29:29 +01:00
|
|
|
mattermost = handleTest ./mattermost.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 {};
|
2019-08-18 08:28:16 +01:00
|
|
|
metabase = handleTest ./metabase.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 {};
|
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 {};
|
2021-08-13 19:55:15 +01:00
|
|
|
mod_perl = handleTest ./mod_perl.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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
morty = handleTest ./morty.nix {};
|
2019-04-24 09:23:13 +01:00
|
|
|
mosquitto = handleTest ./mosquitto.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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
mumble = handleTest ./mumble.nix {};
|
2021-02-27 01:26:02 +00:00
|
|
|
musescore = handleTest ./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 {};
|
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-16 18:59:36 +00:00
|
|
|
nano = handleTest ./nano.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.firewall-conntrack = handleTest ./nat.nix { withFirewall = true; withConntrackHelpers = true; };
|
|
|
|
|
nat.standalone = handleTest ./nat.nix { withFirewall = false; };
|
2021-06-26 12:58:40 +01:00
|
|
|
nats = handleTest ./nats.nix {};
|
2020-12-05 18:11:21 +00:00
|
|
|
navidrome = handleTest ./navidrome.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 {};
|
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; };
|
2020-11-29 23:00:38 +00:00
|
|
|
specialisation = handleTest ./specialisation.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: 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 20:00:27 +01:00
|
|
|
nginx-sandbox = handleTestOn ["x86_64-linux"] ./nginx-sandbox.nix {};
|
2018-12-28 10:41:52 +00:00
|
|
|
nginx-sso = handleTest ./nginx-sso.nix {};
|
2020-06-02 06:01:03 +01:00
|
|
|
nginx-variants = handleTest ./nginx-variants.nix {};
|
2021-07-26 11:00:05 +01:00
|
|
|
nitter = handleTest ./nitter.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 {};
|
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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
novacomd = handleTestOn ["x86_64-linux"] ./novacomd.nix {};
|
|
|
|
|
nsd = handleTest ./nsd.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 {};
|
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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
openssh = handleTest ./openssh.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 {};
|
2021-09-23 09:48:29 +01:00
|
|
|
owncast = handleTest ./owncast.nix {};
|
2020-12-20 20:18:54 +00:00
|
|
|
image-contents = handleTest ./image-contents.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 {};
|
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 {};
|
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 {};
|
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 {};
|
2021-05-13 15:42:22 +01:00
|
|
|
paperless-ng = handleTest ./paperless-ng.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 {};
|
2021-05-31 12:23:06 +01:00
|
|
|
peertube = handleTestOn ["x86_64-linux"] ./web-apps/peertube.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
pgjwt = handleTest ./pgjwt.nix {};
|
|
|
|
|
pgmanage = handleTest ./pgmanage.nix {};
|
2020-03-30 21:07:05 +01:00
|
|
|
php = handleTest ./php {};
|
2021-02-28 20:16:08 +00:00
|
|
|
php74 = handleTest ./php { php = pkgs.php74; };
|
|
|
|
|
php80 = handleTest ./php { php = pkgs.php80; };
|
2021-11-25 20:38:19 +00:00
|
|
|
php81 = handleTest ./php { php = pkgs.php81; };
|
2020-06-03 22:12:06 +01:00
|
|
|
pinnwand = handleTest ./pinnwand.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 {};
|
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 {};
|
2021-12-09 02:10:44 +00:00
|
|
|
podman = handleTestOn ["x86_64-linux"] ./podman/default.nix {};
|
|
|
|
|
podman-dnsname = handleTestOn ["x86_64-linux"] ./podman/dnsname.nix {};
|
|
|
|
|
podman-tls-ghostunnel = handleTestOn ["x86_64-linux"] ./podman/tls-ghostunnel.nix {};
|
2021-01-08 03:03:00 +00:00
|
|
|
pomerium = handleTestOn ["x86_64-linux"] ./pomerium.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 {};
|
|
|
|
|
postgresql = handleTest ./postgresql.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 {};
|
|
|
|
|
printing = handleTest ./printing.nix {};
|
2020-04-21 12:37:00 +01:00
|
|
|
privacyidea = handleTest ./privacyidea.nix {};
|
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 {};
|
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 {};
|
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 {};
|
2020-03-22 16:26:55 +00:00
|
|
|
quorum = handleTest ./quorum.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rabbitmq = handleTest ./rabbitmq.nix {};
|
2019-01-24 22:09:21 +00:00
|
|
|
radarr = handleTest ./radarr.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
radicale = handleTest ./radicale.nix {};
|
2021-02-02 00:39:50 +00:00
|
|
|
rasdaemon = handleTest ./rasdaemon.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 {};
|
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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
rspamd = handleTest ./rspamd.nix {};
|
2018-10-27 10:33:43 +01:00
|
|
|
rss2email = handleTest ./rss2email.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 {};
|
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 {};
|
2020-02-28 11:17:01 +00:00
|
|
|
service-runner = handleTest ./service-runner.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 {};
|
|
|
|
|
slurm = handleTest ./slurm.nix {};
|
|
|
|
|
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 {};
|
2020-05-12 17:32:39 +01:00
|
|
|
sogo = handleTest ./sogo.nix {};
|
2021-05-20 21:03:39 +01:00
|
|
|
solanum = handleTest ./solanum.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
solr = handleTest ./solr.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
sonarr = handleTest ./sonarr.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 {};
|
2021-10-20 21:33:56 +01:00
|
|
|
spark = handleTestOn ["x86_64-linux"] ./spark {};
|
2020-01-18 12:00:00 +00:00
|
|
|
sslh = handleTest ./sslh.nix {};
|
2020-08-24 14:55:22 +01:00
|
|
|
sssd = handleTestOn ["x86_64-linux"] ./sssd.nix {};
|
2020-09-01 06:03:20 +01: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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
strongswan-swanctl = handleTest ./strongswan-swanctl.nix {};
|
|
|
|
|
sudo = handleTest ./sudo.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 {};
|
2019-04-21 22:05:07 +01:00
|
|
|
syncthing-init = handleTest ./syncthing-init.nix {};
|
2018-11-17 14:02:00 +00:00
|
|
|
syncthing-relay = handleTest ./syncthing-relay.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 {};
|
2019-03-14 14:26:10 +00:00
|
|
|
systemd-confinement = handleTest ./systemd-confinement.nix {};
|
2021-10-04 11:54:13 +01:00
|
|
|
systemd-cryptenroll = handleTest ./systemd-cryptenroll.nix {};
|
2020-11-01 17:48:40 +00:00
|
|
|
systemd-journal = handleTest ./systemd-journal.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 {};
|
2019-11-02 18:55:41 +00:00
|
|
|
systemd-nspawn = handleTest ./systemd-nspawn.nix {};
|
2020-11-29 23:00:38 +00:00
|
|
|
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
|
2021-03-15 18:34:09 +00:00
|
|
|
systemd-unit-path = handleTest ./systemd-unit-path.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
taskserver = handleTest ./taskserver.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 {};
|
2019-04-29 21:46:00 +01:00
|
|
|
tiddlywiki = handleTest ./tiddlywiki.nix {};
|
2020-04-13 04:56:20 +01:00
|
|
|
tigervnc = handleTest ./tigervnc.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 {};
|
2021-12-28 20:32:26 +00:00
|
|
|
tinywl = handleTest ./tinywl.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
tor = handleTest ./tor.nix {};
|
2021-10-29 18:42:32 +01:00
|
|
|
# traefik test relies on docker-containers
|
2020-04-06 07:21:35 +01:00
|
|
|
traefik = handleTestOn ["x86_64-linux"] ./traefik.nix {};
|
2021-04-09 17:48:51 +01:00
|
|
|
trafficserver = handleTest ./trafficserver.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
transmission = handleTest ./transmission.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 {};
|
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 {};
|
2021-06-13 21:00:25 +01:00
|
|
|
ucarp = handleTest ./ucarp.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
udisks2 = handleTest ./udisks2.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 {};
|
2018-11-11 11:30:07 +00:00
|
|
|
upnp = handleTest ./upnp.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 {};
|
2019-05-27 22:03:22 +01:00
|
|
|
uwsgi = handleTest ./uwsgi.nix {};
|
2020-06-12 09:12:51 +01:00
|
|
|
v2ray = handleTest ./v2ray.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
vault = handleTest ./vault.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 {};
|
2021-11-19 20:21:20 +00:00
|
|
|
vscodium = discoverTests (import ./vscodium.nix);
|
2020-06-18 13:19:13 +01:00
|
|
|
wasabibackend = handleTest ./wasabibackend.nix {};
|
2021-03-18 11:33:40 +00:00
|
|
|
wiki-js = handleTest ./wiki-js.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 {};
|
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 {};
|
|
|
|
|
xrdp = handleTest ./xrdp.nix {};
|
|
|
|
|
xss-lock = handleTest ./xss-lock.nix {};
|
2020-11-17 03:13:13 +00:00
|
|
|
xterm = handleTest ./xterm.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 {};
|
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 {};
|
2020-04-11 18:28:52 +01:00
|
|
|
zsh-history = handleTest ./zsh-history.nix {};
|
2018-11-11 11:30:07 +00:00
|
|
|
}
|
