movefasta/nixpkgs
1
0
Fork 0
mirror of https://github.com/NixOS/nixpkgs.git synced 2025-06-10 03:23:29 +03:00
Code Issues Projects Releases Packages Wiki Activity
nixpkgs/nixos/tests/all-tests.nix

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

1274 lines
62 KiB
Nix
Raw Normal View History

nixos/testing: Embrace callTest My conception of its input was wrong. It is quite a useful construct, even if its name is a bit weird.
2022-06-25 12:47:50 +02:00
{ system,
pkgs,
# Projects the test configuration into a the desired value; usually
# the test runner: `config: config.test`.
callTest,
}:
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
# The return value of this function will be an attrset with arbitrary depth and
# the `anything` returned by callTest at its test leafs.
# The tests not supported by `system` will be replaced with `{}`, so that
meta.tests: rename into passthru.tests Nix currently rejects derivations in `meta` values. This works around that limitation by using `passthru` instead. Closes https://github.com/NixOS/nixpkgs/issues/50230
2018-11-11 22:55:23 +09:00
# `passthru.tests` can contain links to those without breaking on architectures
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09: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:
nixos/all-tests.nix: Invoke tests based on make-test-python.nix
2022-06-25 21:26:50 +02:00
if isAttrs val
then
if hasAttr "test" val then callTest val
all-tests: exclude passthru attributes from test discovery discoverTests tries to discover some sort of internal function and tries to call it with the arguments for that internal function. This poses an issue when you want to expose some other functions (i.e. a parameterisation for a test) in nixosTests. This commit allows a test to pass through arbitrary values via `.passthru` without them having discovery applied to them; including functions.
2023-08-06 15:40:10 +02:00
else mapAttrs (n: s: if n == "passthru" then s else discoverTests s) val
nixos/all-tests.nix: Invoke tests based on make-test-python.nix
2022-06-25 21:26:50 +02:00
else if isFunction val
then
# Tests based on make-test-python.nix will return the second lambda
# in that file, which are then forwarded to the test definition
# following the `import make-test-python.nix` expression
# (if it is a function).
discoverTests (val { inherit system pkgs; })
else val;
nixos: Document handleTest deprecation
2025-02-21 10:14:58 +01:00
/**
Evaluate a test and return a derivation that runs the test as its builder.
This function is deprecated in favor of runTest and runTestOn, which works
by passing a module instead of a specific set of arguments.
Benefits of runTest and runTestOn:
- Define values for any test option
- Use imports to compose tests
- Access the module arguments like hostPkgs and config.node.pkgs
- Portable to other VM hosts, specifically Darwin
- Faster evaluation, using a single `pkgs` instance
Changes required to migrate to runTest:
- Remove any `import ../make-test-python.nix` or similar calls, leaving only
the callback function.
- Convert the function header to make it a module.
Packages can be taken from the following. For VM host portability, use
- `config.node.pkgs.<name>` or `config.nodes.foo.nixpkgs.pkgs.<name>` to refer
to the Nixpkgs used on the VM guest(s).
- `hostPkgs.<name>` when invoking commands on the VM host (e.g. in Python
`os.system("foo")`)
- Since the runTest argument is a module instead of a function, arguments
must be passed as option definitions.
You may declare explicit `options` for the test parameter(s), or use the
less explicit `_module.args.<name>` to pass arguments to the module.
Example call with arguments:
runTest {
imports = [ ./test.nix ];
_module.args.getPackage = pkgs: pkgs.foo_1_2;
}
- If your test requires any definitions in `nixpkgs.*` options, set
`node.pkgsReadOnly = false` in the test configuration.
*/
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
handleTest = path: args:
discoverTests (import path ({ inherit system pkgs; } // args));
nixos: Document handleTest deprecation
2025-02-21 10:14:58 +01:00
/** See handleTest */
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
handleTestOn = systems: path: args:
if elem system systems then handleTest path args
else {};
nixos/nixpkgs.nix: Make independent (cherry picked from commit 62e7f0eda1c5acf0beb13a00a23f577912a6b8eb)
2021-12-03 12:04:36 +00:00
nixos/lib: Add featureFlags, use it for minimal modules
2022-01-07 01:09:46 +01:00
nixosLib = import ../lib {
# Experimental features need testing too, but there's no point in warning
# about it, so we enable the feature flag.
featureFlags.minimalModules = {};
};
nixos/nixpkgs.nix: Make independent (cherry picked from commit 62e7f0eda1c5acf0beb13a00a23f577912a6b8eb)
2021-12-03 12:04:36 +00:00
evalMinimalConfig = module: nixosLib.evalModules { modules = [ module ]; };
nixosTests: Add allDrivers for development purposes
2022-06-03 14:34:29 +02:00
nixos/all-tests.nix: Improve runTest for release.nix ... and add runTestOn.
2022-06-06 20:19:59 +02:00
inherit
(rec {
nixos/testing: Fix release.nix tests evaluation Fixes the problem introduced by 12b3066aae46a8ccc3d21f54f668a3f4be344332 which caused nixos/release.nix to return the wrong attributes, while intending to only affect nixos/lib's runTest. This also removes callTest from the test options, because callTest is only ever invoked by all-tests.nix.
2022-09-29 10:32:31 +02:00
doRunTest = arg: ((import ../lib/testing-python.nix { inherit system pkgs; }).evalTest {
nixos/all-tests: Enable readOnlyPkgs by default for runTest Most tests are not affected by this because they use the `handleTest` function instead.
2023-05-07 19:25:33 +02:00
imports = [ arg readOnlyPkgs ];
nixos/testing: Fix release.nix tests evaluation Fixes the problem introduced by 12b3066aae46a8ccc3d21f54f668a3f4be344332 which caused nixos/release.nix to return the wrong attributes, while intending to only affect nixos/lib's runTest. This also removes callTest from the test options, because callTest is only ever invoked by all-tests.nix.
2022-09-29 10:32:31 +02:00
}).config.result;
nixos/all-tests.nix: Improve runTest for release.nix ... and add runTestOn.
2022-06-06 20:19:59 +02:00
findTests = tree:
if tree?recurseForDerivations && tree.recurseForDerivations
nixos/testing: Embrace callTest My conception of its input was wrong. It is quite a useful construct, even if its name is a bit weird.
2022-06-25 12:47:50 +02:00
then
mapAttrs
(k: findTests)
(builtins.removeAttrs tree ["recurseForDerivations"])
else callTest tree;
nixos/all-tests.nix: Improve runTest for release.nix ... and add runTestOn.
2022-06-06 20:19:59 +02:00
runTest = arg: let r = doRunTest arg; in findTests r;
runTestOn = systems: arg:
if elem system systems then runTest arg
else {};
})
nixos: Document handleTest deprecation
2025-02-21 10:14:58 +01:00
/** See https://nixos.org/manual/nixos/unstable/#sec-calling-nixos-tests */
nixos/all-tests.nix: Improve runTest for release.nix ... and add runTestOn.
2022-06-06 20:19:59 +02:00
runTest
nixos: Document handleTest deprecation
2025-02-21 10:14:58 +01:00
/** See https://nixos.org/manual/nixos/unstable/#sec-calling-nixos-tests */
nixos/all-tests.nix: Improve runTest for release.nix ... and add runTestOn.
2022-06-06 20:19:59 +02:00
runTestOn
;
nixos/all-tests.nix: Add readOnlyPkgs module
2023-05-07 15:44:54 +02:00
# Using a single instance of nixpkgs makes test evaluation faster.
# To make sure we don't accidentally depend on a modified pkgs, we make the
# related options read-only. We need to test the right configuration.
#
# If your service depends on a nixpkgs setting, first try to avoid that, but
# otherwise, you can remove the readOnlyPkgs import and test your service as
# usual.
readOnlyPkgs =
# TODO: We currently accept this for nixosTests, so that the `pkgs` argument
# is consistent with `pkgs` in `pkgs.nixosTests`. Can we reinitialize
# it with `allowAliases = false`?
# warnIf pkgs.config.allowAliases "nixosTests: pkgs includes aliases."
{
macOS support for NixOS tests (#282401) Closes #193336 Closes #261694 Related to #108984 The goal here was to get the following flake to build and run on `aarch64-darwin`: ```nix { inputs.nixpkgs.url = <this branch>; outputs = { nixpkgs, ... }: { checks.aarch64-darwin.default = nixpkgs.legacyPackages.aarch64-darwin.nixosTest { name = "test"; nodes.machine = { }; testScript = ""; }; }; } ``` … and after this change it does. There's no longer a need for the user to set `nodes.*.nixpkgs.pkgs` or `nodes.*.virtualisation.host.pkgs` as the correct values are inferred from the host system.
2024-03-01 21:33:14 -08:00
_file = "${__curPos.file} readOnlyPkgs";
nixos/all-tests.nix: Add readOnlyPkgs module
2023-05-07 15:44:54 +02:00
_class = "nixosTest";
macOS support for NixOS tests (#282401) Closes #193336 Closes #261694 Related to #108984 The goal here was to get the following flake to build and run on `aarch64-darwin`: ```nix { inputs.nixpkgs.url = <this branch>; outputs = { nixpkgs, ... }: { checks.aarch64-darwin.default = nixpkgs.legacyPackages.aarch64-darwin.nixosTest { name = "test"; nodes.machine = { }; testScript = ""; }; }; } ``` … and after this change it does. There's no longer a need for the user to set `nodes.*.nixpkgs.pkgs` or `nodes.*.virtualisation.host.pkgs` as the correct values are inferred from the host system.
2024-03-01 21:33:14 -08:00
node.pkgs = pkgs.pkgsLinux;
nixos/all-tests.nix: Add readOnlyPkgs module
2023-05-07 15:44:54 +02:00
};
nixosTests.allDrivers: Move logic to all-packages.nix Bring it in line with release.nix
2022-06-06 19:24:30 +02:00
in {
nixos/tests: extra-python-packages -> nixos-test-driver/extra-python-packages Categorizing the tests for the test driver helps with testing the test driver.
2023-04-25 11:59:14 +02:00
# Testing the test driver
nixos-test-driver = {
extra-python-packages = handleTest ./nixos-test-driver/extra-python-packages.nix {};
nixosTest: provide a test for lib.extend in nixosTests & runNixOSTest
2023-06-03 20:10:20 -07:00
lib-extend = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./nixos-test-driver/lib-extend.nix {};
nixosTests.nixos-test-driver.node-name: init
2023-04-25 12:21:38 +02:00
node-name = runTest ./nixos-test-driver/node-name.nix;
nixos/test-driver: add a test for #241938.
2023-07-07 10:58:13 +02:00
busybox = runTest ./nixos-test-driver/busybox.nix;
nixos/tests/nixos-test-driver: test timeout failures We test that the test framework timeouts are working as expected.
2023-10-27 13:32:04 +02:00
driver-timeout = pkgs.runCommand "ensure-timeout-induced-failure" {
failed = pkgs.testers.testBuildFailure ((runTest ./nixos-test-driver/timeout.nix).config.rawTestDerivation);
} ''
grep -F "timeout reached; test terminating" $failed/testBuildFailure.log
# The program will always be terminated by SIGTERM (143) if it waits for the deadline thread.
[[ 143 = $(cat $failed/testBuildFailure.exit) ]]
touch $out
'';
nixos/tests: extra-python-packages -> nixos-test-driver/extra-python-packages Categorizing the tests for the test driver helps with testing the test driver.
2023-04-25 11:59:14 +02:00
};
# NixOS vm tests and non-vm unit tests
nixos/testing: Add pkgs parameter This parameter is for packages to use in VMs, unlike hostPkgs.
2022-06-06 21:19:22 +02:00
_3proxy = runTest ./3proxy.nix;
nixos/tests/aaaaxy: init Add a simple VM test for the game AAAAXY.
2023-04-04 20:18:38 +02:00
aaaaxy = runTest ./aaaaxy.nix;
nixosTests.acme: Use module system based runner
2022-06-06 23:49:59 +02:00
acme = runTest ./acme.nix;
nixosTests.acme-dns: init
2023-05-31 15:08:39 +02:00
acme-dns = handleTest ./acme-dns.nix {};
nixos/actual: init module and tests Co-authored-by: PatrickDaG <58092422+PatrickDaG@users.noreply.github.com>
2024-10-11 03:06:31 +02:00
actual = handleTest ./actual.nix {};
nixosTests.adguardhome: Use module based runner
2022-06-09 17:43:22 +02:00
adguardhome = runTest ./adguardhome.nix;
nixos/aesmd: add option to configure quote provider library Changes sgx-psw to append `aesm` to `LD_LIBRARY_PATH`: - Append instead of prepend to allow for overriding in service config - As we already add a wrapper to add `aesm` to `LD_LIBRARY_PATH` it is not necessary to also set in `LD_LIBRARY_PATH` of the systemd service. Co-authored-by: Vincent Haupert <mail@vincent-haupert.de>
2022-11-25 19:20:39 +01:00
aesmd = runTestOn ["x86_64-linux"] ./aesmd.nix;
nixosTests.agate: Use module based runner
2022-06-09 17:46:51 +02:00
agate = runTest ./web-servers/agate.nix;
agda: Added test
2020-04-19 20:01:37 +02:00
agda = handleTest ./agda.nix {};
age-plugin-tpm: 0.2.0 -> 0.3.0
2025-02-16 09:49:59 -08:00
age-plugin-tpm-decrypt = runTest ./age-plugin-tpm-decrypt.nix;
nixos/tests/agorakit: init test
2024-10-14 23:25:16 +02:00
agorakit = runTest ./web-apps/agorakit.nix;
airsonic: add test for module
2021-05-03 09:38:02 -06:00
airsonic = handleTest ./airsonic.nix {};
nixos/tests/akkoma: init This test is based in part on nixos/tests/pleroma.
2022-09-24 15:52:36 +02:00
akkoma = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix {};
akkoma-confined = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./akkoma.nix { confined = true; };
nixos/alice-lg: init
2023-04-11 17:55:16 +02:00
alice-lg = handleTest ./alice-lg.nix {};
nixosTests.alloy: init VM test This adds a VM test, starting up Grafana Alloy and ensuring it comes up healthy.
2024-06-08 18:31:12 +03:00
alloy = handleTest ./alloy.nix {};
nixos/terminfo: add enableAllTerminfo option Add an option to install all .terminfo packages, normally this should add no runtime bloat, if caches are used.
2021-10-05 14:33:18 +03:00
allTerminfo = handleTest ./all-terminfo.nix {};
nixos/alps: add hardening, extensible options, test
2022-11-16 17:56:44 +01:00
alps = handleTest ./alps.nix {};
amazon-cloudwatch-agent: init at 1.300049.1
2024-08-27 01:53:59 -04:00
amazon-cloudwatch-agent = handleTest ./amazon-cloudwatch-agent.nix {};
nixos/amazon-init: add user-data shell script support
2021-04-18 10:19:06 +01:00
amazon-init-shell = handleTest ./amazon-init-shell.nix {};
nixosTests.amazon-ssm-agent: init
2023-10-25 11:29:11 +02:00
amazon-ssm-agent = handleTest ./amazon-ssm-agent.nix {};
nixos/amd.sev: add test
2023-08-10 20:42:41 +02:00
amd-sev = runTest ./amd-sev.nix;
nixos/tests: add test api in angie package
2023-11-20 23:22:02 +03:00
angie-api = handleTest ./angie-api.nix {};
nixos/tests/anki-sync-server: add anki sync test Start anki-sync-server service and drive anki manually through its python lib to test sync. The anki python part isn't a stable API and might require freqent rework, let's see if it holds up...
2023-09-25 22:01:02 +09:00
anki-sync-server = handleTest ./anki-sync-server.nix {};
nixos/anuko-time-tracker: init
2023-06-27 12:30:06 +02:00
anuko-time-tracker = handleTest ./anuko-time-tracker.nix {};
nixos/tests/apcupsd.nix: init This verifies that https://github.com/NixOS/nixpkgs/issues/208204 ("apcupsd: apcaccess does not respect config from services.apcupsd") is fixed.
2022-12-29 13:43:50 +01:00
apcupsd = handleTest ./apcupsd.nix {};
nixos/tests/apfs: clean up code - Use `runTest` instead of `handleTest`, which simplifies the code a little - Use `lib.maintainers` instead of `pkgs.lib.maintainers` - Remove unused function argument `pkgs` - Change test name in the kernel module from `test` to `apfs`, since that seems to be a common pattern for the name
2023-04-04 20:12:51 +02:00
apfs = runTest ./apfs.nix;
nixos/tests/appliance-repart-image: init
2023-07-16 22:16:55 +02:00
appliance-repart-image = runTest ./appliance-repart-image.nix;
nixos/tests/appliance-repart-image-verity-store: init This test should illustrate how to build a verity-protected NixOS image with systemd-repart, using the opinionated image.repart.verityStore module.
2024-09-18 19:26:31 +02:00
appliance-repart-image-verity-store = runTest ./appliance-repart-image-verity-store.nix;
nixos/tests/apparmor: move to folder, refactor, improve coverage - nixfmt on apparmor test - move apparmor test to nixos/tests/apparmor directory - expected profile contents are now generated in its own file to make the test file less confusing and hard to maintain - enforce/complain is now being tested via diff of expected against aa-status - path is now tested against diff+file checking symlink target of /etc/static/apparmor.d/<name> - profile is now checked by diff of /etc/static/apparmor.d/<name> against original string added in nix config - test still successfully passes - added test for confined hello to succeed - added test for confined hexdump on denied path to fail
2024-12-03 22:18:24 +01:00
apparmor = handleTest ./apparmor {};
nixos/tests/archi: init smoke tests for Archi
2023-10-31 01:06:08 +01:00
archi = handleTest ./archi.nix {};
nixos/aria2: add test
2024-04-16 19:14:48 +02:00
aria2 = handleTest ./aria2.nix {};
nixos/armagetronad: add module with tests
2023-11-25 13:06:11 -08:00
armagetronad = handleTest ./armagetronad.nix {};
nixosTests.artalk: add auth test
2024-11-21 12:52:14 +08:00
artalk = runTest ./artalk.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
atd = handleTest ./atd.nix {};
nixos/atop: Add configuration for atop services, allow to enable netatop, gpuatop, allow setuid wrapper
2021-05-14 02:11:05 +02:00
atop = handleTest ./atop.nix {};
nixos/atticd: init module Copied from https://github.com/zhaofengli/attic/blob/1b29816235b7573fca7f964709fd201e1a187024/nixos/atticd.nix and modified
2024-10-10 10:57:51 -04:00
atticd = runTest ./atticd.nix;
atuin: switch to runTest to run the VM test
2024-12-30 10:20:05 +02:00
atuin = runTest ./atuin.nix;
audiobookshelf: init module
2023-09-29 11:46:13 +02:00
audiobookshelf = handleTest ./audiobookshelf.nix {};
nixos/mysql-auth: add VM-Test
2022-07-31 23:40:48 +02:00
auth-mysql = handleTest ./auth-mysql.nix {};
nixos/authelia: init tests
2023-03-02 21:18:50 +00:00
authelia = handleTest ./authelia.nix {};
nixos/auto-cpufreq: init vm test Even though cpufreq cannot be adjusted within qemu this test is still useful to ensure that the service is running and the auto-cpufreq cli is able to interact with the auto-cpufreq service.
2024-10-21 19:00:20 +00:00
auto-cpufreq = handleTest ./auto-cpufreq.nix {};
nixos/autobrr: init
2024-02-09 17:55:06 -05:00
autobrr = handleTest ./autobrr.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
avahi = handleTest ./avahi.nix {};
nixosTests.avahi: add avahi-with-resolved This allows testing avahi works with resolved being enabled, as a regression test for https://github.com/NixOS/nixpkgs/pull/99530.
2020-10-11 20:45:25 +02:00
avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };
tests/ayatana-indicators: nixfmt, modernise
2024-08-15 22:06:15 +02:00
ayatana-indicators = runTest ./ayatana-indicators.nix;
nixos/tests: add babeld
2019-10-12 01:30:55 +02:00
babeld = handleTest ./babeld.nix {};
nixos/bazarr: init
2020-05-10 12:54:09 +02:00
bazarr = handleTest ./bazarr.nix {};
linux_testing_bcachefs, bcachefs-tools: unstable-2021-07-08 → unstable-2021-11-06 bcachefs now supports snapshots so we need the latest version to use them. Additionally, it appears to build on AArch64 so I've removed the x86 requirement.
2021-11-06 21:24:16 +00:00
bcachefs = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bcachefs.nix {};
nixos/beanstalkd: new service for existing package (#55953)
2019-02-22 08:10:02 -05:00
beanstalkd = handleTest ./beanstalkd.nix {};
nixosTests.bees: port to python
2019-11-24 01:10:17 +01:00
bees = handleTest ./bees.nix {};
nixos/benchexec: init
2024-05-17 21:19:41 +02:00
benchexec = handleTest ./benchexec.nix {};
Introduce mkBinaryCache function
2022-10-03 22:06:28 -06:00
binary-cache = handleTest ./binary-cache.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
bind = handleTest ./bind.nix {};
nixos/tests/bird: init
2022-01-25 15:15:52 +01:00
bird = handleTest ./bird.nix {};
nixos/birdwatcher: init
2023-04-12 09:20:16 +02:00
birdwatcher = handleTest ./birdwatcher.nix {};
nixos/bitcoind: add tests
2020-07-21 13:43:32 +02:00
bitcoind = handleTest ./bitcoind.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
bittorrent = handleTest ./bittorrent.nix {};
nixos/blockbook-frontend: add tests
2020-06-23 13:09:03 +02:00
blockbook-frontend = handleTest ./blockbook-frontend.nix {};
nixos/blocky: init
2022-02-10 19:44:18 -03:00
blocky = handleTest ./blocky.nix {};
nixos/boot: test on aarch64
2021-05-25 21:13:29 +03:00
boot = handleTestOn ["x86_64-linux" "aarch64-linux"] ./boot.nix {};
nixos/tests: expose bootspec test On x86_64-linux only because bootspec is for NixOS (for the moment?), and NixOS is really only a Linux concept (for the moment?). Not on aarch64-linux because it fails for whatever reason 🤷
2022-12-21 14:11:37 -08:00
bootspec = handleTestOn ["x86_64-linux"] ./bootspec.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
boot-stage1 = handleTest ./boot-stage1.nix {};
nixos/tests: add boot-stage2 tests - Test RO store mount even given the presence of filesystems with options ending in "ro" - Test postBootCommands in stage2
2025-01-19 23:02:25 -08:00
boot-stage2 = handleTest ./boot-stage2.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
borgbackup = handleTest ./borgbackup.nix {};
nixos/borgmatic: added test
2024-03-02 12:24:17 +01:00
borgmatic = handleTest ./borgmatic.nix {};
nixos/tests/botamusique: init
2021-05-04 14:30:25 +02:00
botamusique = handleTest ./botamusique.nix {};
nixos/tests: add bpf test test bcc and bpftrace briefly
2021-12-04 10:20:26 +09:00
bpf = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bpf.nix {};
nixos/bpftune: init basic test
2023-06-29 10:43:06 +08:00
bpftune = handleTest ./bpftune.nix {};
breitbandmessung: init at 3.1.0
2022-01-26 14:03:05 +01:00
breitbandmessung = handleTest ./breitbandmessung.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
brscan5 = handleTest ./brscan5.nix {};
nixos/btrbk: add module and test
2021-05-30 12:00:00 +00:00
btrbk = handleTest ./btrbk.nix {};
btrbk: add doas variant of module test
2022-10-02 12:42:57 +02:00
btrbk-doas = handleTest ./btrbk-doas.nix {};
nixos/btrbk: allow instances without timers This allows btrbk instances without a triggering timer by setting `onCalendar` to `null`. This is useful for manual-starting only btrbk backup settings.
2022-03-19 23:51:32 +08:00
btrbk-no-timer = handleTest ./btrbk-no-timer.nix {};
nixos/btrbk: fix ordering of subsections and refactor
2022-10-18 23:50:44 +08:00
btrbk-section-order = handleTest ./btrbk-section-order.nix {};
nixos/tests/budgie: init Signed-off-by: Federico Damián Schonborn <fdschonborn@gmail.com>
2023-02-16 23:48:02 -03:00
budgie = handleTest ./budgie.nix {};
buildbot: 3.10.0 -> 3.10.1 Changelog: https://github.com/buildbot/buildbot/releases/tag/v3.10.1
2023-12-26 21:13:50 +00:00
buildbot = handleTest ./buildbot.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
buildkite-agents = handleTest ./buildkite-agents.nix {};
nixos/c2fmzq-server: add test Co-authored-by: h7x4 <h7x4@nani.wtf>
2023-10-01 22:09:53 +02:00
c2fmzq = handleTest ./c2fmzq.nix {};
nixos/caddy: add tests (#70778)
2019-10-09 13:32:03 +02:00
caddy = handleTest ./caddy.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
cadvisor = handleTestOn ["x86_64-linux"] ./cadvisor.nix {};
nixos/tests/{sway,cage,cagebreak}: Fix the tests on aarch64-linux Since the update to wlroots 0.13 (e03dde82a74) the default VGA card isn't supported anymore and we needed to switch to virtio (qxl didn't work either). However, as it turned out "-vga virtio" (28b8cff301f) broke the test on AArch64. Luckily there's a third option that works on all three supported platforms: virtio-gpu-pci According to [0] "This device lacks VGA compatibility mode but is otherwise identical to the virtio vga device. UEFI firmware can handle this, and if your guests has drivers too you can use this instead of virtio-vga. This will reduce the attack surface (no complex VGA emulation support) and reduce the memory footprint by 8 MB (no pci memory bar for VGA compatibility). This device can be placed in a PCI Express slot." So in the end this seems like the ideal choice :) See also [1]. [0]: https://www.kraxel.org/blog/2019/09/display-devices-in-qemu/#virtio-gpu-pci [1]: https://patches.openembedded.org/patch/164351/
2021-05-27 20:37:24 +02:00
cage = handleTest ./cage.nix {};
cagebreak = handleTest ./cagebreak.nix {};
nixos/calibre-web: init module
2021-02-23 14:23:20 +03:00
calibre-web = handleTest ./calibre-web.nix {};
services/calibre-server: Add new http & auth options (#216497) nixos/doc: add calibre-server new options
2023-06-28 14:06:47 +02:00
calibre-server = handleTest ./calibre-server.nix {};
nixos/canaille: init module Co-Authored-By: Janik <80165193+Janik-Haag@users.noreply.github.com>
2024-08-15 16:35:10 +02:00
canaille = handleTest ./canaille.nix {};
nixosTests.castopod: init
2023-04-07 16:36:13 +03:00
castopod = handleTest ./castopod.nix {};
cassandra: Add passthru.tests
2020-12-09 13:01:56 +01:00
cassandra_3_0 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_0; };
cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; };
cassandra_4: init
2022-04-06 13:03:07 +02:00
cassandra_4 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_4; };
centrifugo: init at 5.1.1
2023-08-15 06:34:32 +03:00
centrifugo = runTest ./centrifugo.nix;
nixos/tests/ceph*: Enable on aarch64-linux
2023-03-24 14:29:07 +01:00
ceph-multi-node = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-multi-node.nix {};
ceph-single-node = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node.nix {};
ceph-single-node-bluestore = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node-bluestore.nix {};
tests/ceph: bluestore, dmcrypt, and IPv6 test Signed-off-by: benaryorg <binary@benary.org>
2024-08-22 13:31:52 +00:00
ceph-single-node-bluestore-dmcrypt = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./ceph-single-node-bluestore-dmcrypt.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
certmgr = handleTest ./certmgr.nix {};
nixosTests.cfssl: enable on aarch64-linux
2022-09-24 17:38:37 +10:00
cfssl = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cfssl.nix {};
nixos/cgit: init
2022-04-05 02:02:11 +02:00
cgit = handleTest ./cgit.nix {};
charliecloud: 0.12 -> 0.18 (docker + ch-grow support)
2020-08-25 09:44:27 +02:00
charliecloud = handleTest ./charliecloud.nix {};
nixos/chromadb: init
2024-08-16 18:14:15 +02:00
chromadb = runTest ./chromadb.nix;
nixos/tests/chromium: Enable on aarch64-linux
2022-10-09 23:29:45 +02:00
chromium = (handleTestOn ["aarch64-linux" "x86_64-linux"] ./chromium.nix {}).stable or {};
nixos/chrony: add simple test
2023-08-10 02:02:33 +02:00
chrony = handleTestOn ["aarch64-linux" "x86_64-linux"] ./chrony.nix {};
chrony: add nixos test for ptp_kvm
2023-01-15 14:06:58 +01:00
chrony-ptp = handleTestOn ["aarch64-linux" "x86_64-linux"] ./chrony-ptp.nix {};
nixos/tests/cinnamon: init
2022-09-05 15:40:17 +08:00
cinnamon = handleTest ./cinnamon.nix {};
nixosTests.cinnamon-wayland: init
2023-11-20 00:10:36 +08:00
cinnamon-wayland = handleTest ./cinnamon-wayland.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
cjdns = handleTest ./cjdns.nix {};
nixos/tests/clatd: init
2022-10-23 01:13:35 +02:00
clatd = handleTest ./clatd.nix {};
clickhouse: fix module and package runtime Although the package itself builds fine, the module fails because it tries to log into a non-existant file in `/var/log` which breaks the service. Patching to default config to log to stdout by default fixes the issue. Additionally this is the better solution as NixOS heavily relies on systemd (and thus journald) for logging. Also, the runtime relies on `/etc/localtime` to start, as it's not required by the module system we set UTC as sensitive default when using the module. To ensure that the service's basic functionality is available, a simple NixOS test has been added.
2018-12-19 15:06:53 +01:00
clickhouse = handleTest ./clickhouse.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
cloud-init = handleTest ./cloud-init.nix {};
nixos/cloud-init: fix hostname and resolvconf configuration - Fix hostname configuration on proxmox, which uses "hostname" in user-data instead of "local-hostname" in meta-data. - Allow setting resolv.conf through cloud-init - Add tests for new changes - Add timeouts to make tests fail faster
2022-09-30 19:38:49 +05:30
cloud-init-hostname = handleTest ./cloud-init-hostname.nix {};
nixos/cloudlog: init
2023-01-01 23:19:37 +00:00
cloudlog = handleTest ./cloudlog.nix {};
cntr: only run nixosTests on aarch64/x86_64
2022-09-24 16:15:39 +10:00
cntr = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cntr.nix {};
nixos/cockpit: add nixos test Signed-off-by: lucasew <lucas59356@gmail.com>
2023-01-29 14:40:46 -03:00
cockpit = handleTest ./cockpit.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
cockroachdb = handleTestOn ["x86_64-linux"] ./cockroachdb.nix {};
Revert "code-server: drop" This reverts commit 72911a99d34a4d290671728d40016ba5254f72fe.
2023-12-19 15:40:57 +01:00
code-server = handleTest ./code-server.nix {};
nixos/coder: init module
2022-10-24 20:08:00 +00:00
coder = handleTest ./coder.nix {};
nixos/collectd: add nixos test
2021-12-22 12:00:00 +00:00
collectd = handleTest ./collectd.nix {};
nixos/commafeed: init module
2024-04-15 13:57:37 +02:00
commafeed = handleTest ./commafeed.nix {};
nixos/conduwuit: init
2024-11-23 15:35:02 +01:00
conduwuit = runTest ./matrix/conduwuit.nix;
nixos/tests/connman: init
2023-01-26 00:22:21 +01:00
connman = handleTest ./connman.nix {};
nixos/consul: register test
2019-11-24 15:08:53 +01:00
consul = handleTest ./consul.nix {};
nixosTests.consul-template: init
2023-04-25 16:54:08 +02:00
consul-template = handleTest ./consul-template.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
containers-bridge = handleTest ./containers-bridge.nix {};
nixos-containers: Add support for custom nixpkgs argument
2020-04-19 14:41:18 +01:00
containers-custom-pkgs.nix = handleTest ./containers-custom-pkgs.nix {};
nixos/containers: add 'ephemeral' option
2019-08-18 21:37:38 +02:00
containers-ephemeral = handleTest ./containers-ephemeral.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
containers-extra_veth = handleTest ./containers-extra_veth.nix {};
containers-hosts = handleTest ./containers-hosts.nix {};
containers-imperative = handleTest ./containers-imperative.nix {};
nixos/containers-ip: Test both ipv4 and ipv6 in the same script
2019-11-26 00:44:12 +01:00
containers-ip = handleTest ./containers-ip.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
containers-macvlans = handleTest ./containers-macvlans.nix {};
nixos/containers: allow containers with long names to create private networks Launching a container with a private network requires creating a dedicated networking interface for it; name of that interface is derived from the container name itself - e.g. a container named `foo` gets attached to an interface named `ve-foo`. An interface name can span up to IFNAMSIZ characters, which means that a container name must contain at most IFNAMSIZ - 3 - 1 = 11 characters; it's a limit that we validate using a build-time assertion. This limit has been upgraded with Linux 5.8, as it allows for an interface to contain a so-called altname, which can be much longer, while remaining treated as a first-class citizen. Since altnames have been supported natively by systemd for a while now, due diligence on our side ends with dropping the name-assertion on newer kernels. This commit closes #38509. systemd/systemd#14467 systemd/systemd#17220 https://lwn.net/Articles/794289/
2021-02-26 17:14:08 +01:00
containers-names = handleTest ./containers-names.nix {};
nixosTests.containers-nested: init
2021-02-24 14:02:57 +01:00
containers-nested = handleTest ./containers-nested.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
containers-physical_interfaces = handleTest ./containers-physical_interfaces.nix {};
nixosTests.containers-portforward: add to all-tests.nix
2019-12-10 20:34:37 +01:00
containers-portforward = handleTest ./containers-portforward.nix {};
nixosTests.containers-reloadable: expose test This hasn't been available before in nixosTests.
2020-08-23 11:00:09 +02:00
containers-reloadable = handleTest ./containers-reloadable.nix {};
nixos/nixos-containers: require mounts for bind mount host paths Fixes starting containers before bind mount host paths are mounted
2024-03-20 14:22:44 -04:00
containers-require-bind-mounts = handleTest ./containers-require-bind-mounts.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
containers-restart_networking = handleTest ./containers-restart_networking.nix {};
containers-tmpfs = handleTest ./containers-tmpfs.nix {};
nixos-container: force systemd-nspawn to use unified cgroups hierarchy
2022-10-29 22:22:57 +02:00
containers-unified-hierarchy = handleTest ./containers-unified-hierarchy.nix {};
nixos/convos: add test
2020-06-05 14:54:29 +02:00
convos = handleTest ./convos.nix {};
nixos/corerad: init
2020-01-07 11:52:32 -05:00
corerad = handleTest ./corerad.nix {};
nixos/tests/coturn: init Co-authored-by: MatthewCroughan <matt@croughan.sh>
2021-07-03 08:32:03 +01:00
coturn = handleTest ./coturn.nix {};
nixos/tests: Reenable couchdb Works just fine in current master
2019-07-24 20:48:43 +02:00
couchdb = handleTest ./couchdb.nix {};
nixos/crabfit: init
2024-04-02 12:16:53 +02:00
crabfit = handleTest ./crabfit.nix {};
nixosTests.cri-o: enable on aarch64-linux
2022-09-24 17:39:15 +10:00
cri-o = handleTestOn ["aarch64-linux" "x86_64-linux"] ./cri-o.nix {};
nixos/cryptpad: init This is a full rewrite independent of the previously removed cryptpad module, managing cryptpad's config in RFC0042 along with a shiny test. Upstream cryptpad provides two nginx configs, with many optimizations and complex settings; this uses the easier variant for now but improvements (e.g. serving blocks and js files directly through nginx) should be possible with a bit of work and care about http headers. the /checkup page of cryptpad passes all tests except HSTS, we don't seem to have any nginx config with HSTS enabled in nixpkgs so leave this as is for now. Co-authored-by: Pol Dellaiera <pol.dellaiera@protonmail.com> Co-authored-by: Michael Smith <shmitty@protonmail.com>
2024-07-19 21:45:19 +09:00
cryptpad = runTest ./cryptpad.nix;
cups-pdf: add vm test
2022-07-20 20:14:06 +02:00
cups-pdf = handleTest ./cups-pdf.nix {};
nixosTests.curl-impersonate: init
2023-07-21 14:37:48 -04:00
curl-impersonate = handleTest ./curl-impersonate.nix {};
nixos/tests/custom-ca: init This is a NixOS test for the security.pki options.
2021-01-10 18:28:29 +01:00
custom-ca = handleTest ./custom-ca.nix {};
nixos/croc: init
2020-07-22 10:34:57 +02:00
croc = handleTest ./croc.nix {};
nixos/cross-seed: re-enable test
2025-02-23 17:35:38 +00:00
cross-seed = runTest ./cross-seed.nix;
nixos/cyrus-imap: init module Co-authored-by: jtbx <jeremy@baxters.nz> Co-authored-by: pluiedev <hi@pluie.me>
2024-05-10 10:29:44 +08:00
cyrus-imap = runTest ./cyrus-imap.nix;
nixos/tests/darling: init
2023-05-01 17:39:19 -06:00
darling = handleTest ./darling.nix {};
nixos/tests/darling-dmg: init
2024-07-01 21:42:50 +02:00
darling-dmg = runTest ./darling-dmg.nix;
nixos/dae: add basic test
2023-09-03 02:30:30 +08:00
dae = handleTest ./dae.nix {};
nixos/davis: init
2024-03-25 15:32:01 +01:00
davis = handleTest ./davis.nix {};
nixos/db-rest: init
2023-11-14 21:58:11 +01:00
db-rest = handleTest ./db-rest.nix {};
nixos/dconf: add locks support
2023-06-14 16:27:19 +08:00
dconf = handleTest ./dconf.nix {};
ddns-updater: Add module, test, update script
2024-07-16 17:45:02 +00:00
ddns-updater = handleTest ./ddns-updater.nix {};
nixos/tests/deconz: init
2023-09-17 20:04:28 +02:00
deconz = handleTest ./deconz.nix {};
nixos/tests/deepin: init
2023-04-25 11:34:09 +08:00
deepin = handleTest ./deepin.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
deluge = handleTest ./deluge.nix {};
nixos: move matrix services into their category
2022-05-13 16:46:01 +09:00
dendrite = handleTest ./matrix/dendrite.nix {};
nixos/dependency-track: init module
2024-07-20 21:25:05 +02:00
dependency-track = handleTest ./dependency-track.nix {};
nixos/devpi-server: init Signed-off-by: Christina Sørensen <christina@cafkafk.com>
2024-04-19 13:26:38 +02:00
devpi-server = handleTest ./devpi-server.nix {};
dex-oidc: add module
2021-09-20 01:43:54 +02:00
dex-oidc = handleTest ./dex-oidc.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
dhparams = handleTest ./dhparams.nix {};
installers/tools: add test for system.disableInstallerTools option This test ensures the installer tools are actually unavailable with the option set to true.
2021-09-12 08:06:34 +02:00
disable-installer-tools = handleTest ./disable-installer-tools.nix {};
nixos/discourse: Add test
2021-03-14 15:44:34 +01:00
discourse = handleTest ./discourse.nix {};
nixosTests.dnscrypt-proxy2: init This removes the old dnscrypt-proxy test.
2020-02-01 18:59:02 -05:00
dnscrypt-proxy2 = handleTestOn ["x86_64-linux"] ./dnscrypt-proxy2.nix {};
nixos/tests/dnsdist: test dnscrypt support
2023-11-27 22:00:42 +01:00
dnsdist = import ./dnsdist.nix { inherit pkgs runTest; };
nixos/doas: init `doas` is a lighter alternative to `sudo` that "provide[s] 95% of the features of `sudo` with a fraction of the codebase" [1]. I prefer it to `sudo`, so I figured I would add a NixOS module in order for it to be easier to use. The module is based off of the existing `sudo` module. [1] https://github.com/Duncaen/OpenDoas
2020-04-13 20:13:36 -07:00
doas = handleTest ./doas.nix {};
nixosTests.{docker,docker-rootless}: enable on aarch64-linux
2022-09-24 17:40:42 +10:00
docker = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker.nix {};
docker-rootless = handleTestOn ["aarch64-linux" "x86_64-linux"] ./docker-rootless.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
docker-registry = handleTest ./docker-registry.nix {};
docker-tools = handleTestOn ["x86_64-linux"] ./docker-tools.nix {};
nixosTests.docker-tools-nix-shell: Enable on aarch64-linux The docker-tools test, where this originates, was not run on aarch64-linux, but this is an artifact of its age more so than anything else. Co-authored-by: Ivan Trubach <mr.trubach@icloud.com>
2024-07-28 22:52:11 +02:00
docker-tools-nix-shell = runTest ./docker-tools-nix-shell.nix;
nixosTests.docker-tools-cross: init Not everyone has a suitable remote builder set up, so the cross-compilation tests that _include_ running the result are separate. That way, most people can run the majority of the test suite without the extra setup.
2020-12-13 00:33:46 +01:00
docker-tools-cross = handleTestOn ["x86_64-linux" "aarch64-linux"] ./docker-tools-cross.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
docker-tools-overlay = handleTestOn ["x86_64-linux"] ./docker-tools-overlay.nix {};
documize-community: init at 2.2.1 Documize is an open-source alternative for wiki software like Confluence based on Go and EmberJS. This patch adds the sources for the community edition[1], for commercial their paid-plan[2] needs to be used. For commercial use a derivation that bundles the commercial package and contains a `$out/bin/documize` can be passed to `services.documize.enable`. The package compiles the Go sources, the build process also bundles the pre-built frontend from `gui/public` into the binary. The NixOS module generates a simple `systemd` unit which starts the service as a dynamic user, database and a reverse proxy won't be configured. [1] https://www.documize.com/get-started/ [2] https://www.documize.com/pricing/
2019-03-26 19:04:28 +01:00
documize = handleTest ./documize.nix {};
nixos/documentation: Add unit test
2022-07-14 11:57:37 +02:00
documentation = pkgs.callPackage ../modules/misc/documentation/test.nix { inherit nixosLib; };
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
doh-proxy-rust = handleTest ./doh-proxy-rust.nix {};
nixos/dokuwiki: init module at 2018-04-22b
2019-12-25 23:04:55 +01:00
dokuwiki = handleTest ./dokuwiki.nix {};
nixos/tests/dolibarr: add to all-tests
2022-11-01 21:02:39 +08:00
dolibarr = handleTest ./dolibarr.nix {};
nixosTests.domination: init
2021-11-13 23:00:20 +01:00
domination = handleTest ./domination.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
dovecot = handleTest ./dovecot.nix {};
drawterm: add nixos tests
2023-12-23 15:53:20 -06:00
drawterm = discoverTests (import ./drawterm.nix);
nixos/tests/drbd: init
2021-11-30 21:42:29 +01:00
drbd = handleTest ./drbd.nix {};
druid: add passthru test
2024-03-14 00:12:18 +05:30
druid = handleTestOn [ "x86_64-linux" ] ./druid {};
linuxPackages.drbd: 9.2.8 -> 9.2.9 - 6.8 kernel support added - aligned to Nix standard build environment - test added - redundant installPhase and postFixup definitions removed Signed-off-by: birkb <birk@batchworks.de> Signed-off-by: Julian Stecklina <julian.stecklina@cyberus-technology.de>
2024-05-15 20:12:46 +02:00
drbd-driver = handleTest ./drbd-driver.nix {};
nixos/dublin-traceroute: init
2023-11-27 09:45:10 -08:00
dublin-traceroute = handleTest ./dublin-traceroute.nix {};
nixos/earlyoom: bring the module up to date (#163663) * nixos/earlyoom: bring the module up to date Removes deprecated option `ignoreOOMScoreAdjust`, introduces `killHook` as a replacement for `notificationsCommand`, and adds an `extraArgs` option for things not covered by the module. * nixos/earlyoom: add nixos test * nixos/earlyoom: add reportInterval Allows setting the interval for logging a memory report. Defaults to 3600 following upstream (https://github.com/rfjakob/earlyoom/blob/master/earlyoom.default#L5) to avoid flooding logs. * nixos/earlyoom: add free{Mem,Swap}KillThreshold Fixes https://github.com/NixOS/nixpkgs/issues/83504
2022-03-24 08:34:09 +01:00
earlyoom = handleTestOn ["x86_64-linux"] ./earlyoom.nix {};
nixosTests.early-mount-options: init
2023-04-25 13:07:08 +02:00
early-mount-options = handleTest ./early-mount-options.nix {};
nixosTests.ec2-config: Add to all-tests.nix
2020-02-13 21:31:58 +01:00
ec2-config = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-config or {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
ec2-nixops = (handleTestOn ["x86_64-linux"] ./ec2.nix {}).boot-ec2-nixops or {};
nixos/tests/echoip: init
2025-01-11 16:57:57 +01:00
echoip = handleTest ./echoip.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
ecryptfs = handleTest ./ecryptfs.nix {};
nixos/pam: support fscrypt login protectors fscrypt can automatically unlock directories with the user's login password. To do this it ships a PAM module which reads the user's password and loads the respective keys into the user's kernel keyring. Significant inspiration was taken from the ecryptfs implementation.
2022-05-17 20:16:22 +02:00
fscrypt = handleTest ./fscrypt.nix {};
nixos/tests/fastnetmon-advanced: init
2023-10-18 04:13:16 +02:00
fastnetmon-advanced = runTest ./fastnetmon-advanced.nix;
nixos/tests/eintopf: init
2024-07-03 11:24:22 +02:00
eintopf = handleTest ./eintopf.nix {};
nixos/tests: move ejabberd and prosody test to xmpp folder
2019-06-15 12:16:28 +03:00
ejabberd = handleTest ./xmpp/ejabberd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
elk = handleTestOn ["x86_64-linux"] ./elk.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
emacs-daemon = handleTest ./emacs-daemon.nix {};
nixos/endlessh: init module
2022-10-22 15:53:35 +03:00
endlessh = handleTest ./endlessh.nix {};
nixos/endlessh-go: init module
2022-09-23 23:39:38 +03:00
endlessh-go = handleTest ./endlessh-go.nix {};
nixos/engelsystem: Add test
2020-05-24 14:20:58 +02:00
engelsystem = handleTest ./engelsystem.nix {};
nixos/tests: add enlightenment desktop environment
2020-05-02 11:28:50 -03:00
enlightenment = handleTest ./enlightenment.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
env = handleTest ./env.nix {};
envfs: init at 1.0.0
2022-12-28 15:09:54 +01:00
envfs = handleTest ./envfs.nix {};
nixos/envoy: init
2021-08-27 19:28:27 -07:00
envoy = handleTest ./envoy.nix {};
tests/ergo: init
2020-05-24 20:39:23 +02:00
ergo = handleTest ./ergo.nix {};
nixos/tests/ergochat: init
2022-01-12 21:47:27 +01:00
ergochat = handleTest ./ergochat.nix {};
nixos/eris-server: init
2023-07-29 11:20:37 +01:00
eris-server = handleTest ./eris-server.nix {};
nixos/esphome: init module
2023-03-22 22:48:59 +01:00
esphome = handleTest ./esphome.nix {};
nixos/etc.nix: Make independent (cherry picked from commit 56c283e5c8dfd4d8d5daa15dfa3896beef2ac012)
2021-12-03 12:21:16 +00:00
etc = pkgs.callPackage ../modules/system/etc/test.nix { inherit evalMinimalConfig; };
nixos/top-level.nix: add forbiddenDependenciesRegex option useful for making sure that there's no dev outputs in the system
2022-12-01 18:49:48 +02:00
activation = pkgs.callPackage ../modules/system/activation/test.nix { };
nixos/activation-script: Add lib.sh with warn()
2024-07-16 20:25:06 +02:00
activation-lib = pkgs.callPackage ../modules/system/activation/lib/test.nix { };
nixos/activation: replace var activationScript via tmpfiles
2023-10-17 17:35:16 +02:00
activation-var = runTest ./activation/var.nix;
nixos/nix-channel: replace activationScript via tmpfiles
2023-10-17 21:39:51 +02:00
activation-nix-channel = runTest ./activation/nix-channel.nix;
nixos/etc: optionally mount etc as an overlay
2023-10-13 00:02:48 +02:00
activation-etc-overlay-mutable = runTest ./activation/etc-overlay-mutable.nix;
activation-etc-overlay-immutable = runTest ./activation/etc-overlay-immutable.nix;
nixos/profiles/perlless: init
2023-10-17 16:40:26 +02:00
activation-perlless = runTest ./activation/perlless.nix;
nixos/tests/etcd: enable aarch64-linux * move etcd tests to it's own directory
2024-02-14 11:45:02 -03:00
etcd = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./etcd/etcd.nix {};
etcd-cluster = handleTestOn [ "aarch64-linux" "x86_64-linux" ] ./etcd/etcd-cluster.nix {};
nixos/tests/etebase-server: init
2021-03-28 23:49:45 +02:00
etebase-server = handleTest ./etebase-server.nix {};
etesync-dav: 0.20.0 -> 0.30.6
2020-11-30 22:10:07 +01:00
etesync-dav = handleTest ./etesync-dav.nix {};
nixos/test/evcc: migrate to runTest
2025-02-22 02:27:12 +01:00
evcc = runTest ./evcc.nix;
nixos/fail2ban: use attrsets for settings instead of strings
2022-11-19 13:13:56 +01:00
fail2ban = handleTest ./fail2ban.nix { };
nixos/tests/fakeroute: init
2023-06-18 02:59:06 +02:00
fakeroute = handleTest ./fakeroute.nix {};
Fancontrol: add test etc from #70933 (#72065) * lm_sensors: add fancontrol module + nixos test fancontrol is a small script that checks temperature sensors and adapts fan speeds accordingly. It reads a text config file that can be auto-generated by running the pwmconfig wizard on the live system.
2019-10-29 15:06:32 +01:00
fancontrol = handleTest ./fancontrol.nix {};
nixos/fanout: add test
2023-07-25 12:45:54 -05:00
fanout = handleTest ./fanout.nix {};
nixos/fcitx5: init tests
2023-03-12 14:19:03 +08:00
fcitx5 = handleTest ./fcitx5 {};
nixos/fedimintd: init services
2024-06-26 22:17:12 -07:00
fedimintd = runTest ./fedimintd.nix;
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
fenics = handleTest ./fenics.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
ferm = handleTest ./ferm.nix {};
tests/ferretdb: init
2023-10-15 10:40:11 +02:00
ferretdb = handleTest ./ferretdb.nix {};
nixos/fider: init Co-authored-by: Niklas Korz <niklas@niklaskorz.de>
2024-11-03 15:54:52 +01:00
fider = runTest ./fider.nix;
nixos/filesender: init module
2024-05-21 19:27:45 +03:00
filesender = handleTest ./filesender.nix {};
nixos/filesystems: init overlayfs
2024-02-03 22:40:40 +01:00
filesystems-overlayfs = runTest ./filesystems-overlayfs.nix;
firefly-iii: init at 6.1.13
2024-04-06 21:07:34 +05:30
firefly-iii = handleTest ./firefly-iii.nix {};
nixosTests.firefly-iii-data-importer: init
2024-08-02 21:34:22 +05:30
firefly-iii-data-importer = handleTest ./firefly-iii-data-importer.nix {};
firefox-esr-91: init at 91.0esr
2021-08-09 11:57:57 +02:00
firefox = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox; };
firefox-beta-unwrapped: init at 112.0b6
2023-03-24 14:18:26 +01:00
firefox-beta = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-beta; };
firefox-devedition-unwrapped: init at 112.0b6
2023-03-24 14:16:22 +01:00
firefox-devedition = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-devedition; };
nixos/tests: unbreak the tested job I expect it suffices that the channel only blocks on one firefox ESR test - the one for the default ESR. I didn't want to have the information about the default in two places, so either of the tests will be evaluated twice (but to the same *.drv I hope).
2021-08-10 16:15:57 +02:00
firefox-esr = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr; }; # used in `tested` job
firefox-esr-128-unwrapped: init at 128.0esr
2024-07-08 19:39:05 +02:00
firefox-esr-128 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-128; };
firefoxpwa: init at 2.11.1 firefoxpwa: move to pkgs/by-name
2023-01-08 01:08:00 +01:00
firefoxpwa = handleTest ./firefoxpwa.nix {};
nixos/tests: add test for firejail
2020-08-07 18:45:20 +02:00
firejail = handleTest ./firejail.nix {};
nixos/{firewall, nat}: add a nftables based implementation
2022-12-23 00:23:23 +08:00
firewall = handleTest ./firewall.nix { nftables = false; };
firewall-nftables = handleTest ./firewall.nix { nftables = true; };
nixos/fish: generate autocompletions from man pages
2018-12-17 20:12:09 +01:00
fish = handleTest ./fish.nix {};
nixos/flannel: fix flannel nixos test, add test to all-tests.nix
2019-02-12 18:26:08 +01:00
flannel = handleTestOn ["x86_64-linux"] ./flannel.nix {};
nixos/flaresolverr: initial commit
2024-07-05 23:06:17 +03:00
flaresolverr = handleTest ./flaresolverr.nix {};
nixos/flood: init
2024-06-05 15:14:56 -03:00
flood = handleTest ./flood.nix {};
floorp: init at 11.5.0 Signed-off-by: Christoph Heiss <christoph@c8h4.io>
2023-10-23 10:22:11 +02:00
floorp = handleTest ./firefox.nix { firefoxPackage = pkgs.floorp; };
fluentd: add simple test
2019-07-30 00:35:27 +09:00
fluentd = handleTest ./fluentd.nix {};
nixos/fluidd: init fluidd service at 1.16.2
2021-08-21 22:51:01 +02:00
fluidd = handleTest ./fluidd.nix {};
nixos.tests.fontconfig-default-fonts: init Make sure the fonts.enableDefaultFonts option works.
2019-08-29 14:02:20 +02:00
fontconfig-default-fonts = handleTest ./fontconfig-default-fonts.nix {};
nixos/tests/forgejo: add forgejo-lts variant
2024-07-31 03:59:13 +02:00
forgejo = handleTest ./forgejo.nix { forgejoPackage = pkgs.forgejo; };
forgejo-lts = handleTest ./forgejo.nix { forgejoPackage = pkgs.forgejo-lts; };
nixosTests.freenet: init
2022-11-29 18:30:00 +01:00
freenet = handleTest ./freenet.nix {};
nixos/freeswitch: init
2020-01-07 16:53:34 +02:00
freeswitch = handleTest ./freeswitch.nix {};
freetube: add test This change fixes ofborg eval error
2023-10-30 06:49:08 +11:00
freetube = discoverTests (import ./freetube.nix);
nixos/freshrss: organize tests
2025-01-09 23:18:07 +01:00
freshrss = handleTest ./freshrss {};
nixos/tests/frigate: init Starts a frigate instance with a dummy video stream provided by ffmpeg. Co-Authored-By: fleaz <mail@felixbreidenstein.de>
2023-03-30 13:06:31 +02:00
frigate = handleTest ./frigate.nix {};
nixos/frp: add test and link to package
2023-09-13 21:24:47 +08:00
frp = handleTest ./frp.nix {};
nixos/tests/frr: init Co-Authored-By: Martin Weinelt <hexa@darmstadt.ccc.de>
2021-06-08 21:37:03 +02:00
frr = handleTest ./frr.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
fsck = handleTest ./fsck.nix {};
systemd-stage-1: fsck
2022-12-20 23:05:02 -05:00
fsck-systemd-stage-1 = handleTest ./fsck.nix { systemdStage1 = true; };
ft2-clone: add nixos test
2020-07-29 19:40:38 +02:00
ft2-clone = handleTest ./ft2-clone.nix {};
nixos/tests/legit: init
2023-05-24 09:48:02 -03:00
legit = handleTest ./legit.nix {};
mimir: switch pname to mimir
2022-06-07 06:53:15 -04:00
mimir = handleTest ./mimir.nix {};
nixos/gancio: init module
2024-05-03 10:35:19 +02:00
gancio = handleTest ./gancio.nix {};
nixos/garage: provide multiple versions to provide an upgrade path when using NixOS service - Add mention to release notes 23.05 - Introduce Garage v0.8 - Protect against unexpected upgrade with stateVersion - Test matrix over 0.7 × 0.8
2022-10-15 22:40:34 +02:00
garage = handleTest ./garage {};
nixos/gatus: init module
2024-09-19 21:34:10 +02:00
gatus = runTest ./gatus.nix;
nixos/gemstash: init module
2022-08-11 20:10:58 +10:00
gemstash = handleTest ./gemstash.nix {};
geoserver: add nixos test
2023-11-17 23:29:45 +01:00
geoserver = runTest ./geoserver.nix;
nixos: add gerrit module Co-authored-by: edef <edef@edef.eu> Co-authored-by: Florian Klink <flokli@flokli.de>
2020-03-05 22:11:28 +01:00
gerrit = handleTest ./gerrit.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
geth = handleTest ./geth.nix {};
nixos/ghostunnel: init
2021-05-20 01:15:28 +02:00
ghostunnel = handleTest ./ghostunnel.nix {};
nixos/git-daemon: only create git user if it will be used
2020-02-26 14:05:00 +01:00
gitdaemon = handleTest ./gitdaemon.nix {};
nixos/tests/gitea: make gitea package configurable This allows the same tests to be used for forgejo, a soft-fork of gitea, which currently does not have any tests.
2023-02-24 02:59:30 +01:00
gitea = handleTest ./gitea.nix { giteaPackage = pkgs.gitea; };
nixos/tests/github-runner: init
2023-02-26 13:50:49 +01:00
github-runner = handleTest ./github-runner.nix {};
nixosTests.gitlab: Use module system based runner
2023-05-11 07:07:37 +00:00
gitlab = runTest ./gitlab.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
gitolite = handleTest ./gitolite.nix {};
gitolite: wrap gitolite-shell git wasn't found when used with services.fcgiwrap for http auth
2019-12-04 18:10:57 -05:00
gitolite-fcgiwrap = handleTest ./gitolite-fcgiwrap.nix {};
nixos/glance: init module
2024-07-01 09:32:41 +02:00
glance = runTest ./glance.nix;
nixos/glances: init module
2024-04-01 22:44:08 +02:00
glances = runTest ./glances.nix;
nixos/glusterfs: add test
2019-08-17 01:28:43 +02:00
glusterfs = handleTest ./glusterfs.nix {};
gnome: rename from gnome3 Since GNOME version is now 40, it no longer makes sense to use the old attribute name.
2021-05-07 23:18:14 +02:00
gnome = handleTest ./gnome.nix {};
nixosTests.gnome-extensions: Init
2023-10-15 15:57:54 +02:00
gnome-extensions = handleTest ./gnome-extensions.nix {};
gnome.gnome-flashback: add VM test
2022-12-28 22:45:22 +01:00
gnome-flashback = handleTest ./gnome-flashback.nix {};
gnome: rename from gnome3 Since GNOME version is now 40, it no longer makes sense to use the old attribute name.
2021-05-07 23:18:14 +02:00
gnome-xorg = handleTest ./gnome-xorg.nix {};
nixosTests.gns3-server: init
2023-10-22 23:04:25 +02:00
gns3-server = handleTest ./gns3-server.nix {};
nixos/tests/gnupg: init
2023-02-02 18:17:40 +01:00
gnupg = handleTest ./gnupg.nix {};
nixos/goatcounter: init
2024-07-15 00:44:11 +05:30
goatcounter = handleTest ./goatcounter.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
go-neb = handleTest ./go-neb.nix {};
nixos/tests/gobgpd: init
2021-04-09 14:57:33 +00:00
gobgpd = handleTest ./gobgpd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
gocd-agent = handleTest ./gocd-agent.nix {};
gocd-server = handleTest ./gocd-server.nix {};
nixos/gollum: add test
2022-09-10 18:01:37 +02:00
gollum = handleTest ./gollum.nix {};
nixos/gonic: init
2022-12-21 01:08:48 +01:00
gonic = handleTest ./gonic.nix {};
nixosTests.graphene: init
2019-05-16 21:29:17 -04:00
google-oslogin = handleTest ./google-oslogin {};
gopro-tool: init at 0-unstable-2024-04-18
2025-02-14 11:45:47 -07:00
gopro-tool = handleTest ./gopro-tool.nix {};
nixosTests.goss: init
2023-10-25 13:54:47 +02:00
goss = handleTest ./goss.nix {};
nixos/gotenberg: init
2024-07-11 03:07:40 -04:00
gotenberg = handleTest ./gotenberg.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
gotify-server = handleTest ./gotify-server.nix {};
nixos/gotosocial: init Co-authored-by: Peder Bergebakken Sundt <pbsds@hotmail.com>
2023-05-19 21:18:17 +03:00
gotosocial = runTest ./web-apps/gotosocial.nix;
nixos/grafana: refactor dashboards for RFC42 This commit refactors `services.grafana.provision.dashboards` towards the RFC42 style. To preserve backwards compatibility, we have to jump through a ton of hoops, introducing esoteric type signatures and bizarre structs. The Grafana module definition should hopefully become a lot cleaner after a release cycle or two once the old configuration style is completely deprecated.
2022-09-18 13:35:07 +04:00
grafana = handleTest ./grafana {};
nixos: add grafana-agent module Easily ship logs and metrics to Grafana Cloud and other similar targets.
2022-06-15 12:11:03 +02:00
grafana-agent = handleTest ./grafana-agent.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
graphite = handleTest ./graphite.nix {};
nixos/grav: init module
2024-11-10 09:53:20 +01:00
grav = runTest ./web-apps/grav.nix;
nixos/graylog: add test Basic test which confirms new inputs can be created and that messages can be sent to a UDP-GELF input using `netcat`. This test requires 4GB of RAM to avoid issues due insufficient memory (please refer to `nixos/tests/elk.nix` for a detailed explanation of the issue) for elasticsearch. Also it's ensured that elasticsearch has an open HTTP port for communication when starting `graylog`. This is a workaround to ensure that all services are started in proper order, even in test environments with less power. However this shouldn't be implemented in the `nixos/graylog` module as this might be harmful when using elasticsearch clusters that require e.g. authentication and/or run on different servers.
2019-07-09 02:01:43 +02:00
graylog = handleTest ./graylog.nix {};
nixos/shadow: introduce security.shadow.enable Allow users to disable the shadow authentication suite. My primary motivation is to reduce the attack surface via setuid binaries, which shadow understandably introduces many. I realised, however, that I don't use any of these. The test demonstrates login working without needing the shadow suite.
2024-05-16 22:09:13 +10:00
greetd-no-shadow = handleTest ./greetd-no-shadow.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
grocy = handleTest ./grocy.nix {};
nixos/grow-partition: add nixos test
2023-10-16 16:58:19 +00:00
grow-partition = runTest ./grow-partition.nix;
nixos/tests: add test for grub authentication
2020-06-13 12:06:26 +02:00
grub = handleTest ./grub.nix {};
nixos/guacamole-server: init
2023-06-16 19:12:42 +02:00
guacamole-server = handleTest ./guacamole-server.nix {};
nixos/guix: init
2023-10-29 14:44:03 +08:00
guix = handleTest ./guix {};
nixosTests.gvisor: add test for gvisor and gvisor as a Docker runtime
2019-11-26 23:01:46 -08:00
gvisor = handleTest ./gvisor.nix {};
nixos/h2o: init module Co-Authored-By: adisbladis <adis@blad.is>
2025-02-12 12:42:02 +07:00
h2o = discoverTests (import ./web-servers/h2o { inherit handleTestOn; });
hadoop: add passthrough tests
2022-01-08 18:38:34 +05:30
hadoop = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop; };
hadoop: init 3.4, drop 3.2
2024-06-24 09:25:57 +05:30
hadoop_3_3 = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop_3_3; };
hadoop: add passthrough tests
2022-01-08 18:38:34 +05:30
hadoop2 = import ./hadoop { inherit handleTestOn; package=pkgs.hadoop2; };
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
haka = handleTest ./haka.nix {};
nixosTests.haste-server: init
2022-03-02 18:00:16 +01:00
haste-server = handleTest ./haste-server.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
haproxy = handleTest ./haproxy.nix {};
nixos/tests: re-enable hardened test Has been okay since 62623b60d5fed91ac676d6f4a70a12570090d513
2019-01-06 14:04:41 +01:00
hardened = handleTest ./hardened.nix {};
nixos/harmonia: adjust module and test to upstream
2023-05-10 19:41:25 +03:00
harmonia = runTest ./harmonia.nix;
headscale: Update to 0.17.1, conform module to RFC0042 This commit upgrades headscale to the newest version, 0.17.0 and updates the module with the current breaking config changes. In addition, the module is rewritten to conform with RFC0042 to try to prevent some drift between the module and the upstream. A new maintainer, Misterio77, is added as maintainer. Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com> Co-authored-by: Gabriel Fontes <hi@m7.rs> Co-authored-by: Geoffrey Huntley <ghuntley@ghuntley.com>
2022-12-01 16:47:24 +01:00
headscale = handleTest ./headscale.nix {};
healthchecks: init at 2.2.1
2022-06-10 14:31:00 +02:00
healthchecks = handleTest ./web-apps/healthchecks.nix {};
hbase: 0.98.24 -> 2.4.11
2022-03-29 01:49:17 +05:30
hbase2 = handleTest ./hbase.nix { package=pkgs.hbase2; };
hbase: version upgrades - 2.4.17 -> 2.4.18 - 2.5.4 -> 2.5.9 - init 2.6.0 - 3.0.0-alpha-3 -> 3.0.0-beta-1
2024-06-24 18:59:06 +05:30
hbase_2_5 = handleTest ./hbase.nix { package=pkgs.hbase_2_5; };
hbase: update versions and remove EoL version - remove 1.7 - 2.4.11 -> 2.4.15 - init 2.5.1 - 3.0.0-alpha-2 -> 3.0.0-alpha-3
2022-09-30 22:13:14 +05:30
hbase_2_4 = handleTest ./hbase.nix { package=pkgs.hbase_2_4; };
hbase: 0.98.24 -> 2.4.11
2022-03-29 01:49:17 +05:30
hbase3 = handleTest ./hbase.nix { package=pkgs.hbase3; };
nixos/hddfancontrol: initial module & test
2023-06-25 12:35:47 -04:00
hddfancontrol = handleTest ./hddfancontrol.nix {};
nixos/codimd: rename to hedgedoc CodiMD was renamed to HedgeDoc. The user, group and state directory, will be named hedgedoc instead of codimd, starting with stateVersion "21.03".
2020-11-29 18:51:50 +01:00
hedgedoc = handleTest ./hedgedoc.nix {};
herbstluftwm: add NixOS test
2020-11-27 19:20:36 +00:00
herbstluftwm = handleTest ./herbstluftwm.nix {};
nixosTest.homebox: init
2024-06-15 15:25:40 +02:00
homebox = handleTest ./homebox.nix {};
nixos/homer: add tests
2024-12-27 18:36:59 +01:00
homer = handleTest ./homer {};
tests/homepage-dashboard: add tests for homepage
2023-07-12 16:46:28 +01:00
homepage-dashboard = handleTest ./homepage-dashboard.nix {};
nixos/modules/honk: init
2023-08-17 18:08:48 +02:00
honk = runTest ./honk.nix;
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
installed-tests = pkgs.recurseIntoAttrs (handleTest ./installed-tests {});
nixos/invidious: add test
2021-09-07 19:44:12 +02:00
invidious = handleTest ./invidious.nix {};
nixos/isolate: add tests
2024-04-22 05:58:48 +08:00
isolate = handleTest ./isolate.nix {};
livebook: add systemd user service, test, and docs Co-authored-by: Yt <happysalada@tuta.io>
2023-10-24 17:53:12 +01:00
livebook-service = handleTest ./livebook-service.nix {};
nixos/pyload: init test
2023-12-24 22:23:15 +01:00
pyload = handleTest ./pyload.nix {};
nixosTests.oci-containers: enable on aarch64-linux
2022-09-24 15:58:01 +10:00
oci-containers = handleTestOn ["aarch64-linux" "x86_64-linux"] ./oci-containers.nix {};
nixosTests.odoo: init
2021-11-02 01:48:47 +01:00
odoo = handleTest ./odoo.nix {};
odoo17: init Signed-off-by: phanirithvij <phanirithvij2000@gmail.com>
2024-10-11 01:13:06 +05:30
odoo17 = handleTest ./odoo.nix { package = pkgs.odoo17; };
odoo: 16.0.20231024 -> 17.0.20240507 Preserve 'odoo16' on the same pattern as existing 'odoo15' Signed-off-by: Sirio Balmelli <sirio@b-ad.ch>
2024-06-19 13:35:20 +00:00
odoo16 = handleTest ./odoo.nix { package = pkgs.odoo16; };
odoo15: init at 15.0-20230720 This contribution adds `odoo15` as a fixed version. To allow reusing the existing test for Odoo, I made the package attribute configurable. To reference the test for `odoo15` in `passthru` I added it to `all-tests.nix`.
2023-08-24 22:04:40 +02:00
odoo15 = handleTest ./odoo.nix { package = pkgs.odoo15; };
nixos/tests/hibernate: disable for platforms other than x86_64 Due to 9pnet_virtio bugs, /nix is no longer available after hibernation. It happens to work on x86_64, but not on other platforms.
2020-03-26 14:33:57 +01: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 {};
nixos/stage-1-systemd: Implement hibernation + test
2022-04-13 12:48:20 +01:00
hibernate-systemd-stage-1 = handleTestOn ["x86_64-linux"] ./hibernate.nix { systemdStage1 = true; };
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
hitch = handleTest ./hitch {};
nixos/hledger-web: init module and test
2020-01-20 12:34:57 +01:00
hledger-web = handleTest ./hledger-web.nix {};
nixos/tests: Init hockeypuck tests
2021-07-18 09:51:49 +02:00
hockeypuck = handleTest ./hockeypuck.nix { };
nixos/tests/home-assistant: call with runTest
2024-09-02 01:54:06 +02:00
home-assistant = runTest ./home-assistant.nix;
nixos/tests/hostname: init (check system's host name) NixOS currently has issues with setting the FQDN of a system in a way where standard tools work. In order to help with experimentation and avoid regressions, add a test that checks that the hostname is reported as the user wanted it to be. Co-authored-by: Michael Weiss <dev.primeos@gmail.com>
2020-05-12 23:48:27 +02:00
hostname = handleTest ./hostname.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
hound = handleTest ./hound.nix {};
hub: Add test
2020-12-29 11:13:26 -05:00
hub = handleTest ./git/hub.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
hydra = handleTest ./hydra {};
i3wm = handleTest ./i3wm.nix {};
nixos/icingaweb: Fix module path; Add test
2019-07-07 03:03:59 +02:00
icingaweb2 = handleTest ./icingaweb2.nix {};
Init IFM service at version 4.0.2 Signed-off-by: Litchi Pi <litchi.pi@proton.me>
2024-07-18 17:17:36 +02:00
ifm = handleTest ./ifm.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
iftop = handleTest ./iftop.nix {};
nixos/tests/immich: init tests
2024-07-02 20:18:19 +01:00
immich = handleTest ./web-apps/immich.nix {};
nixos/immich-public-proxy: init module
2024-11-29 11:26:07 -08:00
immich-public-proxy = handleTest ./web-apps/immich-public-proxy.nix {};
nixos/tests/all-tests.nix: Fix incron test path
2018-11-14 23:51:15 +01:00
incron = handleTest ./incron.nix {};
nixos/tests/incus: fix multi-system support
2024-12-22 19:33:23 -05:00
incus = pkgs.recurseIntoAttrs (handleTest ./incus { lts = false; inherit system pkgs; });
incus-lts = pkgs.recurseIntoAttrs (handleTest ./incus { inherit system pkgs; });
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
influxdb = handleTest ./influxdb.nix {};
nixos/influxdb2: add initial setup automation and nixos tests
2023-08-15 00:26:41 +02:00
influxdb2 = handleTest ./influxdb2.nix {};
openvpn: fix tests and add to passthru.tests
2023-12-20 18:23:08 +09:00
initrd-network-openvpn = handleTestOn [ "x86_64-linux" "i686-linux" ] ./initrd-network-openvpn {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
initrd-network-ssh = handleTest ./initrd-network-ssh {};
nixos/luksroot: add tryEmptyPassphrase option
2023-03-22 09:17:23 -05:00
initrd-luks-empty-passphrase = handleTest ./initrd-luks-empty-passphrase.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
initrdNetwork = handleTest ./initrd-network.nix {};
nixos/tests: Add test for initrd secrets lz4 compression is excluded because it doesn't work for a reason which remains unclear to me.
2020-12-12 14:39:58 +01:00
initrd-secrets = handleTest ./initrd-secrets.nix {};
nixos/grub: Name initrd-secrets by system, not by initrd Previously, secrets were named according to the initrd they were associated with. This created a problem: If secrets were changed whilst the initrd remained the same, there were two versions of the secrets with one initrd. The result was that only one version of the secrets would by recorded into the /boot partition and get used. AFAICT this would only be the oldest version of the secrets for the given initrd version. This manifests as #114594, which I found frustrating while trying to use initrd secrets for the first time. While developing the secrets I found I could not get new versions of the secrets to take effect. Additionally, it's a nasty issue to run into if you had cause to change the initrd secrets for credential rotation, etc, if you change them and discover you cannot, or alternatively that you can't roll back as you would expect. Additional changes in this patch. * Add a regression test that switching to another grub configuration with the alternate secrets works. This test relies on the fact that it is not changing the initrd. I have checked that the test fails if I undo my change. * Persist the useBootLoader disk state, similarly to other boot state. * I had to do this, otherwise I could not find a route to testing the alternate boot configuration. I did attempt a few different ways of testing this, including directly running install-grub.pl, but what I've settled on is most like what a user would do and avoids depending on lots of internal details. * Making tests that test the boot are a bit tricky (see hibernate.nix and installer.nix for inspiration), I found that in addition to having to copy quite a bit of code I still couldn't get things to work as desired since the bootloader state was being clobbered. My change to persist the useBootLoader state could break things, conceptually. I need some help here discovering if that is the case, possibly by letting this run through a staging CI if there is one. Fix #114594. cc potential reviewers: @lopsided98 (original implementer) @joachifm (original reviewer), @wkennington (numerous fixes to grub-install.pl), @lheckemann (wrote original secrets test).
2023-01-05 12:28:32 +00:00
initrd-secrets-changing = handleTest ./initrd-secrets-changing.nix {};
nixos/input-remapper: add nixos test for input-remapper
2022-02-18 13:47:54 -08:00
input-remapper = handleTest ./input-remapper.nix {};
nixos/modules/inspircd: add simplistic module and nixos test
2021-03-22 14:32:46 +01:00
inspircd = handleTest ./inspircd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
installer = handleTest ./installer.nix {};
nixos: Installer tests for systemd stage 1
2022-04-17 17:24:13 -04:00
installer-systemd-stage-1 = handleTest ./installer-systemd-stage-1.nix {};
nixos/intune: init
2023-03-17 21:39:03 +13:00
intune = handleTest ./intune.nix {};
nixos/invoiceplane: init module and package at 1.5.11 (#146909)
2022-01-20 14:45:35 +01:00
invoiceplane = handleTest ./invoiceplane.nix {};
nixos/iodine: add test
2020-02-02 12:00:00 +00:00
iodine = handleTest ./iodine.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
ipv6 = handleTest ./ipv6.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
iscsi-multipath-root = handleTest ./iscsi-multipath-root.nix {};
nixosTests.iscsi-root: init Co-authored-by: Graham Christensen <graham@floxdev.com>
2020-10-18 19:55:42 +02:00
iscsi-root = handleTest ./iscsi-root.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
isso = handleTest ./isso.nix {};
nixos/jackett: Add test for jackett to ensure startup
2019-01-25 07:09:36 +01:00
jackett = handleTest ./jackett.nix {};
nixos/jellyfin: add test to all-tests.nix
2019-05-01 11:57:34 +02:00
jellyfin = handleTest ./jellyfin.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
jenkins = handleTest ./jenkins.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
jenkins-cli = handleTest ./jenkins-cli.nix {};
nixos/jibri: add nixos test
2021-10-15 11:00:24 -07:00
jibri = handleTest ./jibri.nix {};
nixos/jirefeau: add `services.jirafeau` module Signed-off-by: David Wood <david.wood@codeplay.com>
2020-02-06 16:00:19 +00:00
jirafeau = handleTest ./jirafeau.nix {};
nixos/jitsi-meet: init
2020-03-18 04:23:15 +01:00
jitsi-meet = handleTest ./jitsi-meet.nix {};
nixos/tests/jool: update for module changes
2023-07-01 18:50:08 +02:00
jool = import ./jool.nix { inherit pkgs runTest; };
nixos/jotta-cli: init jotta-cli See https://github.com/NixOS/nixpkgs/issues/300063.
2024-04-06 10:02:46 +02:00
jotta-cli = handleTest ./jotta-cli.nix {};
nixos/tests/k3s: reorganize test into a subdirectory In preperation for more tests, coming soon.
2022-07-21 23:13:20 -07:00
k3s = handleTest ./k3s {};
kafka: Add test for 2.2 Also add back tests, don't seem broken anymore. This is just fine: nix-build ./nixos/release.nix -A tests.kafka.kafka_2_1.x86_64-linux -A tests.kafka.kafka_2_2.x86_64-linux
2019-04-01 08:39:25 -04:00
kafka = handleTest ./kafka.nix {};
kanboard: init at 1.2.42 (#357229)
2024-12-09 09:17:10 +08:00
kanboard = handleTest ./web-apps/kanboard.nix {};
nixos/kanidm: init Co-Authored-By: Martin Weinelt <mweinelt@users.noreply.github.com> Co-Authored-By: Flakebi <flakebi@t-online.de>
2022-05-05 12:09:42 +02:00
kanidm = handleTest ./kanidm.nix {};
nixos/kanidm: add provisioning of groups, persons and oauth2 systems
2024-03-10 21:32:24 +01:00
kanidm-provisioning = handleTest ./kanidm-provisioning.nix {};
nixos/karma: init
2022-10-10 10:46:25 +05:30
karma = handleTest ./karma.nix {};
nixos/tests/kavita: init
2023-04-30 00:27:25 -03:00
kavita = handleTest ./kavita.nix {};
nixos/tests/kbd-setfont-decompress: init
2021-05-31 02:37:14 +08:00
kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};
nixos/tests: add kbd-update-search-paths-patch
2021-07-20 02:21:02 +07:00
kbd-update-search-paths-patch = handleTest ./kbd-update-search-paths-patch.nix {};
nixos/tests/kea: init A simple DHCPv4 test case, with borrowed structure from the systemd-networkd-dhcpserver test.
2021-07-14 00:43:17 +02:00
kea = handleTest ./kea.nix {};
nixos/keepalived: add test
2019-12-22 07:45:31 +00:00
keepalived = handleTest ./keepalived.nix {};
nixos/tests: add keepassxc Test whether KeePassXC launches correctly.
2021-02-02 12:35:46 +01:00
keepassxc = handleTest ./keepassxc.nix {};
nixos/tests/kerberos: fix evaluation
2019-01-11 04:36:51 +00:00
kerberos = handleTest ./kerberos/default.nix {};
kernel: Add tests to passthru.tests
2021-04-07 11:57:58 -04:00
kernel-generic = handleTest ./kernel-generic.nix {};
nixos/tests: add kernel-latest-ath-user-regd Test for the option `networking.wireless.athUserRegulatoryDomain` to make sure the underlying patch still applies for the latest kernel. Also see NixOS/nixpkgs#108725.
2021-01-31 14:55:53 +01:00
kernel-latest-ath-user-regd = handleTest ./kernel-latest-ath-user-regd.nix {};
nixosTests.kernel-rust.linux_testing: init for aarch64 Older kernels do not support Rust on aarch64, so we have to move the platform check from all-tests.nix into the test itself.
2024-03-27 16:15:37 +01:00
kernel-rust = handleTest ./kernel-rust.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 09:41:54 -04:00
keter = handleTest ./keter.nix {};
nixos/tests: register `kexec' test
2021-10-25 00:20:46 +02:00
kexec = handleTest ./kexec.nix {};
nixos/keycloak: Add support for MySQL and external DBs with SSL - Add support for using MySQL as an option to PostgreSQL. - Enable connecting to external DBs with SSL - Add a database port config option
2020-10-26 15:33:57 +01:00
keycloak = discoverTests (import ./keycloak.nix);
keyd: add keyd service and test The keyd package already exists, but without a systemd service. Keyd requires write access to /var/run to create its socket. Currently the directory it uses can be changed with an environment variable, but the keyd repo state suggests that this may turn into a compile-time option. with that set, and some supplementary groups added, we can run the service under DynamicUser. Co-authored-by: pennae <82953136+pennae@users.noreply.github.com>
2023-03-15 15:15:38 +02:00
keyd = handleTest ./keyd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
keymap = handleTest ./keymap.nix {};
nixos/kimai: init module & add test
2024-11-02 05:50:17 +07:00
kimai = handleTest ./kimai.nix {};
nixos/kmonad: add a basic nixos test
2025-01-01 10:10:00 +08:00
kmonad = runTest ./kmonad.nix;
nixos/knot: init
2019-03-13 01:12:56 +01:00
knot = handleTest ./knot.nix {};
nixos/komga: add module
2022-08-12 23:52:52 +02:00
komga = handleTest ./komga.nix {};
nixos/tests: fix discrepancy between nix-build and nix build
2023-12-23 22:40:56 -06:00
krb5 = discoverTests (import ./krb5);
nixos/test/ksm: add simple test
2021-02-26 13:06:18 +01:00
ksm = handleTest ./ksm.nix {};
nixos/kthxbye: init
2022-09-26 00:16:03 +05:30
kthxbye = handleTest ./kthxbye.nix {};
kubernetes: fix flaky test and run tests as group
2021-07-30 16:16:23 +01:00
kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};
nixos/tests/kubo: various improvements Add new test to check if kubo.passthru.repoVersion is set correctly. Also split the existing NixOS VM test into two independent parts. The test already used two independent VMs but just one testScript. This made experimenting with just one of the two VMs slower than it needed to be. It should also increase parallelism slightly since both test scripts can now run at the same time.
2023-10-08 18:56:05 +02:00
kubo = import ./kubo { inherit recurseIntoAttrs runTest; };
nixosTests.ladybird: init
2022-08-16 15:03:37 +02:00
ladybird = handleTest ./ladybird.nix {};
nixos/service/languagetool: init
2022-08-16 20:33:08 +02:00
languagetool = handleTest ./languagetool.nix {};
nixos/lanraragi: init
2023-09-17 17:12:55 +02:00
lanraragi = handleTest ./lanraragi.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
latestKernel.login = handleTest ./login.nix { latestKernel = true; };
leaps = handleTest ./leaps.nix {};
nixos/tests/lemmy: init Co-authored-by: Ctem <c@ctem.me> Co-authored-by: cab <cab404@mailbox.org> Co-authored-by: a-kenji <aks.kenji@protonmail.com> Co-authored-by: Shahar Dawn Or <mightyiampresence@gmail.com> Co-authored-by: Matthias Meschede <MMesch@users.noreply.github.com> Co-authored-by: Ilan Joselevich <personal@ilanjoselevich.com>
2022-09-02 02:02:51 -07:00
lemmy = handleTest ./lemmy.nix {};
nixos/libinput: add module tests
2021-11-15 08:46:20 -03:00
libinput = handleTest ./libinput.nix {};
nixos/librenms: add nixos test
2023-10-05 16:09:58 +02:00
librenms = handleTest ./librenms.nix {};
nixosTests.aseprite: init
2021-11-18 19:10:48 +01:00
libresprite = handleTest ./libresprite.nix {};
nixos/tests/libreswan: use runTest
2024-05-09 20:22:57 +02:00
libreswan = runTest ./libreswan.nix;
nixos/tests/libreswan-nat: add test
2024-05-09 20:24:56 +02:00
libreswan-nat = runTest ./libreswan-nat.nix;
librewolf: add nixos test - support librewolf in the firefox nixos test - use the correct binary name - ensure autoplay is always on for the audio test, since librewolf disables it by default
2022-07-08 17:40:24 -07:00
librewolf = handleTest ./firefox.nix { firefoxPackage = pkgs.librewolf; };
libuiohook: init at 1.2.2
2022-07-15 21:00:28 +01:00
libuiohook = handleTest ./libuiohook.nix {};
nixos/tests/libvirtd: init
2022-08-22 05:17:06 +02:00
libvirtd = handleTest ./libvirtd.nix {};
nixos/libinput: add module tests
2021-11-15 08:46:20 -03:00
lidarr = handleTest ./lidarr.nix {};
nixos/release-combined: re-enable lightdm test This has been tested in the Pantheon test for a year now and it does fine on hydra.
2019-08-06 18:29:50 -04:00
lightdm = handleTest ./lightdm.nix {};
nixos: add lighttpd test
2022-07-24 17:04:12 +02:00
lighttpd = handleTest ./lighttpd.nix {};
nixos/limesurvey: add basic nixos test
2019-03-16 08:24:23 -04:00
limesurvey = handleTest ./limesurvey.nix {};
listmonk: perform tests only linux supported platforms Otherwise, Darwin will try to run them and fail.
2023-08-23 17:50:28 +02:00
listmonk = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./listmonk.nix {};
nixos/litestream: init
2021-07-30 17:41:54 +02:00
litestream = handleTest ./litestream.nix {};
nixosTests.lldap: init
2023-04-27 15:26:57 +02:00
lldap = handleTest ./lldap.nix {};
nixos/tests/localsend: init
2024-05-12 17:07:22 -05:00
localsend = handleTest ./localsend.nix {};
nixos/locate: Add a test
2020-11-23 17:53:21 -08:00
locate = handleTest ./locate.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
login = handleTest ./login.nix {};
nixos tests: add logrotate test make sure the service is enabled by default and works.
2022-02-11 17:49:52 +09:00
logrotate = handleTest ./logrotate.nix {};
nixos/tests: add test for loki
2019-06-27 18:11:09 +02:00
loki = handleTest ./loki.nix {};
nixos/tests: add test for luksroot and initrd keymaps (#189725)
2023-02-20 08:19:02 +01:00
luks = handleTest ./luks.nix {};
nixos/tests/lvm2: init
2022-02-01 18:21:11 +01:00
lvm2 = handleTest ./lvm2 {};
lxc: added option for unprivileged containers. Added extra option to enable unprivileged containers. This includes a patch to remove the hard-coded path to `lxc-user-nic` and a new security wrapper to set SUID to `lxc-user-nic`.
2024-05-08 13:52:25 +02:00
lxc = handleTest ./lxc {};
nixos/tests/lxd: disable virtual-machine test on aarch64
2023-09-04 15:19:34 -04:00
lxd = pkgs.recurseIntoAttrs (handleTest ./lxd { inherit handleTestOn; });
nixosTests.lxd-image-server: init
2021-10-20 23:39:53 +02:00
lxd-image-server = handleTest ./lxd-image-server.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
#logstash = handleTest ./logstash.nix {};
tests/lomiri: Prepare for splitting
2024-08-05 23:12:50 +02:00
lomiri = discoverTests (import ./lomiri.nix);
tests/lomiri-calculator-app: init
2024-06-19 16:23:11 +02:00
lomiri-calculator-app = runTest ./lomiri-calculator-app.nix;
nixosTests.lomiri-calendar-app: init
2025-02-13 20:14:15 +01:00
lomiri-calendar-app = runTest ./lomiri-calendar-app.nix;
tests/lomiri-camera-app: init
2024-07-24 19:18:05 +02:00
lomiri-camera-app = runTest ./lomiri-camera-app.nix;
tests/lomiri-clock-app: init
2024-06-29 21:24:57 +02:00
lomiri-clock-app = runTest ./lomiri-clock-app.nix;
tests/lomiri-docviewer-app: init
2024-08-24 23:09:29 +02:00
lomiri-docviewer-app = runTest ./lomiri-docviewer-app.nix;
tests/lomiri-filemanager-app: init
2024-06-07 11:37:49 +02:00
lomiri-filemanager-app = runTest ./lomiri-filemanager-app.nix;
tests/lomiri-mediaplayer-app: init
2024-11-27 19:31:56 +01:00
lomiri-mediaplayer-app = runTest ./lomiri-mediaplayer-app.nix;
nixosTests.lomiri-music-app: init
2025-02-09 15:39:44 +01:00
lomiri-music-app = runTest ./lomiri-music-app.nix;
tests/lomiri-gallery-app: init
2024-08-14 15:26:08 +02:00
lomiri-gallery-app = runTest ./lomiri-gallery-app.nix;
tests/lomiri-system-settings: init
2024-02-15 09:59:39 +01:00
lomiri-system-settings = handleTest ./lomiri-system-settings.nix {};
lorri: init at version unstable-2019-10-30 Includes user service (nixos/modules/services/development/lorri) that starts on demand.
2019-11-05 11:57:05 +01:00
lorri = handleTest ./lorri/default.nix {};
nixosTests.lxqt: init
2025-01-27 00:06:25 +08:00
lxqt = handleTest ./lxqt.nix {};
nixos/ly: init module
2024-03-20 16:48:22 +08:00
ly = handleTest ./ly.nix {};
nixos/maddy: Add tls option
2023-04-21 08:59:13 +02:00
maddy = discoverTests (import ./maddy { inherit handleTest; });
nixos: add maestral tests
2022-04-01 10:41:31 +08:00
maestral = handleTest ./maestral.nix {};
nixos/tests: add magic-wormhole-mailbox-server
2020-03-30 13:30:05 +02:00
magic-wormhole-mailbox-server = handleTest ./magic-wormhole-mailbox-server.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
magnetico = handleTest ./magnetico.nix {};
nixos/mailcatcher: add nixos test
2019-03-27 07:35:24 -04:00
mailcatcher = handleTest ./mailcatcher.nix {};
mailhog: add simple test
2020-12-17 16:58:57 +01:00
mailhog = handleTest ./mailhog.nix {};
nixos/mailpit: init Simple module to configure a systemd service for mailpit.
2024-07-24 15:48:20 +02:00
mailpit = handleTest ./mailpit.nix {};
nixosTests.mailman: init
2023-02-09 17:56:56 +00:00
mailman = handleTest ./mailman.nix {};
nixos/tests/man: test common functionality of both man impls
2021-09-24 20:54:08 +02:00
man = handleTest ./man.nix {};
nixos/tests/mariadb-galera: test multiple mariadb versions merge both tests and completely refactor
2021-12-08 09:47:07 +00:00
mariadb-galera = handleTest ./mysql/mariadb-galera.nix {};
marytts: init at 5.2.1-unstable-2024-10-09, nixos/marytts: init (#351933) * marytts: init at 5.2.1-unstable-2024-10-09 * nixos/marytts: init module * nixos/marytts: add tests
2024-12-12 06:12:54 +01:00
marytts = handleTest ./marytts.nix {};
nixos/mastodon: use recurseIntoAttrs for better test ergonomics
2024-07-04 18:07:44 +02:00
mastodon = pkgs.recurseIntoAttrs (handleTest ./web-apps/mastodon { inherit handleTestOn; });
nixos/tests/pixelfed: init test
2023-03-25 17:02:52 +01:00
pixelfed = discoverTests (import ./web-apps/pixelfed { inherit handleTestOn; });
nixos/tests/mate: init
2023-01-08 23:44:00 +08:00
mate = handleTest ./mate.nix {};
nixosTests.mate-wayland: init
2024-03-12 22:29:08 +08:00
mate-wayland = handleTest ./mate-wayland.nix {};
matter-server: add nixos service module New module to run the python-matter-server executable as a sandboxed system service.
2023-10-28 23:16:44 -04:00
matter-server = handleTest ./matter-server.nix {};
nixos/matomo: migrate tests from handleTest to runTest
2025-01-15 12:42:39 +01:00
matomo = runTest ./matomo.nix;
nixos/tests/matrix-appservice-irc: modernize
2024-09-04 20:35:52 +02:00
matrix-appservice-irc = runTest ./matrix/appservice-irc.nix;
nixos: move matrix services into their category
2022-05-13 16:46:01 +09:00
matrix-conduit = handleTest ./matrix/conduit.nix {};
matrix-synapse = handleTest ./matrix/synapse.nix {};
nixos/synapse: add test for running synapse with workers Co-authored-by: Daniel Olsen <daniel.olsen99@gmail.com>
2023-07-07 11:27:55 +02:00
matrix-synapse-workers = handleTest ./matrix/synapse-workers.nix {};
mautrix-meta: init service Acked-by: Rutherther <rutherther@proton.me>
2024-03-17 18:56:18 +01:00
mautrix-meta-postgres = handleTest ./matrix/mautrix-meta-postgres.nix {};
mautrix-meta-sqlite = handleTest ./matrix/mautrix-meta-sqlite.nix {};
nixos/mattermost: modernize, support MySQL and mmctl Based on #198040. Prioritizes backwards compatibility, including database and plugin compatibility, while adding more sensible defaults like database peer authentication. Expand the scope of tests to include plugins (including building from source) and testing that a piece of media uploads and downloads to make sure the storage directory doesn't vanish.
2024-10-21 23:05:06 -07:00
mattermost = handleTest ./mattermost {};
nixos/mealie: init tests Signed-off-by: Litchi Pi <litchi.pi@proton.me>
2024-02-01 08:30:57 +01:00
mealie = handleTest ./mealie.nix {};
nixos/tests/mediamtx: init
2023-08-10 20:43:26 +02:00
mediamtx = handleTest ./mediamtx.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
mediatomb = handleTest ./mediatomb.nix {};
nixos/mediawiki: init service to replace httpd subservice
2019-06-05 21:19:11 -04:00
mediawiki = handleTest ./mediawiki.nix {};
nixosTests.meilisearch: init (cherry picked from commit 4cc2d55f6ac2440843ef3387909dbc703f65397d)
2020-04-07 12:00:43 +03:00
meilisearch = handleTest ./meilisearch.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
memcached = handleTest ./memcached.nix {};
nixos/merecat: init
2022-10-19 10:49:57 +02:00
merecat = handleTest ./merecat.nix {};
tests: adding metabase service test
2019-08-18 09:28:16 +02:00
metabase = handleTest ./metabase.nix {};
nixos/mihomo: add tests
2024-02-10 22:43:17 +08:00
mihomo = handleTest ./mihomo.nix {};
nixosTests.mindustry: init
2023-01-15 00:28:32 +01:00
mindustry = handleTest ./mindustry.nix {};
minecraft: Add test
2020-11-28 12:42:10 -05:00
minecraft = handleTest ./minecraft.nix {};
minecraft-server: Add test
2020-11-28 12:42:46 -05:00
minecraft-server = handleTest ./minecraft-server.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
minidlna = handleTest ./minidlna.nix {};
miniflux: add service
2018-12-21 10:36:58 -08:00
miniflux = handleTest ./miniflux.nix {};
minio: add test to nixos/tests/all-tests.nix
2019-02-05 17:38:34 +01:00
minio = handleTest ./minio.nix {};
tests/miracle-wm: init
2024-06-10 15:55:54 +02:00
miracle-wm = runTest ./miracle-wm.nix;
nixos/miriway: add test
2023-02-04 02:23:14 +01:00
miriway = handleTest ./miriway.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
misc = handleTest ./misc.nix {};
nixos/misskey: init
2024-06-12 17:34:42 +02:00
misskey = handleTest ./misskey.nix {};
nixos/mjolnir: add test
2021-05-30 17:33:09 +02:00
mjolnir = handleTest ./matrix/mjolnir.nix {};
nixosTests.mobilizon: migrate from handleTest to runTest
2025-01-16 11:38:53 +01:00
mobilizon = runTest ./mobilizon.nix;
nixos/mod_perl: add test
2021-08-13 20:55:15 +02:00
mod_perl = handleTest ./mod_perl.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
molly-brown = handleTest ./molly-brown.nix {};
nixos/mollysocket: init
2024-01-05 03:10:12 -08:00
mollysocket = handleTest ./mollysocket.nix { };
nixos/monado: add test Signed-off-by: Sefa Eyeoglu <contact@scrumplex.net>
2023-12-18 17:48:48 +01:00
monado = handleTest ./monado.nix {};
nixos/monetdb: Init nixos test
2024-03-19 21:54:05 +01:00
monetdb = handleTest ./monetdb.nix {};
nixos/monica: init
2023-04-16 11:21:57 +02:00
monica = handleTest ./web-apps/monica.nix {};
nixosTests.mongodb: migrate from handleTest to runTest
2025-01-21 16:28:54 +01:00
mongodb = runTest ./mongodb.nix;
nixosTests.mongodb-ce: init
2025-01-21 17:27:18 +01:00
mongodb-ce = runTest ({ config, ... }: {
imports = [ ./mongodb.nix ];
defaults.services.mongodb.package = config.node.pkgs.mongodb-ce;
});
nixos/moodle: init service
2019-06-21 10:09:15 -04:00
moodle = handleTest ./moodle.nix {};
nixos/tests/moonraker: init
2022-03-22 15:35:39 -07:00
moonraker = handleTest ./moonraker.nix {};
nixos/mopidy: add test
2024-11-14 23:40:14 +01:00
mopidy = handleTest ./mopidy.nix {};
tests/morph-browser: Add standalone (non-Lomiri) test
2024-02-22 10:36:50 +01:00
morph-browser = handleTest ./morph-browser.nix { };
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
morty = handleTest ./morty.nix {};
nixos/mosquitto: add test
2019-04-24 16:23:13 +08:00
mosquitto = handleTest ./mosquitto.nix {};
nixos/tests: add moosefs test
2021-10-06 21:51:07 +02:00
moosefs = handleTest ./moosefs.nix {};
nixos/movim: add service module
2024-03-22 23:49:50 +07:00
movim = discoverTests (import ./web-apps/movim { inherit handleTestOn; });
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
mpd = handleTest ./mpd.nix {};
mpvScripts.simple-mpv-webui: 1.0.0 -> 2.1.0 This also adds a test. The current packaged version (1.0.0) is broken, it cannot find relevant files.
2021-08-01 00:44:02 +02:00
mpv = handleTest ./mpv.nix {};
nixos/tests/mtp: init Adds a fully fledged NixOS VM integration test which uses jmtpfs and gvfs to test the functionality of MTP inside of NixOS. It uses USB device emulation in QEMU to create MTP device(s) which can be tested against.
2021-11-15 05:58:12 +00:00
mtp = handleTest ./mtp.nix {};
nixos/tests/multipass: init
2023-02-03 09:28:48 +00:00
multipass = handleTest ./multipass.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
mumble = handleTest ./mumble.nix {};
musescore: Enable test only on x86_64-linux
2023-02-04 12:16:53 +02:00
# Fails on aarch64-linux at the PDF creation step - need to debug this on an
# aarch64 machine..
musescore = handleTestOn ["x86_64-linux"] ./musescore.nix {};
nixos/tests/music-assistant: init
2024-05-18 01:10:54 +02:00
music-assistant = runTest ./music-assistant.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
munin = handleTest ./munin.nix {};
mutableUsers = handleTest ./mutable-users.nix {};
nixos/tests/mycelium: init
2024-03-18 17:40:30 +01:00
mycelium = handleTest ./mycelium {};
nixos/mympd: add nixos test
2023-12-18 23:31:29 +02:00
mympd = handleTest ./mympd.nix {};
nixos/tests: move mysql tests to subfolder
2020-04-02 23:40:55 +03: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 {};
nixos/n8n: init module and test
2020-11-28 18:00:25 +01:00
n8n = handleTest ./n8n.nix {};
nagios: enable darwin support
2024-05-03 20:40:22 +02:00
nagios = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./nagios.nix {};
nar-serve: init at 0.3.0 (#95420) * nar-serve: init at 0.3.0 * nixos/nar-serve: add new module Co-authored-by: zimbatm <zimbatm@zimbatm.com>
2020-11-07 00:59:51 +07:00
nar-serve = handleTest ./nar-serve.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
nat.firewall = handleTest ./nat.nix { withFirewall = true; };
nat.standalone = handleTest ./nat.nix { withFirewall = false; };
nixos/{firewall, nat}: add a nftables based implementation
2022-12-23 00:23:23 +08:00
nat.nftables.firewall = handleTest ./nat.nix { withFirewall = true; nftables = true; };
nat.nftables.standalone = handleTest ./nat.nix { withFirewall = false; nftables = true; };
nixos/nats: init
2021-06-26 13:58:40 +02:00
nats = handleTest ./nats.nix {};
nixos/navidrome: init module and test Co-authored-by: aciceri <andrea.ciceri@autistici.org> Co-authored-by: nyanloutre <paul@nyanlout.re>
2020-12-05 19:11:21 +01:00
navidrome = handleTest ./navidrome.nix {};
nbd: add programs.nbd, services.nbd, and test Changes: nbd: Update nixos/modules/services/networking/nbd.nix Co-authored-by: pennae <82953136+pennae@users.noreply.github.com> nbd: Update nixos/modules/services/networking/nbd.nix Co-authored-by: pennae <82953136+pennae@users.noreply.github.com> nbd: Update nixos/tests/nbd.nix Co-authored-by: pennae <82953136+pennae@users.noreply.github.com> nbd: generalize options in nbd service nbd: harden service nbd: Update nixos/modules/services/networking/nbd.nix Co-authored-by: pennae <82953136+pennae@users.noreply.github.com> nbd: Update nixos/modules/services/networking/nbd.nix Co-authored-by: pennae <82953136+pennae@users.noreply.github.com> nbd: refactor code a bit and BindPaths automatically
2022-03-06 13:49:57 +00:00
nbd = handleTest ./nbd.nix {};
nixos/tests/ncdns: add test
2020-06-07 23:59:12 +02:00
ncdns = handleTest ./ncdns.nix {};
nixos/tests/ncps: init service test
2025-01-01 17:15:26 -08:00
ncps = runTest ./ncps.nix;
ncps-custom-cache-datapath = runTest {
imports = [ ./ncps.nix ];
defaults.services.ncps.cache.dataPath = "/path/to/ncps";
};
nixos/ndppd: register test
2019-02-03 16:47:01 +01:00
ndppd = handleTest ./ndppd.nix {};
nixos/nix-channel.nix: shellcheck and fix the activation check
2024-07-16 22:00:16 +02:00
nix-channel = pkgs.callPackage ../modules/config/nix-channel/test.nix { };
nixos/nebula: Add nebula module and unit test to lists
2021-03-04 21:28:58 -08:00
nebula = handleTest ./nebula.nix {};
nixosTests.netbird: init
2022-08-14 19:59:15 +03:00
netbird = handleTest ./netbird.nix {};
tests/nimdow: init
2024-03-16 19:13:51 +01:00
nimdow = handleTest ./nimdow.nix {};
neo4j: add neo4j test
2019-02-01 14:29:54 +01:00
neo4j = handleTest ./neo4j.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
netdata = handleTest ./netdata.nix {};
nixosTests.networking: split router into a separate file and remove `with lib;` antipattern this commit also does a tiny bit more, namely: - removing unnecessary ping's to the hosts own ip - and simplifying a few pieces of code like changing `{ inherit (pkgs) lib pkgs; };` to `{ inherit lib pkgs; };`
2024-03-16 21:05:56 +01:00
networking.scripted = handleTest ./networking/networkd-and-scripted.nix { networkd = false; };
networking.networkd = handleTest ./networking/networkd-and-scripted.nix { networkd = true; };
nixosTests.networking: refactor and add NetworkManager support
2024-03-01 01:38:35 +01:00
networking.networkmanager = handleTest ./networking/networkmanager.nix {};
netbox_3_6: init, mark 3_5 as EOL use it for the upgrade test increase tests memory, otherwise NetBox gets OOM killed Co-authored-by: Raito Bezarius <masterancpp@gmail.com>
2023-09-24 10:06:08 +02:00
netbox_3_6 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_6; };
netbox: 3.6.9 -> 3.7.1 Or another way to see it: netbox_3_7: init at 3.7.1 Make NetBox 3.7 the default version if stateVersion >= 24.05, switch upgrade test to test upgrade from 3.6 to 3.7, remove clearcache command for >=3.7.0, make reindex command mandatory
2024-01-22 16:17:57 +01:00
netbox_3_7 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_7; };
netbox_4_0: init at 4.0.11 Migrate to pkgs/by-name, and update the test so that it passes for all versions This version is added as EOL, since NetBox 4.1 is out, but it might be still useful in case of an upgrade issue.
2024-08-02 10:58:19 +02:00
netbox_4_0 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_4_0; };
netbox_4_1: init at 4.1.3
2024-10-07 16:14:33 +02:00
netbox_4_1 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_4_1; };
nixos/tests/netbox-upgrade: init Test that the upgrade from NetBox 3.3 to NetBox 3.5 runs fine
2023-07-31 14:56:05 +02:00
netbox-upgrade = handleTest ./web-apps/netbox-upgrade.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
# TODO: put in networking.nix after the test becomes more complete
networkingProxy = handleTest ./networking-proxy.nix {};
nextcloud = handleTest ./nextcloud {};
tests/nextflow: restrict to x86_64-linux The docker image hash seems to differ on different systems. See https://github.com/NixOS/nixpkgs/pull/339197#discussion_r1779927407
2024-09-30 11:15:23 +02:00
nextflow = handleTestOn ["x86_64-linux"] ./nextflow.nix {};
nixos/nextjs-ollama-llm-ui: init module NixOS already has good support for the Ollama backend service. Now we can benefit from having a convenient web frontend as well for it.
2024-05-20 14:54:08 +02:00
nextjs-ollama-llm-ui = runTest ./web-apps/nextjs-ollama-llm-ui.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
nexus = handleTest ./nexus.nix {};
nixos/nfs: test nfs with kerberos authentication
2019-11-27 14:37:27 +00:00
# TODO: Test nfsv3 + Kerberos
nfs3 = handleTest ./nfs { version = 3; };
nfs4 = handleTest ./nfs { version = 4; };
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
nghttpx = handleTest ./nghttpx.nix {};
nginx = handleTest ./nginx.nix {};
nginx: test basic auth
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 14:06:00 +01:00
nginx-etag = handleTest ./nginx-etag.nix {};
nginx: change etags for statically compressed files served from store Per RFC 9110, [section 8.8.1][1], different representations of the same resource should have different Etags: > A strong validator is unique across all versions of all > representations associated with a particular resource over time. > However, there is no implication of uniqueness across representations > of different resources (i.e., the same strong validator might be in > use for representations of multiple resources at the same time and > does not imply that those representations are equivalent) When serving statically compressed files (ie, when there is an existing corresponding .gz/.br/etc. file on disk), Nginx sends the Etag marked as strong. These tags should be different for each compressed format (as shown in an explicit example in section [8.8.3.3][2] of the RFC). Upstream Etags are composed of the file modification timestamp and content length, and the latter generally changes between these representations. Previous implementation of Nix-specific Etags for things served from store used the store hash. This is fine to share between different files, but it becomes a problem for statically compressed versions of the same file, as it means Nginx was serving different representations of the same resource with the same Etag, marked as strong. This patch addresses this by imitating the upstream Nginx behavior, and appending the value of content length to the store hash. [1]: https://www.rfc-editor.org/rfc/rfc9110.html#name-validator-fields [2]: https://www.rfc-editor.org/rfc/rfc9110.html#name-example-entity-tags-varying
2024-01-02 20:29:15 +01:00
nginx-etag-compression = handleTest ./nginx-etag-compression.nix {};
nginx: make global redirect vhost option accept exceptions By moving the return into a location directive, one can provide exceptions by adding locations. This is similar to what the forceSSL option does.
2022-12-03 18:58:33 +01:00
nginx-globalredirect = handleTest ./nginx-globalredirect.nix {};
nixos/tests: add nginx-http3 test
2022-04-18 13:22:39 +03:00
nginx-http3 = handleTest ./nginx-http3.nix {};
nixos/tests/nginx-mime: add check optimal size of types_hash
2024-09-25 20:55:38 +03:00
nginx-mime = handleTest ./nginx-mime.nix {};
nixos/tests/nginx-modsecurity: init
2022-02-15 00:10:37 +01:00
nginx-modsecurity = handleTest ./nginx-modsecurity.nix {};
nixos/tests/nginx: add test variant for moreheaders module
2024-01-15 17:25:21 +01:00
nginx-moreheaders = handleTest ./nginx-moreheaders.nix {};
nginxModules.njs: init at 0.7.8
2022-09-18 14:54:04 +02:00
nginx-njs = handleTest ./nginx-njs.nix {};
nixos/nginx: sort test include order alphabetically
2023-07-28 20:30:43 +02:00
nginx-proxyprotocol = handleTest ./nginx-proxyprotocol {};
nginx: Fix ETag patch to ignore realpath(3) error While our ETag patch works pretty fine if it comes to serving data off store paths, it unfortunately broke something that might be a bit more common, namely when using regexes to extract path components of location directives for example. Recently, @devhell has reported a bug with a nginx location directive like this: location ~^/\~([a-z0-9_]+)(/.*)?$" { alias /home/$1/public_html$2; } While this might look harmless at first glance, it does however cause issues with our ETag patch. The alias directive gets broken up by nginx like this: *2 http script copy: "/home/" *2 http script capture: "foo" *2 http script copy: "/public_html/" *2 http script capture: "bar.txt" In our patch however, we use realpath(3) to get the canonicalised path from ngx_http_core_loc_conf_s.root, which returns the *configured* value from the root or alias directive. So in the example above, realpath(3) boils down to the following syscalls: lstat("/home", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 lstat("/home/$1", 0x7ffd08da6f60) = -1 ENOENT (No such file or directory) During my review[1] of the initial patch, I didn't actually notice that what we're doing here is returning NGX_ERROR if the realpath(3) call fails, which in turn causes an HTTP 500 error. Since our patch actually made the canonicalisation (and thus additional syscalls) necessary, we really shouldn't introduce an additional error so let's - at least for now - silently skip return value if realpath(3) has failed. However since we're using the unaltered root from the config we have another issue, consider this root: /nix/store/...-abcde/$1 Calling realpath(3) on this path will fail (except if there's a file called "$1" of course), so even this fix is not enough because it results in the ETag not being set to the store path hash. While this is very ugly and we should fix this very soon, it's not as serious as getting HTTP 500 errors for serving static files. I added a small NixOS VM test, which uses the example above as a regression test. It seems that my memory is failing these days, since apparently I *knew* about this issue since digging for existing issues in nixpkgs, I found this similar pull request which I even reviewed: https://github.com/NixOS/nixpkgs/pull/66532 However, since the comments weren't addressed and the author hasn't responded to the pull request, I decided to keep this very commit and do a follow-up pull request. [1]: https://github.com/NixOS/nixpkgs/pull/48337 Signed-off-by: aszlig <aszlig@nix.build> Reported-by: @devhell Acked-by: @7c6f434c Acked-by: @yorickvP Merges: https://github.com/NixOS/nixpkgs/pull/80671 Fixes: https://github.com/NixOS/nixpkgs/pull/66532
2020-02-20 20:43:42 +01:00
nginx-pubhtml = handleTest ./nginx-pubhtml.nix {};
nixos/nginx: make redirect status code configurable Add an option to configure which code globalRedirect and forceSSL use. It previously was always 301 with no easy way to override.
2023-12-01 15:42:46 -03:00
nginx-redirectcode = handleTest ./nginx-redirectcode.nix {};
nixos/tests: add nginx-sso basic functionality test
2018-12-28 11:41:52 +01:00
nginx-sso = handleTest ./nginx-sso.nix {};
nixos/nginx: add test for status page
2023-07-28 19:36:55 +02:00
nginx-status-page = handleTest ./nginx-status-page.nix {};
nixos/tests: add test for nginx temp directories removal The default temp directories for nginx must not be removed by systemd-tmpfiles-clean.service. This test lowers the age parameter for /tmp and triggers a cleanup that would normally only occur after 10 days of nginx inactivity. After that, the functionality of nginx that requires a temporary directory is tested again.
2023-10-06 14:26:06 +02:00
nginx-tmpdir = handleTest ./nginx-tmpdir.nix {};
nixos/nginx: Allow empty port for listen directive When listening on unix sockets, it doesn't make sense to specify a port for nginx's listen directive. Since nginx defaults to port 80 when the port isn't specified (but the address is), we can change the default for the option to null as well without changing any behaviour.
2023-07-07 11:52:37 -04:00
nginx-unix-socket = handleTest ./nginx-unix-socket.nix {};
nixos/nginx: ensure all variants have a basic level of testing
2020-06-02 17:01:03 +12:00
nginx-variants = handleTest ./nginx-variants.nix {};
nixos/tests: add nifi test
2022-04-10 20:41:30 +03:00
nifi = handleTestOn ["x86_64-linux"] ./web-apps/nifi.nix {};
nixos/nitter: init module and test
2021-07-26 12:00:05 +02:00
nitter = handleTest ./nitter.nix {};
nixos/nix: add workaround for https://github.com/NixOS/nix/issues/9487 Nix has a suprising behavior where if the option `extra-foo` is set before `foo`, then setting `foo` overwrites the setting for `extra-foo`. This is reported as https://github.com/NixOS/nix/issues/9487, and will likely not be fixed any time soon. This works around this issue by always putting `extra-*` settings after non-extra ones in the nixos-generated `/etc/nix.conf`.
2024-01-01 12:00:00 +00:00
nix-config = handleTest ./nix-config.nix {};
tests/nix-ld: fix invocation
2022-04-11 21:51:29 +03:00
nix-ld = handleTest ./nix-ld.nix {};
nixosTests.nix-misc: Split from `nixosTests.misc` Bit weird to have nix tests in misc Add `artturin` to maintainers
2024-05-30 18:09:46 +03:00
nix-misc = handleTest ./nix/misc.nix {};
nixosTest.nix-upgrade: init Test out both nix upgrade-nix and a NixOS upgrade. Inject a fake fallback-paths.nix assuming a stable -> latest upgrade. The NixOS upgrade does not use nixos-rebuild switch due to the cost+annoyance of the instantiation needing system.includeBuildDependencies.
2024-08-18 00:31:38 -04:00
nix-upgrade = handleTest ./nix/upgrade.nix {inherit (pkgs) nixVersions;};
nixosTests.nix-required-mounts: init
2023-10-17 15:25:17 +03:00
nix-required-mounts = runTest ./nix-required-mounts;
nixosTests.nix-serve: Use new entrypoint This reuses the `pkgs`, so that `pkgs.nixosTests.nix-serve` will run with the overlays of `pkgs` applied.
2024-09-17 15:01:35 +02:00
nix-serve = runTest ./nix-serve.nix;
nixos/tests: fix nix-serve path nixos/tests: rename nix-ssh-serve to nix-serve-ssh nixos/tests/nix-serve-ssh: add --experimental-features nixos-serve: add nix-serve-ssh to passthru.tests
2021-12-03 18:19:42 +02:00
nix-serve-ssh = handleTest ./nix-serve-ssh.nix {};
nixopsUnstable: Add test
2021-10-18 00:38:58 +02:00
nixops = handleTest ./nixops/default.nix {};
nixos-generate-config: enable overriding configuration.nix
2019-08-07 18:04:18 +02:00
nixos-generate-config = handleTest ./nixos-generate-config.nix {};
nixos/tests: make nixos-rebuild tests x86_64-linux only Depends on GRUB2/BIOS.
2023-10-23 11:00:20 +01:00
nixos-rebuild-install-bootloader = handleTestOn ["x86_64-linux"] ./nixos-rebuild-install-bootloader.nix {};
nixos/tests: add nixos-rebuild-install-bootloader-ng
2024-12-05 22:52:38 +00:00
nixos-rebuild-install-bootloader-ng = handleTestOn ["x86_64-linux"] ./nixos-rebuild-install-bootloader.nix { withNg = true; };
nixos/tests: add nixos-rebuild-specialisations-ng
2024-12-09 12:20:30 +00:00
nixos-rebuild-specialisations = runTestOn ["x86_64-linux"] {
imports = [ ./nixos-rebuild-specialisations.nix ];
_module.args.withNg = false;
};
nixos-rebuild-specialisations-ng = runTestOn ["x86_64-linux"] {
imports = [ ./nixos-rebuild-specialisations.nix ];
_module.args.withNg = true;
};
nixos/tests: add nixos-rebuild-target-host-ng
2024-12-10 12:50:12 +00:00
nixos-rebuild-target-host = runTest {
imports = [ ./nixos-rebuild-target-host.nix ];
_module.args.withNg = false;
};
nixos-rebuild-target-host-ng = runTest {
imports = [ ./nixos-rebuild-target-host.nix ];
_module.args.withNg = true;
};
nixos/nixpkgs.nix: Make independent (cherry picked from commit 62e7f0eda1c5acf0beb13a00a23f577912a6b8eb)
2021-12-03 12:04:36 +00:00
nixpkgs = pkgs.callPackage ../modules/misc/nixpkgs/test.nix { inherit evalMinimalConfig; };
nixseparatedebuginfod: add module and nixos test
2023-11-29 12:00:00 +00:00
nixseparatedebuginfod = handleTest ./nixseparatedebuginfod.nix {};
nixos/node-red: add test
2021-07-28 11:42:26 +01:00
node-red = handleTest ./node-red.nix {};
nixos/nomad: add extraSettingsFiles option to nomad service (#109761)
2021-01-23 17:52:19 -05:00
nomad = handleTest ./nomad.nix {};
nixos/tests: add non-default-filesystems test
2022-06-22 04:10:44 +02:00
non-default-filesystems = handleTest ./non-default-filesystems.nix {};
nixos: add system.switch.enable flag This flag allows the user to optionally exclude switch-to-confguration.pl from toplevel. This is interesting for appliance images where you don't want to re-build the system. This flag is called `rebuildable` because the standard interface to do this is `nixos-rebuild` which will not work anymore with this change.
2023-10-14 01:29:05 +02:00
non-switchable-system = runTest ./non-switchable-system.nix;
nixos: add sample test for noto fonts
2022-01-22 10:06:13 +08:00
noto-fonts = handleTest ./noto-fonts.nix {};
nixosTests.noto-fonts-cjk-qt-default-weight: init
2023-03-21 15:59:24 +08:00
noto-fonts-cjk-qt-default-weight = handleTest ./noto-fonts-cjk-qt-default-weight.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
novacomd = handleTestOn ["x86_64-linux"] ./novacomd.nix {};
nixos: test programs.npm.npmrc setting
2023-11-02 20:43:20 +13:00
npmrc = handleTest ./npmrc.nix {};
nixosTests.nscd: init, move DynamicUser test into there nixosTests.systemd is quite heavy, it requires a full graphical system, which is quite a big of a rebuild if the only thing you want to test is whether dynamic users work. This is now moved to an `nscd` test, which tests various NSS lookups, making extra sure that the nscd path is tested, not the fallback path (by hiding /etc/nsswitch.conf and /etc/hosts for getent). nixosTests.resolv is removed. It didn't check for reverse lookups, didn't catch nscd breaking halfway in between, and also had an ambiguous reverse lookup - 192.0.2.1 could either reverse lookup to host-ipv4.example.net, or host-dual.example.net.
2022-10-07 11:40:33 +02:00
nscd = handleTest ./nscd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
nsd = handleTest ./nsd.nix {};
nixos/ntfy-sh: init
2022-09-01 14:36:19 +02:00
ntfy-sh = handleTest ./ntfy-sh.nix {};
nixos/ntfy-sh: clean up DynamicUser workarounds this commit removes the static assignments for the ntfy-sh user and group. furthermore, it removes some tmpfiles.d rules which where initially put in place by https://github.com/NixOS/nixpkgs/pull/234811. these are however not required, as ntfy-sh will automatically create the required files and systemd automatically handles the migration process. A nixosTest is added to demonstrate that the migration is working reliably. This also fixes an issue with where systemd would sometimes not start ntfy-sh. The tmpfiles rules in combination with impermanence caused `/ var/lib/ntfy-sh` to be a directory when it should have been a symlink.
2024-01-09 22:03:21 +01:00
ntfy-sh-migration = handleTest ./ntfy-sh-migration.nix {};
nixos/tests/ntpd: init
2024-10-19 14:26:27 -04:00
ntpd = handleTest ./ntpd.nix {};
nixos/ntpd-rs: init
2023-10-31 14:28:49 +00:00
ntpd-rs = handleTest ./ntpd-rs.nix {};
tests/nvidia-container-toolkit: mv shared config to `defaults`
2024-08-22 17:51:54 +00:00
nvidia-container-toolkit = runTest ./nvidia-container-toolkit.nix;
nixosTests.nvmetcfg: init
2024-02-01 13:34:05 -05:00
nvmetcfg = handleTest ./nvmetcfg.nix {};
nixos/nzbget: fix broken service, add a nixos test, as well as some general improvements
2019-04-22 08:06:33 -04:00
nzbget = handleTest ./nzbget.nix {};
nixos/nzbhydra2: init
2020-10-04 16:06:53 +02:00
nzbhydra2 = handleTest ./nzbhydra2.nix {};
nixos/ocis: init at 5.0.0 Co-authored-by: Casey Link <unnamedrambler@gmail.com>
2024-03-18 17:59:16 +05:30
ocis = handleTest ./ocis.nix {};
nixosTests.oddjobd: init
2024-04-06 23:41:28 +02:00
oddjobd = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./oddjobd.nix {};
modules/obs-studio: optionally enable v4l2loopback (#312112) * modules/obs-studio: optionally enable v4l2loopback * add test * added documentation to 24.11 changelog
2024-09-28 17:43:06 +00:00
obs-studio = handleTest ./obs-studio.nix {};
oh-my-zsh: Add test
2020-11-04 20:37:50 -05:00
oh-my-zsh = handleTest ./oh-my-zsh.nix {};
nixos/ollama: split cuda and rocm from service test Cuda and rocm are platform specific, only working on linux. Also, ofborg won't run any of the service test at all because cuda is unfreely licensed.
2024-07-13 17:26:29 -04:00
ollama = runTest ./ollama.nix;
ollama-cuda = runTestOn ["x86_64-linux" "aarch64-linux"] ./ollama-cuda.nix;
ollama-rocm = runTestOn ["x86_64-linux" "aarch64-linux"] ./ollama-rocm.nix;
nixos/ombi: add test for ombi to ensure startup
2021-03-29 17:51:05 +03:00
ombi = handleTest ./ombi.nix {};
openarena: add test
2019-10-23 01:20:56 +11:00
openarena = handleTest ./openarena.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
openldap = handleTest ./openldap.nix {};
nixos/opensearch: Use DynamicUser and StateDirectory by default ...but still allow for setting `dataDir` to a custom path. This gets rid of the use of the deprecated option PermissionsStartOnly. Also, add the ability to customize user and group, since that could be useful with a custom `dataDir`.
2023-02-15 16:11:39 +01:00
opensearch = discoverTests (import ./opensearch.nix);
nixos/tests/openresty-lua: test openresty with lua related to #140655
2021-10-06 23:36:02 -04:00
openresty-lua = handleTest ./openresty-lua.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
opensmtpd = handleTest ./opensmtpd.nix {};
opensmtpd-filter-rspamd: init at 0.1.7 (#122823)
2021-05-19 22:37:49 +02:00
opensmtpd-rspamd = handleTest ./opensmtpd-rspamd.nix {};
nixos/opensnitch: add test
2023-08-08 22:00:52 +02:00
opensnitch = handleTest ./opensnitch.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
openssh = handleTest ./openssh.nix {};
octoprint: add nixosTests Signed-off-by: Florian Brandes <florian.brandes@posteo.de> Co-authored-by: Nick Cao <nickcao@nichi.co>
2023-01-28 20:02:15 +01:00
octoprint = handleTest ./octoprint.nix {};
Rename `novaImage` to `openstackImage` People don't necessary know `nova` is related to Openstack (it is a component of Openstack). So, it is more explicit to call it `openstackImage`.
2019-01-28 15:09:48 +01:00
openstack-image-metadata = (handleTestOn ["x86_64-linux"] ./openstack-image.nix {}).metadata or {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
openstack-image-userdata = (handleTestOn ["x86_64-linux"] ./openstack-image.nix {}).userdata or {};
nixos/opentabletdriver: add tests
2021-01-08 13:48:00 -03:00
opentabletdriver = handleTest ./opentabletdriver.nix {};
nixos/opentelemetry-collector: add nixosTest (cherry picked from commit a45a1a51e57eff974922b19d80b77ff0c23771f0) Signed-off-by: Domen Kožar <domen@dev.si>
2023-05-09 11:31:47 -06:00
opentelemetry-collector = handleTest ./opentelemetry-collector.nix {};
nixos/open-web-calendar: init module
2024-09-16 16:37:49 +02:00
open-web-calendar = handleTest ./web-apps/open-web-calendar.nix {};
nixosTests.ocsinventory-agent: init
2023-11-02 01:28:20 +01:00
ocsinventory-agent = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./ocsinventory-agent.nix {};
nixos/owncast: init owncast service
2021-09-23 10:48:29 +02:00
owncast = handleTest ./owncast.nix {};
outline: add nixos test
2023-05-17 13:10:57 +02:00
outline = handleTest ./outline.nix {};
nixosTests.image-contents: init
2020-12-20 21:18:54 +01:00
image-contents = handleTest ./image-contents.nix {};
nixosTests.openvscode-server: init
2023-05-15 15:33:37 +02:00
openvscode-server = handleTest ./openvscode-server.nix {};
nixos/open-webui: init
2024-06-04 16:07:06 +05:30
open-webui = runTest ./open-webui.nix;
openvswitch: init simple bridge test and add incus test
2024-09-26 09:26:10 -04:00
openvswitch = runTest ./openvswitch.nix;
nixos/orangefs: add test
2019-08-21 00:27:14 +02:00
orangefs = handleTest ./orangefs.nix {};
mention the os-prober test in pkgs.os-prober.passthru.tests
2019-06-09 20:26:05 +02:00
os-prober = handleTestOn ["x86_64-linux"] ./os-prober.nix {};
nixos/tests/osquery: init
2023-07-19 11:59:22 +02:00
osquery = handleTestOn ["x86_64-linux"] ./osquery.nix {};
nixos/tests: add osrm-backend test
2019-01-05 13:13:10 +01:00
osrm-backend = handleTest ./osrm-backend.nix {};
nixos/overlayfs: add test
2019-01-23 10:19:23 +01:00
overlayfs = handleTest ./overlayfs.nix {};
nixos/tests/pacemaker: init
2022-03-08 02:46:26 +01:00
pacemaker = handleTest ./pacemaker.nix {};
nixos/packagekit: add test
2019-04-24 16:45:29 +08:00
packagekit = handleTest ./packagekit.nix {};
tests: Move all PAM tests into a separate directory As per <https://github.com/NixOS/nixpkgs/pull/146467#issuecomment-972743535>.
2021-11-27 21:04:28 +13: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 {};
nixos/pam: add support for pam-ussh pam-ussh allows authorizing using an SSH certificate stored in your SSH agent, in a similar manner to pam-ssh-agent-auth, but for certificates rather than raw public keys.
2022-03-13 17:20:23 +00:00
pam-ussh = handleTest ./pam/pam-ussh.nix {};
nixos/pam: add test for ZFS home dataset unlocking
2023-05-14 21:30:01 +02:00
pam-zfs-key = handleTest ./pam/zfs-key.nix {};
pass-secret-service: unstable-2020-04-12 -> unstable-2022-03-21 * Update to the latest upstream version of pass-secret-service that includes systemd service files. * Add patch to fix use of a function that has been removed from the Python Cryptography library in NixOS 22.05 * Install systemd service files in the Nix package. * Add NixOS test to ensure the D-Bus API activates the service unit. * Add myself as a maintainer to the package and NixOS test. * Use checkTarget instead of equivalent custom checkPhase.
2022-04-16 17:18:57 +12:00
pass-secret-service = handleTest ./pass-secret-service.nix {};
nixos/patroni: only run tests on x86_64-linux etcd doesn't support other architectures and refuses to start
2022-11-23 18:53:04 +01:00
patroni = handleTestOn ["x86_64-linux"] ./patroni.nix {};
nixos/pantalaimon: add test Co-authored-by: sumnerevans <me@sumnerevans.com>
2021-05-30 17:32:41 +02:00
pantalaimon = handleTest ./matrix/pantalaimon.nix {};
nixos/tests/all-tests.nix: add pantheon
2019-01-24 17:33:05 -05:00
pantheon = handleTest ./pantheon.nix {};
nixosTests.pantheon-wayland: init It is unclear to me how to properly start apps so I am using autostart here.
2025-01-08 22:09:41 +08:00
pantheon-wayland = handleTest ./pantheon-wayland.nix {};
nixos/paperless-ng: rename to `paperless`, use `paperless-ngx` package Use this opportunity to rename `paperless-(ng)-server` to `paperless-scheduler`. This follows the naming scheme in the paperless repo and docs.
2022-04-12 17:48:53 +02:00
paperless = handleTest ./paperless.nix {};
nixos/parsedmarc: Add test
2021-06-02 18:19:37 +02:00
parsedmarc = handleTest ./parsedmarc {};
nixos/tests: Add two new tests for password option override ordering This commit adds two new tests to show that the ordering of password overrides documentation in nixos/modules/config/user-groups.nix is correct. The override behavior differs depending on whether a system has systemd-sysusers enabled, so there are two tests.
2024-12-15 12:22:02 +08:00
password-option-override-ordering = handleTest ./password-option-override-ordering.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
pdns-recursor = handleTest ./pdns-recursor.nix {};
pds: add NixOS test
2024-11-09 20:46:47 -07:00
pds = handleTest ./pds.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
peerflix = handleTest ./peerflix.nix {};
nixos/tests/peering-manager: init
2022-12-01 17:32:15 +01:00
peering-manager = handleTest ./web-apps/peering-manager.nix {};
nixos/tests: add peertube test
2021-05-31 14:23:06 +03:00
peertube = handleTestOn ["x86_64-linux"] ./web-apps/peertube.nix {};
nixos/peroxide: add module for peroxide service
2023-01-04 11:05:34 +13:00
peroxide = handleTest ./peroxide.nix {};
pgadmin4: init at 6.3 Signed-off-by: Florian Brandes <florian.brandes@posteo.de>
2021-07-02 14:22:12 +02:00
pgadmin4 = handleTest ./pgadmin4.nix {};
nixos/pgbouncer: init (#241578) Co-authored-by: Marek Mahut <marek.mahut@gmail.com>
2023-07-22 12:49:23 +02:00
pgbouncer = handleTest ./pgbouncer.nix {};
nixos/pghero: init
2023-11-23 13:59:27 +03:00
pghero = runTest ./pghero.nix;
pgweb: add NixOS test I maintain this package and I'd llike to be able to merge minor version bumps without having to manually test the package. refs https://github.com/Thaigersprint/thaigersprint-2025/issues/1
2025-02-15 15:54:40 +07:00
pgweb = runTest ./pgweb.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
pgmanage = handleTest ./pgmanage.nix {};
nixos/tests/phosh: init
2022-08-02 12:34:37 -07:00
phosh = handleTest ./phosh.nix {};
nixos/tests/photonvision: init
2024-02-05 23:51:17 -08:00
photonvision = handleTest ./photonvision.nix {};
nixos/photoprism: add test
2023-01-15 00:16:35 +01:00
photoprism = handleTest ./photoprism.nix {};
nixos/php: Add tests for phpfpm This test checks that we evaluate PHP properly and that certain extensions are actually loaded.
2020-03-30 22:07:05 +02:00
php = handleTest ./php {};
php81: init at 8.1.1
2021-11-25 21:38:19 +01:00
php81 = handleTest ./php { php = pkgs.php81; };
php82: init at 8.2.0rc6
2022-11-13 21:14:38 +01:00
php82 = handleTest ./php { php = pkgs.php82; };
php83: init at 8.3.0alpha2 (#239151) * php83: init at 8.3.0alpha2 * phpExtensions.blackfire: disable for php 8.3 * phpExtensions.apcu: patch for 8.3 only
2023-06-26 20:51:23 +02:00
php83 = handleTest ./php { php = pkgs.php83; };
php84: init at 8.4.0alpha4 https://github.com/php/php-src/blob/php-8.4.0alpha4/NEWS Announcements: - alpha1 https://www.php.net/archive/2024.php#2024-07-05-1 - imap and pspell moved to PECL - alpha3 https://www.php.net/archive/2024.php#2024-07-18-1 - alpha4 https://www.php.net/archive/2024.php#2024-08-01-3 Co-authored-by: Jan Tojnar <jtojnar@gmail.com>
2024-07-05 16:36:46 +02:00
php84 = handleTest ./php { php = pkgs.php84; };
nixos/tests: add phlactery
2022-06-29 04:17:38 +09:00
phylactery = handleTest ./web-apps/phylactery.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
pict-rs = handleTest ./pict-rs.nix {};
nixos/pingvin-share: add nixos test
2024-02-09 20:06:25 +01:00
pingvin-share = handleTest ./pingvin-share.nix {} ;
nixos/tests/pinnwand: init
2020-06-03 23:12:06 +02:00
pinnwand = handleTest ./pinnwand.nix {};
nixosTests.plantuml-server: init
2023-11-14 23:09:23 +01:00
plantuml-server = handleTest ./plantuml-server.nix {};
nixos/plasma5: add very basic plasma-bigscreen module
2022-09-17 16:02:37 +03:00
plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
plasma5 = handleTest ./plasma5.nix {};
nixos/tests: add plasma6
2024-02-05 19:04:04 +03:00
plasma6 = handleTest ./plasma6.nix {};
nixosTest/plasma5-systemd-start: init
2021-11-01 04:34:10 +08:00
plasma5-systemd-start = handleTest ./plasma5-systemd-start.nix {};
plausible: init at 1.3.0
2021-05-21 23:15:23 +02:00
plausible = handleTest ./plausible.nix {};
tests/playwright-python: init For some reason, chromium, which is still the nixpkgs version hangs inside the normal test vm, while working fine in .driverInteractive. I suspect that might have to do with the existence of a display in .driverInteractive. Neither vm does run X11 or wayland.
2024-09-13 11:20:01 +02:00
playwright-python = handleTest ./playwright-python.nix {};
nixos/please: init module Co-authored-by: Cole Helbling <cole.e.helbling@outlook.com>
2022-09-30 00:12:29 +03:00
please = handleTest ./please.nix {};
nixos/pleroma: add NixOS VM test.
2020-11-08 15:10:14 +01:00
pleroma = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./pleroma.nix {};
nixos/tests: new test for plikd
2020-11-13 15:00:34 +01:00
plikd = handleTest ./plikd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
plotinus = handleTest ./plotinus.nix {};
nixos/tests/podgrab: init
2021-04-14 17:15:41 +00:00
podgrab = handleTest ./podgrab.nix {};
nixosTests.podman*: enable on aarch64-linux
2022-09-24 15:58:15 +10:00
podman = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/default.nix {};
podman-tls-ghostunnel = handleTestOn ["aarch64-linux" "x86_64-linux"] ./podman/tls-ghostunnel.nix {};
nixos/polaris: init
2022-06-17 20:04:54 +02:00
polaris = handleTest ./polaris.nix {};
nixos/tests/pomerium: init
2021-01-08 03:03:00 +00:00
pomerium = handleTestOn ["x86_64-linux"] ./pomerium.nix {};
nixos/tests: init portunus
2023-05-21 18:53:52 +02:00
portunus = handleTest ./portunus.nix { };
postfix: Add submissions option for postfix and test (#91691) RFC 8314 suggests, for end user submission of mails, SMTP over TLS on port 465 should be used. Closes #91690
2020-07-06 03:37:56 +02:00
postfix = handleTest ./postfix.nix {};
postfix-raise-smtpd-tls-security-level = handleTest ./postfix-raise-smtpd-tls-security-level.nix {};
postfixadmin: init at 3.3.9
2021-05-18 23:34:03 -05:00
postfixadmin = handleTest ./postfixadmin.nix {};
nixosTests.postgresql: move all postgresql related nixosTests into one folder This makes it possible to run all those tests at once by building nixosTests.postgresql and allow a simple entry to ci/OWNERS for all tests.
2024-11-02 18:58:52 +01:00
postgresql = handleTest ./postgresql {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
powerdns = handleTest ./powerdns.nix {};
powerdns-admin: fix and add module - Add the migrations directory to the package - Add postgres support to the package - Add a service for powerdns-admin Co-authored-by: Zhaofeng Li <hello@zhaofeng.li>
2021-12-17 10:33:40 +01:00
powerdns-admin = handleTest ./powerdns-admin.nix {};
nixosTests.power-profiles-daemon: add to all-tests.nix This was forgotten in the inital PR.
2021-10-29 06:15:27 +02:00
power-profiles-daemon = handleTest ./power-profiles-daemon.nix {};
nixos/tests/pppd: init This test creates a PPPoE link between two machines, and verifies that the machines can ping each other.
2019-10-14 21:26:54 -07:00
pppd = handleTest ./pppd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
predictable-interface-names = handleTest ./predictable-interface-names.nix {};
nixos/tests/pretalx: init
2023-05-13 17:36:03 +02:00
pretalx = runTest ./web-apps/pretalx.nix;
nixos/tests/pretix: init
2024-03-14 12:43:39 +01:00
pretix = runTest ./web-apps/pretix.nix;
nixos/tests/printing: test cases for domain socket only config Add two new vm tests for the printing configuration that test `listenAddresses = []`, i.e., the situation where cups only listens on the unix domain socket `/run/cups/cups.sock`. This helps catching bugs like this: https://github.com/OpenPrinting/cups/issues/985 https://github.com/NixOS/nixpkgs/pull/337748
2024-08-29 15:12:56 +02:00
printing-socket = handleTest ./printing.nix { socket = true; listenTcp = true; };
printing-service = handleTest ./printing.nix { socket = false; listenTcp = true; };
printing-socket-notcp = handleTest ./printing.nix { socket = true; listenTcp = false; };
printing-service-notcp = handleTest ./printing.nix { socket = false; listenTcp = false; };
nixos/private-gpt: init
2024-04-24 15:15:25 +02:00
private-gpt = handleTest ./private-gpt.nix {};
nixos/tests/privatebin: init
2024-09-29 22:57:42 +05:30
privatebin = runTest ./privatebin.nix;
nixos/tests/privoxy: add test
2021-03-03 17:18:09 +01:00
privoxy = handleTest ./privoxy.nix {};
nixos/prometheus: Added simple two Prometheus server testcase
2024-06-02 00:06:14 +01:00
prometheus = handleTest ./prometheus {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
prometheus-exporters = handleTest ./prometheus-exporters.nix {};
nixos/tests: move ejabberd and prosody test to xmpp folder
2019-06-15 12:16:28 +03:00
prosody = handleTest ./xmpp/prosody.nix {};
nixos/tests/prosody: return prosody-mysql test
2022-02-18 22:19:31 +03:00
prosody-mysql = handleTest ./xmpp/prosody-mysql.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
proxy = handleTest ./proxy.nix {};
nixos/tests/prowlarr: init
2021-10-10 08:54:22 -07:00
prowlarr = handleTest ./prowlarr.nix {};
pt2-clone: add nixos test
2020-07-29 19:00:33 +02:00
pt2-clone = handleTest ./pt2-clone.nix {};
pykms: switch to maintained fork, fix PYTHONPATH, add test I have read the full diff[0] between the previous owner and the new maintained fork that I'm switching to, and could not find any suspicious code. The new fork includes fixes that are otherwise crashing as of Python 3.10. This commit also fixes the PYTHONPATH which prevents the client from starting. This commit also adds a test that the client can successfully query the server, testing the two components at once. [0] https://github.com/SystemRage/py-kms/compare/master...Py-KMS-Organization:master
2022-06-27 00:20:04 +02:00
pykms = handleTest ./pykms.nix {};
nixos/public-inbox: add tests
2021-12-01 11:06:18 +01:00
public-inbox = handleTest ./public-inbox.nix {};
nixos/pufferpanel: init
2023-04-07 09:34:25 +03:00
pufferpanel = handleTest ./pufferpanel.nix {};
nixosTests.pulseAudio: init
2021-11-30 14:51:06 +01:00
pulseaudio = discoverTests (import ./pulseaudio.nix);
nixos/qemu-vm: add option to use a non-standard BIOS I'd like to change the default on x86 platforms to qboot at some point, since it saves a fair bit of startup time.
2020-05-22 15:15:32 +12:00
qboot = handleTestOn ["x86_64-linux" "i686-linux"] ./qboot.nix {};
nixos/tests: add qemu-vm-restrictnetwork test
2023-01-12 19:50:27 +01:00
qemu-vm-restrictnetwork = handleTest ./qemu-vm-restrictnetwork.nix {};
nixos/tests/qemu-vm-volatile-root: init
2023-06-21 01:38:27 +02:00
qemu-vm-volatile-root = runTest ./qemu-vm-volatile-root.nix;
nixos/qemu-vm: optionally disable overriding fileSystems Allow the user to disable overriding the fileSystems option with virtualisation.fileSystems by setting `virtualisation.fileSystems = lib.mkForce { };`. With this change you can use the qemu-vm module to boot from an external image that was not produced by the qemu-vm module itself. The user can now re-use the modularly set fileSystems option instead of having to reproduce it in virtualisation.fileSystems.
2023-06-21 00:19:21 +02:00
qemu-vm-external-disk-image = runTest ./qemu-vm-external-disk-image.nix;
nixos/tests/qemu-vm-store: init
2024-02-23 00:00:37 +01:00
qemu-vm-store = runTest ./qemu-vm-store.nix;
qgis: add server support
2024-09-16 12:51:21 +02:00
qgis = handleTest ./qgis.nix { package = pkgs.qgis; };
qgis-ltr = handleTest ./qgis.nix { package = pkgs.qgis-ltr; };
qownnotes: add tests
2023-06-16 08:19:47 +02:00
qownnotes = handleTest ./qownnotes.nix {};
nixos/tests/qtile: test extraPackages and qtile-extras
2024-05-31 16:25:21 +02:00
qtile = handleTestOn ["x86_64-linux" "aarch64-linux"] ./qtile/default.nix {};
qgis: add nixos tests Add NixOS test for QGIS and QGIS-LTR. This test creates QGIS vector memory layer containing Nix snowflake. This proves that application can successfully start and Python bindings are working. By default, Python script is executed in non-interactive mode and QGIS is closed after script is finished. This script can be also executed interactively by running following command: ``` nix-build -A qgis QGIS_TEST_INTERACTIVE=True ./result/bin/qgis --code pkgs/applications/gis/qgis/test.py ``` In this case, QGIS is not automatically closed.
2023-08-28 17:59:16 +02:00
quake3 = handleTest ./quake3.nix {};
nixos/quicktun: add test
2023-11-01 19:48:51 +01:00
quicktun = handleTest ./quicktun.nix {};
nixos/quickwit: Added testcase
2024-06-04 22:39:48 +01:00
quickwit = handleTest ./quickwit.nix {};
qgis: add nixos tests Add NixOS test for QGIS and QGIS-LTR. This test creates QGIS vector memory layer containing Nix snowflake. This proves that application can successfully start and Python bindings are working. By default, Python script is executed in non-interactive mode and QGIS is closed after script is finished. This script can be also executed interactively by running following command: ``` nix-build -A qgis QGIS_TEST_INTERACTIVE=True ./result/bin/qgis --code pkgs/applications/gis/qgis/test.py ``` In this case, QGIS is not automatically closed.
2023-08-28 17:59:16 +02:00
quorum = handleTest ./quorum.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
rabbitmq = handleTest ./rabbitmq.nix {};
nixos/radarr: Add test for radarr to ensure startup
2019-01-24 23:09:21 +01:00
radarr = handleTest ./radarr.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
radicale = handleTest ./radicale.nix {};
nixos/radicle: init services
2024-05-25 02:23:48 +02:00
radicle = runTest ./radicle.nix;
ragnarwm: init at 1.3.1
2023-08-08 11:53:51 +02:00
ragnarwm = handleTest ./ragnarwm.nix {};
nixosTests.rasdaemon: init module test and passthru test in the package
2021-02-02 01:39:50 +01:00
rasdaemon = handleTest ./rasdaemon.nix {};
nixos/rathole: init module Adds a module for rathole package. The package itself and this module is very similar to frp, so the options and tests are not very far off from those for frp.
2024-07-28 01:25:01 +03:00
rathole = handleTest ./rathole.nix {};
readarr: init at 0.1.4.1596
2023-03-12 20:54:23 +01:00
readarr = handleTest ./readarr.nix {};
nixosTests.realm: init
2024-01-28 12:56:32 +08:00
realm = handleTest ./realm.nix {};
nixos/readeck: init
2025-01-02 21:09:06 +01:00
readeck = runTest ./readeck.nix;
nixos/redis: add test
2019-08-31 20:17:33 +02:00
redis = handleTest ./redis.nix {};
redlib.tests: fix eval Without the change the eval fails as: $ nix build --no-link -f. redlib.tests error: attribute 'redlib' missing at pkgs/by-name/re/redlib/package.nix:50:26: 49| passthru.tests = { 50| inherit (nixosTests) redlib; | ^ 51| }; Did you mean redis?
2024-04-22 07:31:53 +01:00
redlib = handleTest ./redlib.nix {};
nixos/tests/redmine: Limit architectures to supported ones In order to avoid unnecessary CI errors regarding unsupported architectures, limit the target architectures to the supported ones by the Redmine package. Signed-off-by: Felix Singer <felixsinger@posteo.net>
2024-10-13 03:32:49 +02:00
redmine = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./redmine.nix {};
nixosTests.renovate: init vm test
2024-06-08 17:56:52 +02:00
renovate = handleTest ./renovate.nix {};
replaceDependencies: add tests The tests cannot be directly built by Hydra, because replaceDependencies relies on IFD. Instead, they are put inside a NixOS test where they are built on the guest.
2023-12-16 19:02:17 +01:00
replace-dependencies = handleTest ./replace-dependencies {};
nixos/switch-to-configuration: Allow activation scripts to restart units The primary use case is tools like sops-nix and agenix to restart units when secrets change. There's probably other reasons to restart units as well and a nice thing to have in general.
2021-09-08 21:02:28 +02:00
restartByActivationScript = handleTest ./restart-by-activation-script.nix {};
restic-rest-server: add nixos test
2024-03-16 07:27:14 +01:00
restic-rest-server = handleTest ./restic-rest-server.nix {};
nixos/tests/restic.nix: add test
2020-01-30 16:31:52 -05:00
restic = handleTest ./restic.nix {};
nixos/retroarch: add RetroArch as a desktop session
2022-02-05 00:50:11 +01:00
retroarch = handleTest ./retroarch.nix {};
nixos/tests/rke2: add tests for single-node and multi-node For multi-node test, create a 3-node cluster (2 server nodes and 1 agent node) to test the connection between nodes. Setup `passthru.tests`.
2024-05-11 06:50:27 +02:00
rke2 = handleTestOn ["aarch64-linux" "x86_64-linux"] ./rke2 {};
nixos/rkvm: add nixos test
2023-10-05 14:32:38 +02:00
rkvm = handleTest ./rkvm {};
nixos/tests/rmfakecloud: new test
2024-11-18 22:56:12 +09:00
rmfakecloud = runTest ./rmfakecloud.nix;
nixos/tests/robustirc-bridge: init
2020-08-30 18:31:54 +02:00
robustirc-bridge = handleTest ./robustirc-bridge.nix {};
roundcube: apply code review suggestions
2018-11-28 17:33:26 +01:00
roundcube = handleTest ./roundcube.nix {};
nixos/routinator: init module
2025-02-07 09:21:45 +01:00
routinator = handleTest ./routinator.nix {};
rosenpass: refactor, add module and test (#254813)
2023-10-23 19:29:30 +02:00
rosenpass = handleTest ./rosenpass.nix {};
nixos/tests/rshim: init
2023-05-15 14:09:28 +02:00
rshim = handleTest ./rshim.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
rspamd = handleTest ./rspamd.nix {};
nixos/rspamd-trainer: init; rspamd-trainer: init at unstable-2023-11-27
2023-10-18 11:47:00 +02:00
rspamd-trainer = handleTest ./rspamd-trainer.nix {};
nixosTests/rss-bridge: improve and add caddy
2025-02-03 22:25:20 +01:00
rss-bridge = handleTest ./web-apps/rss-bridge {};
rss2email module: init Also adding `system-sendmail` package for sharing the code with other modules or packages needing it.
2018-10-27 18:33:43 +09:00
rss2email = handleTest ./rss2email.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
rstudio-server = handleTest ./rstudio-server.nix {};
rsyncd = handleTest ./rsyncd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
rsyslogd = handleTest ./rsyslogd.nix {};
nixos/rtkit: Add tests
2024-04-24 16:09:06 +08:00
rtkit = runTest ./rtkit.nix;
nixos/rtorrent: add NixOS tests
2024-06-23 20:38:41 -03:00
rtorrent = handleTest ./rtorrent.nix {};
nixos/tests/rustls-libssl: init
2024-12-10 14:53:02 +01:00
rustls-libssl = handleTest ./rustls-libssl.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
rxe = handleTest ./rxe.nix {};
sabnzbd: add simple test
2021-09-21 13:38:22 +02:00
sabnzbd = handleTest ./sabnzbd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
samba = handleTest ./samba.nix {};
nixos/tests/samba-wsdd: add check WSD Discovery
2020-11-23 17:13:22 +03:00
samba-wsdd = handleTest ./samba-wsdd.nix {};
nixos/sane: add nixos test
2024-01-01 12:00:00 +00:00
sane = handleTest ./sane.nix {};
nixos/sanoid, nixos/syncoid: init module and test
2019-10-26 23:37:30 -04:00
sanoid = handleTest ./sanoid.nix {};
nixos/saunafs: add module + test
2024-10-03 11:39:24 +02:00
saunafs = handleTest ./saunafs.nix {};
scaphandre: init at 0.5.0 (#238462) * scaphandre: init at 0.5.0 * Update pkgs/servers/scaphandre/default.nix --------- Co-authored-by: Pol Dellaiera <pol.dellaiera@protonmail.com>
2023-06-26 19:41:28 +02:00
scaphandre = handleTest ./scaphandre.nix {};
nixos/schleuder: init module and accompanying test Co-Authored-By: Martin Weinelt <hexa@darmstadt.ccc.de> Co-Authored-By: Cole Helbling <cole.helbling@determinate.systems>
2022-05-31 17:27:54 +02:00
schleuder = handleTest ./schleuder.nix {};
nixos/scion: init
2024-03-24 21:03:03 +00:00
scion-freestanding-deployment = handleTest ./scion/freestanding-deployment {};
nixosTests.scrutiny: init
2024-02-19 09:47:18 +00:00
scrutiny = handleTest ./scrutiny.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
sddm = handleTest ./sddm.nix {};
sdl3: init at 3.1.8
2024-12-14 06:44:37 -04:00
sdl3 = handleTest ./sdl3.nix { };
nixosTests.seafile: link the committed test It succeeds for me. Apparently this line was forgotten in PR #119719.
2021-11-07 09:05:36 +01:00
seafile = handleTest ./seafile.nix {};
nixos/searx: switch from `handleTest` to `runTests`
2024-06-19 07:04:30 +02:00
searx = runTest ./searx.nix;
nixos/tests/seatd: init
2023-08-25 10:59:57 +05:30
seatd = handleTest ./seatd.nix {};
nixos/send: init
2024-10-26 01:50:55 +08:00
send = runTest ./send.nix;
nixos/service-runner.nix: Allow quotes in commands + test
2020-02-28 12:17:01 +01:00
service-runner = handleTest ./service-runner.nix {};
nixos/tests/servo: init
2025-02-20 03:00:31 +01:00
servo = runTest ./servo.nix;
tests/shadps4: init
2024-12-10 11:55:20 +01:00
shadps4 = runTest ./shadps4.nix;
nixos/tests/sftpgo: init
2023-04-19 13:13:54 +00:00
sftpgo = runTest ./sftpgo.nix;
sfxr-qt: add nixos test
2022-03-20 22:39:04 +01:00
sfxr-qt = handleTest ./sfxr-qt.nix {};
sgt-puzzles: rename all "sgtpuzzles" -> "sgt-puzzles" nixpkgs currently mixes sgtpuzzles/sgt-puzzles across filenames, packages, tests. This inconsistency is frequently annoying. Let's unify on "sgt-puzzles", on the basis that: * "sgt-puzzles" is the package filename. * Alpine/FreeBSD/Debian use "sgt-puzzles". No other distro uses "sgtpuzzles". https://repology.org/project/sgt-puzzles/versions
2023-10-06 21:36:48 +11:00
sgt-puzzles = handleTest ./sgt-puzzles.nix {};
shadow: Add test
2020-12-23 13:28:30 -05:00
shadow = handleTest ./shadow.nix {};
nixos/shadowsocks: add test without plugin
2020-09-09 10:15:59 +12:00
shadowsocks = handleTest ./shadowsocks {};
shattered-pixel-dungeon: add nixos test
2020-08-09 15:20:17 +02:00
shattered-pixel-dungeon = handleTest ./shattered-pixel-dungeon.nix {};
nixos/tests: add shiori to all-tests.nix
2019-11-08 18:17:08 +01:00
shiori = handleTest ./shiori.nix {};
nixosTests.signal-desktop: add test
2019-05-23 00:50:51 +02:00
signal-desktop = handleTest ./signal-desktop.nix {};
nixosTests.silverbullet: init
2024-03-16 17:12:16 +01:00
silverbullet = handleTest ./silverbullet.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
simple = handleTest ./simple.nix {};
nixos/sing-box: add basic test
2023-06-27 12:58:10 +08:00
sing-box = handleTest ./sing-box.nix {};
nixos/slimserver: init service test
2023-11-04 21:43:15 -04:00
slimserver = handleTest ./slimserver.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
slurm = handleTest ./slurm.nix {};
nixos/snmpd: add nixos test
2023-12-02 16:05:57 +02:00
snmpd = handleTest ./snmpd.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
smokeping = handleTest ./smokeping.nix {};
nixos/tests: add snapcast Checks - if all configured ports are listened on - if all pipes for multiple streams get set up - if rpc interaction is possible
2020-07-28 14:47:36 +02:00
snapcast = handleTest ./snapcast.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
snapper = handleTest ./snapper.nix {};
nixos/tests/snipe-it: init (#180772)
2023-04-26 17:46:15 +02:00
snipe-it = runTest ./web-apps/snipe-it.nix;
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
soapui = handleTest ./soapui.nix {};
nixos/soft-serve: init This adds a NixOS module for Soft Serve, a tasty, self-hostable Git server for the command line. The module has a test that checks some basic things like creating users, creating a repo and cloning it. Co-authored-by: Sandro <sandro.jaeckel@gmail.com>
2023-07-08 01:44:42 +02:00
soft-serve = handleTest ./soft-serve.nix {};
nixosTests.sogo: init test
2020-05-12 18:32:39 +02:00
sogo = handleTest ./sogo.nix {};
nixos/soju: add tests For now, just try creating a user with sojuctl. Actually connecting an irc client is pretty annoying.
2023-10-01 17:56:37 -07:00
soju = handleTest ./soju.nix {};
nixos/solanum: init
2021-05-20 22:03:39 +02:00
solanum = handleTest ./solanum.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
sonarr = handleTest ./sonarr.nix {};
nixosTests.sonic-server: init
2023-11-10 14:52:15 +01:00
sonic-server = handleTest ./sonic-server.nix {};
nixosTests.sourcehut: split tests belonging to different services
2023-12-25 03:49:11 +01:00
sourcehut = handleTest ./sourcehut {};
nixos/spacecookie: add service module and test
2019-05-24 21:17:51 +02:00
spacecookie = handleTest ./spacecookie.nix {};
spark: init 3.2.1 and test on aarch64-linux
2022-02-08 08:59:23 -05:00
spark = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./spark {};
nixos/tests/spiped: init
2024-10-21 18:34:20 +11:00
spiped = runTest ./spiped.nix;
sqlite3-to-mysql: init at 1.4.16 Signed-off-by: Florian Brandes <florian.brandes@posteo.de>
2022-11-13 20:13:15 +01:00
sqlite3-to-mysql = handleTest ./sqlite3-to-mysql.nix {};
squid: add test
2025-01-27 12:10:54 +01:00
squid = handleTest ./squid.nix {};
nixos: add test for sslh
2020-01-18 12:00:00 +00:00
sslh = handleTest ./sslh.nix {};
nixosTests.ssh-agent-auth: init
2023-11-08 20:47:33 +00:00
ssh-agent-auth = handleTest ./ssh-agent-auth.nix {};
ssh-audit: add test of audited configuration On current nixpkgs, no modifications to the server settings were necessary to pass the audit. However, some of the client algorithms were considered insecure. The client configuration lists all algorithms which were listed as acceptable by `ssh-audit`. This can be used as an example of a configuration currently considered acceptable by `ssh-audit`, and verifies that such a configuration results in a compatible client/server configuration. Beware that this test will continue passing when future versions of `ssh-audit` add support for new algorithms. In other words, the example configuration represents a subset of what the current version of `ssh-audit` would consider acceptable.
2023-10-16 21:31:39 +13:00
ssh-audit = handleTest ./ssh-audit.nix {};
nixosTests.sssd: add aarch64-linux platform
2023-10-18 18:25:11 +02:00
sssd = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd.nix {};
sssd-ldap = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./sssd-ldap.nix {};
nixos/stalwart-mail: add vm test
2023-09-02 20:27:11 +02:00
stalwart-mail = handleTest ./stalwart-mail.nix {};
nixos/stargazer: init
2023-04-16 19:24:06 -04:00
stargazer = runTest ./web-servers/stargazer.nix;
nixos/starship: add a test
2021-12-24 11:24:29 +00:00
starship = handleTest ./starship.nix {};
nixos/stash: init
2024-12-24 15:27:25 -08:00
stash = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./stash.nix {};
nixos/static-web-server: create module which uses upstream systemd units This commit creates a nixos module for static-web-server. The module uses upstream systemd units to start static-web-server. It also includes options for configuring static-web-server.
2023-07-01 12:17:39 -04:00
static-web-server = handleTest ./web-servers/static-web-server.nix {};
nixos/tests: add step-ca test
2021-11-12 21:37:11 +01:00
step-ca = handleTestOn ["x86_64-linux"] ./step-ca.nix {};
nixos/stratis: add test for simple usecases
2022-09-12 15:18:11 +08:00
stratis = handleTest ./stratis {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
strongswan-swanctl = handleTest ./strongswan-swanctl.nix {};
nixos/stub-ld: init module
2023-11-23 22:03:03 -05:00
stub-ld = handleTestOn [ "x86_64-linux" "aarch64-linux" ] ./stub-ld.nix {};
nixos/tests/stunnel: init
2022-02-22 14:08:43 -08:00
stunnel = handleTest ./stunnel.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
sudo = handleTest ./sudo.nix {};
nixos/sudo: Add tests for sudo-rs too Duplicated sudo's testsuite for now, as its maintainer does not with to collaborate on testing effors; see #253876. Environment-related tests were removed, as sudo-rs does not support `(NO)SETENV` yet; see memorysafety/sudo-rs#760
2023-09-07 15:53:18 +00:00
sudo-rs = handleTest ./sudo-rs.nix {};
nixos/sunshine: init
2024-03-30 20:07:35 -05:00
sunshine = handleTest ./sunshine.nix {};
nixos/suricata: init module
2024-05-22 14:45:16 +02:00
suricata = handleTest ./suricata.nix {};
nixos/suwayomi-server: add nixos tests
2024-01-18 22:11:16 +01:00
suwayomi-server = handleTest ./suwayomi-server.nix {};
nixos/tests/swap-file-btrfs: init
2022-10-04 11:08:46 +08:00
swap-file-btrfs = handleTest ./swap-file-btrfs.nix {};
nixos/tests: add swap-partition test
2022-06-22 04:11:23 +02:00
swap-partition = handleTest ./swap-partition.nix {};
nixos/config/swap: improve randomEncrytion * add sector size parameter to swap randomEncryption * add key size parameter to swap randomEncryption * allow deviceName to be overridden for encrypted swap * create test for swap random encryption * update release notes
2023-05-03 16:11:45 -04:00
swap-random-encryption = handleTest ./swap-random-encryption.nix {};
nixos/swapspace: add tests Signed-off-by: phanirithvij <phanirithvij2000@gmail.com>
2024-10-27 01:22:53 +05:30
swapspace = handleTestOn ["aarch64-linux" "x86_64-linux"] ./swapspace.nix {};
nixos/tests/{sway,cage,cagebreak}: Fix the tests on aarch64-linux Since the update to wlroots 0.13 (e03dde82a74) the default VGA card isn't supported anymore and we needed to switch to virtio (qxl didn't work either). However, as it turned out "-vga virtio" (28b8cff301f) broke the test on AArch64. Luckily there's a third option that works on all three supported platforms: virtio-gpu-pci According to [0] "This device lacks VGA compatibility mode but is otherwise identical to the virtio vga device. UEFI firmware can handle this, and if your guests has drivers too you can use this instead of virtio-vga. This will reduce the attack surface (no complex VGA emulation support) and reduce the memory footprint by 8 MB (no pci memory bar for VGA compatibility). This device can be placed in a PCI Express slot." So in the end this seems like the ideal choice :) See also [1]. [0]: https://www.kraxel.org/blog/2019/09/display-devices-in-qemu/#virtio-gpu-pci [1]: https://patches.openembedded.org/patch/164351/
2021-05-27 20:37:24 +02:00
sway = handleTest ./sway.nix {};
swayfx-unwrapped: add basic nixos test
2024-04-29 15:47:59 -04:00
swayfx = handleTest ./swayfx.nix {};
nixos/switch-test: use the runTest handler to improve eval performance The newer runTest handler uses a single nixpkgs instance to eval all the specialisations, reducing the memory usage and eval time of the test drastically compared to handleTest which creates a new nixpkgs instance for every specialisation.
2024-12-11 09:38:55 +01:00
switchTest = runTest {
imports = [ ./switch-test.nix ];
defaults.system.switch.enableNg = false;
};
switchTestNg = runTest {
imports = [ ./switch-test.nix ];
defaults.system.switch.enableNg = true;
};
nixos/tests/sx: init
2024-08-10 15:17:06 +01:00
sx = handleTest ./sx.nix {};
nixos/sympa: init module
2019-07-06 20:56:30 +02:00
sympa = handleTest ./sympa.nix {};
nixos/tests: Add test for syncthing
2020-07-23 00:13:26 -07:00
syncthing = handleTest ./syncthing.nix {};
nixosTests.syncthing-no-settings: init
2023-05-23 16:58:38 +03:00
syncthing-no-settings = handleTest ./syncthing-no-settings.nix {};
nixos/syncthing: add options for declarative device/folder config
2019-04-21 23:05:07 +02:00
syncthing-init = handleTest ./syncthing-init.nix {};
nixosTests.syncthing-many-devices: init
2023-10-14 21:32:24 +03:00
syncthing-many-devices = handleTest ./syncthing-many-devices.nix {};
syncthing-relay module: init
2018-11-17 15:02:00 +01:00
syncthing-relay = handleTest ./syncthing-relay.nix {};
nixos/switch-to-configuration: add sysinit-reactivation.target
2023-11-25 21:31:09 +01:00
sysinit-reactivation = runTest ./sysinit-reactivation.nix;
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
systemd = handleTest ./systemd.nix {};
nixos/tests: add systemd-analyze test
2019-11-25 00:03:55 +01:00
systemd-analyze = handleTest ./systemd-analyze.nix {};
nixosTests.systemd-binfmt: init This adds a simple test running GNU Hello cross-compiled for armv7l and aarch64 inside a x86_64 VM with configured binfmt. We already build the cross toolchains in other invocations, and building hello itself is small.
2020-05-18 11:16:56 +02:00
systemd-binfmt = handleTestOn ["x86_64-linux"] ./systemd-binfmt.nix {};
nixos/systemd-boot: run test on aarch64
2020-06-13 23:57:52 -04:00
systemd-boot = handleTest ./systemd-boot.nix {};
systemd: enable `BPF_FRAMEWORK` by default (`withLibBPF=true`) So far, we have been building Systemd without `BPF_FRAMEWORK`. As a result, some Systemd features like `RestrictNetworkInterfaces=` cannot work. To make things worse, Systemd doesn't even complain when using a feature which requires `+BPF_FRAMEWORK`; yet, the option has no effect: # systemctl --version | grep -o "\-BPF_FRAMEWORK" -BPF_FRAMEWORK # systemd-run -t -p RestrictNetworkInterfaces="lo" ping -c 1 8.8.8.8 This commit enables `BPF_FRAMEWORK` by default. This is in line with other distros (e.g., Fedora). Also note that BPF does not support stack protector: https://lkml.org/lkml/2020/2/21/1000. To that end, I added a small `CFLAGS` patch to the BPF building to keep using stack protector as a default. I also added an appropriate NixOS test.
2022-08-21 12:22:16 +02:00
systemd-bpf = handleTest ./systemd-bpf.nix {};
nixos/tests/confinement: Move to dedicated dir When experimenting on ways how to refactor the test, I wrote a significant enough amount of Python to warrant a dedicated Python file. This commit is mainly to prepare for that and make it easier to track renames. Signed-off-by: aszlig <aszlig@nix.build>
2024-04-24 15:04:07 +02:00
systemd-confinement = handleTest ./systemd-confinement {};
nixos: systemd-coredump: improve disabled state The systemd-coredump module required systemd to be built with withCoredump=true, even if the module was disabled. - allow systemd to be missing systemd-coredump if the module is disabled - switch to mkDefault for the sysctl config to allow user overrides when the module is disabled - add nixos tests for both the enabled and disabled cases
2022-08-01 09:44:29 -07:00
systemd-coredump = handleTest ./systemd-coredump.nix {};
nixos/tests/systemd-cryptenroll: add basic TPM2 test
2021-10-04 12:54:13 +02:00
systemd-cryptenroll = handleTest ./systemd-cryptenroll.nix {};
nixos/tests/systemd-credentials-tpm2: Add tests for systemd credentials Add a test that checks whether systemd can access the TPM in order access credentials requested via Load/SetCredentialEncrypted.
2023-02-20 01:07:31 +01:00
systemd-credentials-tpm2 = handleTest ./systemd-credentials-tpm2.nix {};
nixos: add functions and documentation for escaping systemd Exec* directives it's really easy to accidentally write the wrong systemd Exec* directive, ones that works most of the time but fails when users include systemd metacharacters in arguments that are interpolated into an Exec* directive. add a few functions analogous to escapeShellArg{,s} and some documentation on how and when to use them.
2022-01-09 08:46:55 +01:00
systemd-escaping = handleTest ./systemd-escaping.nix {};
nixos/tests/systemd-initrd-bridge: init
2023-08-25 13:11:20 -04:00
systemd-initrd-bridge = handleTest ./systemd-initrd-bridge.nix {};
nixos/btrfs: Add systemd stage 1 support
2022-04-17 13:55:48 +01:00
systemd-initrd-btrfs-raid = handleTest ./systemd-initrd-btrfs-raid.nix {};
nixos/tests/systemd-initrd-luks-fido2: init
2022-10-04 01:10:03 +08:00
systemd-initrd-luks-fido2 = handleTest ./systemd-initrd-luks-fido2.nix {};
nixos/stage-1-systemd: Add a test for LUKS keyfiles
2022-04-13 22:27:58 +01:00
systemd-initrd-luks-keyfile = handleTest ./systemd-initrd-luks-keyfile.nix {};
nixos/luksroot: add tryEmptyPassphrase option
2023-03-22 09:17:23 -05:00
systemd-initrd-luks-empty-passphrase = handleTest ./initrd-luks-empty-passphrase.nix { systemdStage1 = true; };
nixos/stage-1-systemd: Add LUKS w/ password support
2022-04-13 19:45:29 +01:00
systemd-initrd-luks-password = handleTest ./systemd-initrd-luks-password.nix {};
nixos/tests/systemd-initrd-luks-tpm2: init
2022-09-23 15:47:05 -06:00
systemd-initrd-luks-tpm2 = handleTest ./systemd-initrd-luks-tpm2.nix {};
nixos/tests: init systemd-initrd-luks-unl0kr
2023-02-27 00:30:25 +11:00
systemd-initrd-luks-unl0kr = handleTest ./systemd-initrd-luks-unl0kr.nix {};
nixos/tests/systemd-initrd-modprobe: init
2022-10-05 08:37:51 +08:00
systemd-initrd-modprobe = handleTest ./systemd-initrd-modprobe.nix {};
nixos/systemd: Properly shut down the system
2022-04-15 11:23:02 +01:00
systemd-initrd-shutdown = handleTest ./systemd-shutdown.nix { systemdStage1 = true; };
systemd-initrd: Basic test case
2022-03-20 16:11:32 -04:00
systemd-initrd-simple = handleTest ./systemd-initrd-simple.nix {};
nixos/stage-1-init: Merge mdraid module into swraid
2022-04-15 16:28:41 +01:00
systemd-initrd-swraid = handleTest ./systemd-initrd-swraid.nix {};
nixos/tests/systemd-initrd-vconsole: init new test for console.earlySetup
2023-02-08 15:24:10 -05:00
systemd-initrd-vconsole = handleTest ./systemd-initrd-vconsole.nix {};
systemd-initrd: networkd
2022-06-29 01:01:59 -04:00
systemd-initrd-networkd = handleTest ./systemd-initrd-networkd.nix {};
systemd-initrd: sshd
2022-08-03 06:36:11 -04:00
systemd-initrd-networkd-ssh = handleTest ./systemd-initrd-networkd-ssh.nix {};
openvpn: fix tests and add to passthru.tests
2023-12-20 18:23:08 +09:00
systemd-initrd-networkd-openvpn = handleTestOn [ "x86_64-linux" "i686-linux" ] ./initrd-network-openvpn { systemdStage1 = true; };
nixos/tests/systemd-initrd-vlan: init
2023-08-24 23:57:46 -04:00
systemd-initrd-vlan = handleTest ./systemd-initrd-vlan.nix {};
nixos.tests.systemd-journal: add basic systemd-journal-gatewayd test This test allows to ensure the systemd-journal-gatewayd service is responding correcly when the NixOS option `enableHttpGateway` is set. The test has not been added into the main systemd test because a graphical stack is not required (and rebuilding the graphical stack on systemd change is huge).
2020-11-01 18:48:40 +01:00
systemd-journal = handleTest ./systemd-journal.nix {};
nixos/tests/journal-gateway: init move previous gateway test from systemd-journal -> systemd-journal-gateway
2022-09-01 14:54:10 +02:00
systemd-journal-gateway = handleTest ./systemd-journal-gateway.nix {};
nixos/tests/journal-upload: init
2022-09-01 14:55:30 +02:00
systemd-journal-upload = handleTest ./systemd-journal-upload.nix {};
nixos/systemd-lock-handler: init
2023-10-05 17:52:07 +03:00
systemd-lock-handler = runTestOn ["aarch64-linux" "x86_64-linux"] ./systemd-lock-handler.nix;
nixos: Switch to default systemd-nspawn behaviour
2022-02-17 22:07:05 +01:00
systemd-machinectl = handleTest ./systemd-machinectl.nix {};
nixos/networkd: test routingPolicyRules with a nixos vm test
2020-02-29 19:34:48 +01:00
systemd-networkd = handleTest ./systemd-networkd.nix {};
nixos/networkd: add [Bridge] section to netdev conf This setting was missing from netdev. This commit additionally adds a test using the new section, ensuring that STP can be enabled.
2024-04-11 00:56:18 -07:00
systemd-networkd-bridge = handleTest ./systemd-networkd-bridge.nix {};
systemd-networkd: add DHCPServer test
2019-11-16 22:13:51 +11:00
systemd-networkd-dhcpserver = handleTest ./systemd-networkd-dhcpserver.nix {};
nixos/networkd: add `dhcpServerStaticLeaseConfig` option Add `systemd.network.networks.*.dhcpServerStaticLeaseConfig` to allow for configuring static DHCP leases through the `[DHCPServerStaticLease]` section. See systemd.network(5) of systemd 249 for details. Also adds the NixOS test `systemd-networkd-dhcpserver-static-lease` to test the assignment of static leases.
2021-11-30 09:57:15 +01:00
systemd-networkd-dhcpserver-static-leases = handleTest ./systemd-networkd-dhcpserver-static-leases.nix {};
nixos/tests: add systemd-networkd-ipv6-prefix-delegation This is a follow-up to the PR #82026 that contains the promised tests. In this test I am testing if we can properly propagate prefixes received via DHCPv6 PD with the networkd options in our module system. The comments in the test should be sufficient to follow the idea and what is going on.
2020-05-01 15:12:19 +02:00
systemd-networkd-ipv6-prefix-delegation = handleTest ./systemd-networkd-ipv6-prefix-delegation.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
systemd-networkd-vrf = handleTest ./systemd-networkd-vrf.nix {};
systemd-no-tainted: init as regression test
2022-10-05 00:19:38 +08:00
systemd-no-tainted = handleTest ./systemd-no-tainted.nix {};
nixosTests.systemd-nspawn: add test This adds a test downloading an nspawn container via http, and ensures sha256sum verification and gpg signature verification work.
2019-11-02 19:55:41 +01:00
systemd-nspawn = handleTest ./systemd-nspawn.nix {};
nixos/tests/systemd-nspawn-configfile: init Test for presence of all specified options in the generated .nspawn config file. Additionally test for absence of misspelled and fixed option MachineID.
2023-06-07 11:34:33 +02:00
systemd-nspawn-configfile = handleTest ./systemd-nspawn-configfile.nix {};
nixos/systemd-oomd: Add a new module + test
2022-04-21 19:54:50 +02:00
systemd-oomd = handleTest ./systemd-oomd.nix {};
nixos/tests: init systemd-portabled Please enter the commit message for your changes. Lines starting
2022-09-29 12:57:18 +02:00
systemd-portabled = handleTest ./systemd-portabled.nix {};
nixos/systemd-repart: init
2023-01-19 20:04:29 +01:00
systemd-repart = handleTest ./systemd-repart.nix {};
nixos/tests: systemd-resolved
2024-05-20 19:37:01 -04:00
systemd-resolved = handleTest ./systemd-resolved.nix {};
nixos/systemd: Properly shut down the system
2022-04-15 11:23:02 +01:00
systemd-shutdown = handleTest ./systemd-shutdown.nix {};
nixos/tests/systemd-sysupdate: init
2023-07-17 17:20:32 +02:00
systemd-sysupdate = runTest ./systemd-sysupdate.nix;
nixos/systemd-sysusers: init
2023-11-19 23:16:14 +01:00
systemd-sysusers-mutable = runTest ./systemd-sysusers-mutable.nix;
systemd-sysusers-immutable = runTest ./systemd-sysusers-immutable.nix;
nixos/tests: Add two new tests for password option override ordering This commit adds two new tests to show that the ordering of password overrides documentation in nixos/modules/config/user-groups.nix is correct. The override behavior differs depending on whether a system has systemd-sysusers enabled, so there are two tests.
2024-12-15 12:22:02 +08:00
systemd-sysusers-password-option-override-ordering = runTest ./systemd-sysusers-password-option-override-ordering.nix;
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
systemd: disable NSCD when DNSSEC validation is disabled in timesyncd When a system has a wrong date and time timesyncd is unable to synchronize it because DNSSEC doesn't work. In order to break this chicken and egg problem systemd-timesync disables DNSSEC validation by setting SYSTEMD_NSS_RESOLVE_VALIDATE=0 in the unit file. However, it doesn't work in NixOS because it uses NSCD. This patch disables NSCD in systemd-timesyncd when SYSTEMD_NSS_RESOLVE_VALIDATE is set to 0 so that it uses NSS libraries directly. In order for it to be able to find the libnss_resolve.so.2 library this patch adds the systemd directory in the nix store to the LD_LIBRARY_PATH.
2023-06-22 15:17:42 +03:00
systemd-timesyncd-nscd-dnssec = handleTest ./systemd-timesyncd-nscd-dnssec.nix {};
nixos/users-groups: move linger to oneshot and add nixos test
2024-03-21 19:51:05 -04:00
systemd-user-linger = handleTest ./systemd-user-linger.nix {};
nixos: systemd: add systemd.user.tmpfiles
2022-12-23 21:22:49 +01:00
systemd-user-tmpfiles-rules = handleTest ./systemd-user-tmpfiles-rules.nix {};
nixos/systemd: Allow creation of unit directories This patch allows creation of files like /etc/systemd/system/user-.slice.d/limits.conf with systemd.units."user-.slice.d/limits.conf" = { text = '' [Slice] CPUAccounting=yes CPUQuota=50% ''; }; which previously threw an error Also renames the systemd-unit-path test to sytsemd-misc, and extends it to test that `systemd.units` can handle directories. In this case we make sure that resource limits specified in user slices apply.
2021-08-11 20:28:30 +02:00
systemd-misc = handleTest ./systemd-misc.nix {};
nixos/systemd/userdbd: add method to enable service This is recommended to enable in conjunction with systemd-homed.
2022-12-07 18:31:05 -06:00
systemd-userdbd = handleTest ./systemd-userdbd.nix {};
nixos: add systemd-homed support As a start, it's not very configurable, but works pretty well.
2022-12-08 02:49:12 -06:00
systemd-homed = handleTest ./systemd-homed.nix {};
linuxPackages.systemtap: 4.8 -> 5.0a, add nixos tests (#276840) * nixos/tests/systemtap: init smoke test * linuxPackages.systemtap: use --sysroot instead of -r * nixos/tests/systemtap: rule out warnings * linuxPackages.systemtap: smaller sysroot * nixos/tests/systemtap: test on a few more kernels * linuxPackages.systemtap: provide debuginfo for tracing kernel.function * linuxPackages.systemtap: test kernel.function probe * linuxPackages.systemtap: 4.8 -> 5.0a
2024-01-09 19:38:02 +01:00
systemtap = handleTest ./systemtap.nix {};
tests/taler: init basic test Test build and services start, but libeufin-bank fails when trying to access the database to change the admin's password. We need to execute the command as the libeufin-bank user. tests/taler: add master private key tests/taler: rewrite `register_bank_account` to Nix tests/taler: rename libeufin node to bank tests/taler: use xtaler wire_type instead of iban tests/taler: remove redundant data from conf files tests/taler: enable exchange account tests/taler: remove unused talerConfig tests/taler: add client node and attempt a withdrawal tests/taler: systemd_run optional user and group args tests/taler: refactor and make a withdrawal tests/taler: refactor tasks into subtests tests/taler: properly read and test balance tests/taler: refactor commands and add comments nixos/taler: rename private key tests/taler: enable nexus service in bank node tests/taler: nexus fake incoming payment test tests/taler: use correct path for nexus client keys tests/taler: add merchant node tests/taler: merchant register instance tests/taler: init pay for order merchant tests/taler: fix payto uri tests/taler: withdraw smaller amount This makes the test faster tests/taler: verify balance tests/nixos: debugging merchant payment, cleanup tests/taler: fix libeufin command, use curl to register accounts tests/taler: add basic online test tests/taler: move nodes into separate directory tests/taler: fix insufficient balance error Turns out that the exchange wire fees need to be set up (even if they're 0) in order for the CLI wallet to deposit coins into the merchant's bank account. tests/taler: improve node importing, port forwarding tests/taler: import scripts from a separate file tests/taler: move tests into a sub-directory tests/taler: manually start services, cleanup This results in less overhead and conflict since components will not try to prematurely connect to the ones that haven't finished their set up. tests/taler: remove online test This was used to debug the insufficient balance problem, but it's not really that useful by itself. tests/taler: add nexus keys tests/taler: use bank initalAccounts option taler/tests: use initialAccount tests/taler: make nexus work tests/taler: don't run nexus test if there is no internet tests/taler: use openFirewall, remove manual package install fix(test): evaluation errors fix(test): create nexus role by enabling createLocalDatabase
2024-07-23 18:20:41 +01:00
taler = handleTest ./taler {};
nixos/tandoor-recipes: add test
2022-09-17 16:36:39 +02:00
tandoor-recipes = handleTest ./tandoor-recipes.nix {};
nixosTests.tandoor-recipes-script-name: init Verify that all `href` attributes emitted as part of the entrypoint page after logging in are reachable. Co-authored-by: Bruno BELANYI <bruno@belanyi.fr>
2024-06-19 23:55:33 +12:00
tandoor-recipes-script-name = handleTest ./tandoor-recipes-script-name.nix {};
nixos/tang: create module for tang server (#247037) This commit adds a module for the tang server and the related nixos test.
2023-10-16 13:10:15 +02:00
tang = handleTest ./tang.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
taskserver = handleTest ./taskserver.nix {};
nixosTests.taskchampion-sync-server: init
2024-06-10 20:15:18 +03:00
taskchampion-sync-server = handleTest ./taskchampion-sync-server.nix {};
nixos/tests/tayga: init
2022-10-12 21:16:02 +02:00
tayga = handleTest ./tayga.nix {};
nixos/modules: add `technitium-dns-server` tests
2024-04-04 08:35:07 +02:00
technitium-dns-server = handleTest ./technitium-dns-server.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
teeworlds = handleTest ./teeworlds.nix {};
nixos/telegraf: add test
2019-01-21 11:30:11 +00:00
telegraf = handleTest ./telegraf.nix {};
nixos/tests/teleport: init
2022-01-10 13:46:47 +01:00
teleport = handleTest ./teleport.nix {};
tests/teleports: init
2024-07-04 20:36:22 +02:00
teleports = runTest ./teleports.nix;
nixos/thelounge: add test
2022-01-10 21:29:04 -05:00
thelounge = handleTest ./thelounge.nix {};
nixos/tests: add integration tests for terminal emulators
2020-11-14 07:41:14 +13:00
terminal-emulators = handleTest ./terminal-emulators.nix {};
nixos/prometheus: Renamed existing Prometheus test to Thanos.
2024-06-02 00:01:02 +01:00
thanos = handleTest ./thanos.nix {};
nixos/tiddlywiki: init Service that runs TiddlyWiki nodejs server
2019-04-29 21:46:00 +01:00
tiddlywiki = handleTest ./tiddlywiki.nix {};
tigervnc, tightvnc: add basic tests Co-Authored-By: Ingo Blechschmidt <iblech@web.de>
2020-04-13 05:56:20 +02:00
tigervnc = handleTest ./tigervnc.nix {};
nixos/tika: init module
2024-07-12 12:59:00 +02:00
tika = runTest ./tika.nix;
nixos/tests/timezone: port to python
2019-12-02 23:28:53 +01:00
timezone = handleTest ./timezone.nix {};
Update nixos/tests/all-tests.nix Co-authored-by: Manuel Bärenz <programming@manuelbaerenz.de>
2024-10-24 11:46:02 +02:00
timidity = handleTestOn ["aarch64-linux" "x86_64-linux"] ./timidity {};
nixos/tests/tinc: init with simple test
2020-12-06 16:05:21 +01:00
tinc = handleTest ./tinc {};
nixos: add test for tinydns
2019-05-16 23:42:02 +02:00
tinydns = handleTest ./tinydns.nix {};
nixosTests.tinyproxy: init
2023-05-05 21:02:11 +02:00
tinyproxy = handleTest ./tinyproxy.nix {};
nixos/tests/tinywl: init This adds a very minimalistic (in terms of functionality and dependencies) test for wlroots, Wayland, and related packages. The Sway test covers more functionality and packages (e.g. XWayland) but this test has tree advantages: - Less dependencies: Much fewer rebuilds are required when testing core changes that need to go through staging. - Testing wlroots updates: The Sway package isn't immediately updated after a new wlroots version is released and a lot of other packages depend on wlroots as well. - Determining whether a bug only affects Sway or wlroots/TinyWL as well.
2021-12-28 21:32:26 +01:00
tinywl = handleTest ./tinywl.nix {};
nixos/tmate-ssh-server: init module (#192270) * nixos/tmate-ssh-server: init module Co-authored-by: Aaron Andersen <aaron@fosslib.net>
2022-10-05 18:34:30 +02:00
tmate-ssh-server = handleTest ./tmate-ssh-server.nix { };
nixos/tomcat: add basic test case using the example app
2022-03-13 14:31:43 +01:00
tomcat = handleTest ./tomcat.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
tor = handleTest ./tor.nix {};
nixosTests.tpm-ek: provide EK certificates to tests
2024-12-11 19:09:20 -08:00
tpm-ek = handleTest ./tpm-ek {};
nixosTests.traefik: enable on aarch64-linux
2022-09-24 17:43:38 +10:00
traefik = handleTestOn ["aarch64-linux" "x86_64-linux"] ./traefik.nix {};
nixos/tests/trafficserver: init
2021-04-10 01:48:51 +09:00
trafficserver = handleTest ./trafficserver.nix {};
nixosTests.transfer-sh: init
2024-01-25 12:23:53 +08:00
transfer-sh = handleTest ./transfer-sh.nix {};
transmission_3: rename from transmission
2024-06-10 10:54:49 +03:00
transmission_3 = handleTest ./transmission.nix { transmission = pkgs.transmission_3; };
nixosTests.tranmission_4: init
2023-09-23 21:27:17 +10:00
transmission_4 = handleTest ./transmission.nix { transmission = pkgs.transmission_4; };
tracee: 0.7.0 -> 0.8.3 Also simplified the package since after #176152 the tracee build process can now pass in a -target of bpf without weird overrides
2022-10-02 11:43:54 +01:00
# tracee requires bpf
tracee = handleTestOn ["x86_64-linux"] ./tracee.nix {};
tests: adding trezord
2019-08-16 17:00:07 +02:00
trezord = handleTest ./trezord.nix {};
nixos/trickster: add test
2019-11-01 11:03:23 +01:00
trickster = handleTest ./trickster.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
trilium-server = handleTestOn ["x86_64-linux"] ./trilium-server.nix {};
tsm-client: add test derivation and a module test The tsm-client needs a tsm-server to do anything useful. Without a server, automated tests can just check diagnostic outputs for plausibility. The commit at hand adds two tests: 1. The command line interface `dsmc` is called, then it is verified that the program does * report the correct client version, * find its configuration file, * report a connection error. 2. To check the GUI (and the tsm-client nixos module), we add a vm test which uses the module to install `tsm-client-withGui`. To verify that the GUI's basic functionality is present, we skip over all connection failure related error messages and open the "Connection Information" dialog from the main application window. This dialog presents the node name and the client version; both are verified by the test. Note: Our `tsm-client` build recipe consists of two packages: The "unwrapped" package and the final package. This commit puts the unwrapped one into the final package's `passthru` so that tests can access the original version string that is needed to check the client version reported by the application.
2021-12-18 09:21:57 +01:00
tsm-client-gui = handleTest ./tsm-client-gui.nix {};
ttyd: add test & use systemd LoadCredential
2024-01-20 17:33:00 +01:00
ttyd = handleTest ./web-servers/ttyd.nix {};
tt-rss: Add simple test
2024-11-16 23:27:27 +01:00
tt-rss = handleTest ./web-apps/tt-rss.nix {};
pythonPackages.txredisapi: Add unit test
2021-06-24 23:34:03 +02:00
txredisapi = handleTest ./txredisapi.nix {};
nixosTests.tuptime: init test
2020-03-24 23:45:49 +01:00
tuptime = handleTest ./tuptime.nix {};
turbovnc: Add programs.turbovnc, add test for headless software OpenGL
2021-03-14 06:13:41 +01:00
turbovnc-headless-server = handleTest ./turbovnc-headless-server.nix {};
nixos/turn-rs: init
2024-09-11 10:51:45 +08:00
turn-rs = handleTest ./turn-rs.nix {};
tuxguitar: 125945 (#131028) * tuxguitar: Ensure that tuxguitar is launched with java 8 comtabilbe jre and libraries as greate java version is not supported * tuxguitar: Added test to verify application starts without problems * tuxguitar: 1.5.2 -> 1.5.4
2021-07-23 08:02:20 -06:00
tuxguitar = handleTest ./tuxguitar.nix {};
nixos/twingate: add package option and test
2023-07-07 19:50:29 +03:00
twingate = runTest ./twingate.nix;
nixos/typesense: init at 0.24.1
2023-07-19 00:29:30 +02:00
typesense = handleTest ./typesense.nix {};
nixos/test/ucarp: init
2021-06-13 22:00:25 +02:00
ucarp = handleTest ./ucarp.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
udisks2 = handleTest ./udisks2.nix {};
ulogd: add support for multiple logging stacks fixes #244469
2023-09-18 00:09:25 +02:00
ulogd = handleTest ./ulogd/ulogd.nix {};
ucg: init at 20190225
2020-11-29 20:00:38 -03:00
unbound = handleTest ./unbound.nix {};
unifi: Add NixOS tests
2021-12-17 15:55:13 -08:00
unifi = handleTest ./unifi.nix {};
nixos/tests: add unit-php test
2020-04-16 23:08:00 +03:00
unit-php = handleTest ./web-servers/unit-php.nix {};
unit: add nixos tests for perl
2024-09-08 19:45:16 +02:00
unit-perl = handleTest ./web-servers/unit-perl.nix {};
miniupnpd-nftables: init at 2.3.3
2023-06-22 00:08:31 +07:00
upnp.iptables = handleTest ./upnp.nix { useNftables = false; };
upnp.nftables = handleTest ./upnp.nix { useNftables = true; };
nixos/tests/uptermd: init
2022-03-17 17:57:23 +01:00
uptermd = handleTest ./uptermd.nix {};
nixos/uptime-kuma: init module
2022-09-23 07:04:23 +02:00
uptime-kuma = handleTest ./uptime-kuma.nix {};
nixosTests.urn-timer: init
2024-02-04 19:59:22 +01:00
urn-timer = handleTest ./urn-timer.nix {};
nixos/tests/usbguard: init
2021-01-16 23:15:52 +01:00
usbguard = handleTest ./usbguard.nix {};
nixos/tests/userborn: init
2024-08-07 14:56:05 +02:00
userborn = runTest ./userborn.nix;
userborn-mutable-users = runTest ./userborn-mutable-users.nix;
userborn-immutable-users = runTest ./userborn-immutable-users.nix;
userborn-mutable-etc = runTest ./userborn-mutable-etc.nix;
userborn-immutable-etc = runTest ./userborn-immutable-etc.nix;
nixos/activation-script: Add a test
2021-02-15 14:40:54 -08:00
user-activation-scripts = handleTest ./user-activation-scripts.nix {};
nixos/update-users-groups: add nixos test for the expires option
2023-08-02 13:51:06 +02:00
user-expiry = runTest ./user-expiry.nix;
nixos/users-group: Add 'homeMode' option.
2022-04-10 21:06:19 +02:00
user-home-mode = handleTest ./user-home-mode.nix {};
nixos/tests/ustreamer: init
2024-03-21 03:30:37 +00:00
ustreamer = handleTest ./ustreamer.nix {};
nixos: add test for uwsgi
2019-05-27 23:03:22 +02:00
uwsgi = handleTest ./uwsgi.nix {};
nixos/tests/v2ray: init
2020-06-12 16:12:51 +08:00
v2ray = handleTest ./v2ray.nix {};
nixos/tests/varnish: init
2022-09-27 21:22:21 +02:00
varnish60 = handleTest ./varnish.nix { package = pkgs.varnish60; };
varnish75: init at 7.5.0 (#308604) Changes: https://varnish-cache.org/docs/7.5/whats-new/changes-7.5.html
2024-05-03 21:03:01 +02:00
varnish75 = handleTest ./varnish.nix { package = pkgs.varnish75; };
varnish76: init at 7.6.1
2025-01-14 16:56:17 +01:00
varnish76 = handleTest ./varnish.nix { package = pkgs.varnish76; };
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
vault = handleTest ./vault.nix {};
nixosTests.vault-agent: init
2023-04-25 15:58:30 +02:00
vault-agent = handleTest ./vault-agent.nix {};
nixos/vault: add option to start in dev mode. (#180114) * nixos/vault: add option to start in dev mode. This is not only useful for nixos tests i.e. when testing vault agent setups but also when playing around with vault in local setups. In our tests we can now make use of this option to test more vault features. i.e. adding this feature has uncovered the need for a `StateDirectory`. * Update nixos/modules/services/security/vault.nix Co-authored-by: Robert Hensing <roberth@users.noreply.github.com> Co-authored-by: Jonas Chevalier <zimbatm@zimbatm.com> Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>
2022-07-05 10:54:11 +02:00
vault-dev = handleTest ./vault-dev.nix {};
nixosTests.vault-postgresql: init
2021-01-04 17:54:03 +01:00
vault-postgresql = handleTest ./vault-postgresql.nix {};
nixos/vaultwarden: add test for backup script, fix flaky sqlite test
2023-07-27 21:13:55 +02:00
vaultwarden = discoverTests (import ./vaultwarden.nix);
nixos/vector: Moved existing test to subdirectory
2024-05-21 17:13:35 +01:00
vector = handleTest ./vector {};
nixosTests.vengi-tools: init
2021-11-21 18:09:17 +01:00
vengi-tools = handleTest ./vengi-tools.nix {};
nixos/victoriametrics: check config, more tests, update desc
2024-11-22 09:53:13 +08:00
victoriametrics = handleTest ./victoriametrics {};
nixos/vikunja: add nixos test
2021-06-26 14:26:17 +02:00
vikunja = handleTest ./vikunja.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
virtualbox = handleTestOn ["x86_64-linux"] ./virtualbox.nix {};
nixos/tests: Test that Remote SSH can patch Node
2022-03-13 18:16:34 +11:00
vscode-remote-ssh = handleTestOn ["x86_64-linux"] ./vscode-remote-ssh.nix {};
nixos/tests/vscodium{,-wayland}: merge tests
2021-11-19 21:21:20 +01:00
vscodium = discoverTests (import ./vscodium.nix);
vsftpd: enable seccomp (#158974) * vsftpd: enable seccomp * nixos/tests/vsftpd: add basic test * vsftpd: add test to passthru
2022-03-01 04:03:47 +01:00
vsftpd = handleTest ./vsftpd.nix {};
waagent: init module
2024-12-06 23:32:16 +08:00
waagent = handleTest ./waagent.nix {};
nixos/tests: add wakapi
2024-10-22 12:28:04 +03:00
wakapi = handleTest ./wakapi.nix {};
nixosTests.warzone2100: init
2022-11-24 20:46:05 +01:00
warzone2100 = handleTest ./warzone2100.nix {};
tests/wasabibackend: init
2020-06-18 14:19:13 +02:00
wasabibackend = handleTest ./wasabibackend.nix {};
wastebin: init at 2.4.3 (#287455) * wastebin: init at 2.4.3 * nixos/wastebin: init Add module and test for wastebin
2024-04-01 02:55:15 +02:00
wastebin = handleTest ./wastebin.nix {};
nixosTests.watchdogd: init
2024-01-19 23:38:27 +01:00
watchdogd = handleTest ./watchdogd.nix {};
nixos/webhook: init
2020-03-22 12:49:51 +01:00
webhook = runTest ./webhook.nix;
nixos/weblate: init module and test Co-authored-by: Taeer Bar-Yam <Radvendii@users.noreply.github.com>
2024-07-22 17:11:49 +02:00
weblate = handleTest ./web-apps/weblate.nix {};
nixos/whisparr: initial commit
2024-05-25 22:32:17 +03:00
whisparr = handleTest ./whisparr.nix {};
nixos/whoogle-seach: add module
2024-10-16 02:16:15 +02:00
whoogle-search = handleTest ./whoogle-search.nix {};
wiki-js: init at 2.5.191
2021-03-18 12:33:40 +01:00
wiki-js = handleTest ./wiki-js.nix {};
nixos/tests: add missing tests Some tests from the `nixos/tests` folder were missing in the `all-tests.nix` file. This meant they couldn't be run from the `nixosTests` attribute set and therefore not be linked to their packages.
2022-01-23 12:11:05 +01:00
wine = handleTest ./wine.nix {};
nixos/wireguard: add test After working on the last wireguard bump (#57534), we figured that it's probably a good idea to have a basic test which confirms that a simple VPN with wireguard still works. This test starts two peers with a `wg0` network interface and adds a v4 and a v6 route that goes through `wg0`.
2019-03-17 13:20:38 +01:00
wireguard = handleTest ./wireguard {};
nixos/wg-access-server: init module
2024-03-09 17:20:01 +01:00
wg-access-server = handleTest ./wg-access-server.nix {};
nixos/nix-daemon: Add enable option Don't worry, it's is true by default. But I think this is important to have because NixOS indeed shouldn't need Nix at run time when the installation is not being modified, and now we can verify that. NixOS images that cannot "self-modify" are a legitamate use-case that this supports more minimally. One should be able to e.g. do a sshfs mount and use `nixos-install` to modify them remotely, or just discard them and build fresh ones if they are run VMs or something. The next step would be to make generations optional, allowing just baking `/etc` and friends rather than using activation scripts. But that's more involved so I'm leaving it out.
2021-04-24 21:02:15 +00:00
without-nix = handleTest ./without-nix.nix {};
wmderland: init at 2020-07-17
2021-01-27 23:44:27 +09:00
wmderland = handleTest ./wmderland.nix {};
nixos/workout-tracker: init
2024-03-16 14:26:22 +05:30
workout-tracker = handleTest ./workout-tracker.nix {};
nixos/tests/wpa_supplicant: use secretsFile and split subcases
2024-08-22 19:27:20 +02:00
wpa_supplicant = import ./wpa_supplicant.nix { inherit pkgs runTest; };
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
wordpress = handleTest ./wordpress.nix {};
nixos/security/wrappers: add test This is a small smoke test of each piece (setuid, setgid, caps) of wrappers' functionality. It doesn't try to check for combinations of functionalities or anything more complicated.
2022-11-05 12:38:11 +01:00
wrappers = handleTest ./wrappers.nix {};
nixos/writefreely: init
2022-06-25 22:08:43 -07:00
writefreely = handleTest ./web-apps/writefreely.nix {};
nixosTests.wstunnel: init Co-authored-by: r-vdp <ramses@well-founded.dev>
2024-06-15 16:32:52 +02:00
wstunnel = runTest ./wstunnel.nix;
nixosTests.xandikos: init
2019-12-14 01:17:49 +01:00
xandikos = handleTest ./xandikos.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
xautolock = handleTest ./xautolock.nix {};
xfce = handleTest ./xfce.nix {};
nixos/tests/xfce-wayland: init Use wlrctl instead of wait_for_window, to avoid xwininfo usages.
2024-10-21 22:15:30 +08:00
xfce-wayland = handleTest ./xfce-wayland.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
xmonad = handleTest ./xmonad.nix {};
nixos/desktop-manager/none: add option to run XDG autostart files `fcitx5` and `service.earlyoom` rely on use XDG autostart files to start. But for X session with only window manager and no desktop manager (`none` is used), no one can start them. This options is added to run these autostart files for sessions without desktop manager to make other services just work.
2021-06-18 21:10:26 +08:00
xmonad-xdg-autostart = handleTest ./xmonad-xdg-autostart.nix {};
nixos/xpadneo: add sanity test
2022-09-20 19:39:13 -04:00
xpadneo = handleTest ./xpadneo.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
xrdp = handleTest ./xrdp.nix {};
nixos/tests: add xrdp-with-audio-pulseaudio Signed-off-by: lucasew <lucas59356@gmail.com>
2024-01-08 16:19:30 -03:00
xrdp-with-audio-pulseaudio = handleTest ./xrdp-with-audio-pulseaudio.nix {};
nixos/xscreensaver: add module tests Co-authored-by: Aidan Gauland <aidalgol@fastmail.net> Co-authored-by: Anderson Torres <torres.anderson.85@protonmail.com>
2023-11-23 12:31:50 -08:00
xscreensaver = handleTest ./xscreensaver.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
xss-lock = handleTest ./xss-lock.nix {};
xterm: Add test
2020-11-16 22:13:13 -05:00
xterm = handleTest ./xterm.nix {};
xxh: added tests
2022-01-01 22:16:13 +01:00
xxh = handleTest ./xxh.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
yabar = handleTest ./yabar.nix {};
nixosTests.ydotool: init Co-authored-by: Cosima Neidahl <opna2608@protonmail.com>
2024-05-08 17:58:21 +02:00
ydotool = handleTest ./ydotool.nix {};
nixos/yggdrasil: add service
2019-06-27 08:56:10 -07:00
yggdrasil = handleTest ./yggdrasil.nix {};
nixosTests.your_spotify: init
2024-04-13 10:59:11 +02:00
your_spotify = handleTest ./your_spotify.nix {};
Zammad: more fixes
2022-02-16 00:49:51 -05:00
zammad = handleTest ./zammad.nix {};
nixos/zenohd: add module and test
2024-12-27 19:26:01 +01:00
zenohd = handleTest ./zenohd.nix {};
zeronet-conservancy: add nixos test
2022-06-10 14:54:16 +02:00
zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};
nixosTests.zfs: Add to all-tests.nix
2020-02-03 18:33:26 +01:00
zfs = handleTest ./zfs.nix {};
nixos/zigbee2mqtt: add test to all-tests.nix
2020-08-03 12:43:13 +02:00
zigbee2mqtt = handleTest ./zigbee2mqtt.nix {};
nixos/tests/zipline: init
2025-01-04 16:33:37 +01:00
zipline = handleTest ./zipline.nix {};
nixos/zoneminder: add minimal test
2020-04-11 13:28:52 -04:00
zoneminder = handleTest ./zoneminder.nix {};
tests: split into a separate `all-tests.nix` file This will make the list much easier to re-use, eg. for `nixosTests` The drawback is that this approaches makes the ``` nix-build release.nix -A tests.opensmtpd.x86_64-linux ``` command about twice as slow (3s to 6s): it now has to evaluate `nixpkgs` once for each architecture, instead of just having the hardcoded list of tests that allowed to say “ok just evaluate for x86_64-linux”. On the other hand, complete evaluation of `release.nix` should be much faster because we no longer import `nixpkgs` for each test: testing with the following command went from 30s to 18s, and that's just for a few tests. ``` time nix-instantiate --eval --strict nixos/release.nix -A tests.nat ``` I initially wanted to test on the whole `release.nix`, but there are too many broken tests and it takes too long to eval them all, especially compared to the fact that the current implementation breaks some setup. Given developers can just `nix-build nixos/tests/my-test.nix`, it sounds like an overall win.
2018-11-11 20:30:07 +09:00
zookeeper = handleTest ./zookeeper.nix {};
nixos/zram-generator: add test
2023-01-18 15:40:42 +01:00
zram-generator = handleTest ./zram-generator.nix {};
nixos/zrepl: note about systemd unit, add snapshot test Signed-off-by: Matt Layher <mdlayher@gmail.com>
2022-03-29 14:44:07 -04:00
zrepl = handleTest ./zrepl.nix {};
nixos/zoneminder: add minimal test
2020-04-11 13:28:52 -04:00
zsh-history = handleTest ./zsh-history.nix {};
zwave-js: module init, zwave-js-server: init at 1.33.0 Co-authored-by: Martin Weinelt <mweinelt@users.noreply.github.com> Co-authored-by: h7x4 <h7x4@nani.wtf>
2023-05-13 22:42:00 +01:00
zwave-js = handleTest ./zwave-js.nix {};
nixos/zwave-js-ui: init module Provides systemd service and allows configuration of data directory
2024-08-21 22:09:46 -04:00
zwave-js-ui = handleTest ./zwave-js-ui.nix {};
nixosTests.allDrivers: Move logic to all-packages.nix Bring it in line with release.nix
2022-06-06 19:24:30 +02:00
}
Reference in a new issue Copy permalink