commit 7699f34c524a50959c475425587f6b07d443a9e9 · pyrox.dev/nixpkgs

+94

lib/tests/modules.sh

···

       1
       1
       +
       #!/bin/sh

     

       2
       2
       +
       #

     

       3
       3
       +
       # This script is used to test that the module system is working as expected.

     

       4
       4
       +
       # By default it test the version of nixpkgs which is defined in the NIX_PATH.

     

       5
       5
       +
       

     

       6
       6
       +
       cd ./modules

     

       7
       7
       +
       

     

       8
       8
       +
       pass=0

     

       9
       9
       +
       fail=0

     

       10
       10
       +
       

     

       11
       11
       +
       evalConfig() {

     

       12
       12
       +
           local attr=$1

     

       13
       13
       +
           shift;

     

       14
       14
       +
           local script="import ./default.nix { modules = [ $@ ];}"

     

       15
       15
       +
           nix-instantiate --timeout 1 -E "$script" -A "$attr" --eval-only

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       reportFailure() {

     

       19
       19
       +
           local attr=$1

     

       20
       20
       +
           shift;

     

       21
       21
       +
           local script="import ./default.nix { modules = [ $@ ];}"

     

       22
       22
       +
           echo 2>&1 "$ nix-instantiate -E '$script' -A '$attr' --eval-only"

     

       23
       23
       +
           evalConfig "$attr" "$@"

     

       24
       24
       +
           fail=$((fail + 1))

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       checkConfigOutput() {

     

       28
       28
       +
           local outputContains=$1

     

       29
       29
       +
           shift;

     

       30
       30
       +
           if evalConfig "$@" 2>/dev/null | grep --silent "$outputContains" ; then

     

       31
       31
       +
               pass=$((pass + 1))

     

       32
       32
       +
               return 0;

     

       33
       33
       +
           else

     

       34
       34
       +
               echo 2>&1 "error: Expected result matching '$outputContains', while evaluating"

     

       35
       35
       +
               reportFailure "$@"

     

       36
       36
       +
               return 1

     

       37
       37
       +
           fi

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       checkConfigError() {

     

       41
       41
       +
           local errorContains=$1

     

       42
       42
       +
           local err=""

     

       43
       43
       +
           shift;

     

       44
       44
       +
           if err==$(evalConfig "$@" 2>&1 >/dev/null); then

     

       45
       45
       +
               echo 2>&1 "error: Expected error code, got exit code 0, while evaluating"

     

       46
       46
       +
               reportFailure "$@"

     

       47
       47
       +
               return 1

     

       48
       48
       +
           else

     

       49
       49
       +
               if echo "$err" | grep --silent "$errorContains" ; then

     

       50
       50
       +
                   pass=$((pass + 1))

     

       51
       51
       +
                   return 0;

     

       52
       52
       +
               else

     

       53
       53
       +
                   echo 2>&1 "error: Expected error matching '$errorContains', while evaluating"

     

       54
       54
       +
                   reportFailure "$@"

     

       55
       55
       +
                   return 1

     

       56
       56
       +
               fi

     

       57
       57
       +
           fi

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       checkConfigOutput "false" config.enable ./declare-enable.nix

     

       61
       61
       +
       checkConfigError 'The option .* defined in .* does not exist.' config.enable ./define-enable.nix

     

       62
       62
       +
       set -- config.enable ./declare-enable.nix ./define-enable.nix

     

       63
       63
       +
       checkConfigOutput "true" "$@"

     

       64
       64
       +
       checkConfigOutput "false" "$@" ./define-force-enable.nix

     

       65
       65
       +
       checkConfigOutput "false" "$@" ./define-enable-force.nix

     

       66
       66
       +
       

     

       67
       67
       +
       checkConfigError 'attribute .*foo.* .* not found' config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix

     

       68
       68
       +
       checkConfigOutput 'false' config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix

     

       69
       69
       +
       set -- config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo-enable.nix

     

       70
       70
       +
       checkConfigOutput 'true' "$@"

     

       71
       71
       +
       checkConfigOutput 'false' "$@" ./define-force-loaOfSub-foo-enable.nix

     

       72
       72
       +
       checkConfigOutput 'false' "$@" ./define-loaOfSub-force-foo-enable.nix

     

       73
       73
       +
       checkConfigOutput 'false' "$@" ./define-loaOfSub-foo-force-enable.nix

     

       74
       74
       +
       checkConfigOutput 'false' "$@" ./define-loaOfSub-foo-enable-force.nix

     

       75
       75
       +
       

     

       76
       76
       +
       checkConfigError 'attribute .*bar.* .* not found' config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix

     

       77
       77
       +
       checkConfigOutput 'false' config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix ./define-loaOfSub-bar.nix

     

       78
       78
       +
       set -- config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix ./define-loaOfSub-bar-enable.nix

     

       79
       79
       +
       checkConfigOutput 'true' "$@"

     

       80
       80
       +
       checkConfigError 'attribute .*bar.* .* not found' "$@" ./define-force-loaOfSub-foo-enable.nix

     

       81
       81
       +
       checkConfigError 'attribute .*bar.* .* not found' "$@" ./define-loaOfSub-force-foo-enable.nix

     

       82
       82
       +
       checkConfigOutput 'true' "$@" ./define-loaOfSub-foo-force-enable.nix

     

       83
       83
       +
       checkConfigOutput 'true' "$@" ./define-loaOfSub-foo-enable-force.nix

     

       84
       84
       +
       

     

       85
       85
       +
       cat <<EOF

     

       86
       86
       +
       ====== module tests ======

     

       87
       87
       +
       $pass Pass

     

       88
       88
       +
       $fail Fail

     

       89
       89
       +
       EOF

     

       90
       90
       +
       

     

       91
       91
       +
       if test $fail -ne 0; then

     

       92
       92
       +
           exit 1

     

       93
       93
       +
       fi

     

       94
       94
       +
       exit 0

+14

lib/tests/modules/declare-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         options = {

     

       5
       5
       +
           enable = lib.mkOption {

     

       6
       6
       +
             default = false;

     

       7
       7
       +
             example = true;

     

       8
       8
       +
             type = lib.types.bool;

     

       9
       9
       +
             description = ''

     

       10
       10
       +
               Some descriptive text

     

       11
       11
       +
             '';

     

       12
       12
       +
           };

     

       13
       13
       +
         };

     

       14
       14
       +
       }

+29

lib/tests/modules/declare-loaOfSub-any-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         submod = { ... }: {

     

       5
       5
       +
           options = {

     

       6
       6
       +
             enable = lib.mkOption {

     

       7
       7
       +
               default = false;

     

       8
       8
       +
               example = true;

     

       9
       9
       +
               type = lib.types.bool;

     

       10
       10
       +
               description = ''

     

       11
       11
       +
                 Some descriptive text

     

       12
       12
       +
               '';

     

       13
       13
       +
             };

     

       14
       14
       +
           };

     

       15
       15
       +
         };

     

       16
       16
       +
       in

     

       17
       17
       +
       

     

       18
       18
       +
       {

     

       19
       19
       +
         options = {

     

       20
       20
       +
           loaOfSub = lib.mkOption {

     

       21
       21
       +
             default = {};

     

       22
       22
       +
             example = {};

     

       23
       23
       +
             type = lib.types.loaOf (lib.types.submodule [ submod ]);

     

       24
       24
       +
             description = ''

     

       25
       25
       +
               Some descriptive text

     

       26
       26
       +
             '';

     

       27
       27
       +
           };

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+7

lib/tests/modules/default.nix

···

       1
       1
       +
       { lib ? import <nixpkgs/lib>, modules ? [] }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         inherit (lib.evalModules {

     

       5
       5
       +
           inherit modules;

     

       6
       6
       +
         }) config options;

     

       7
       7
       +
       }

+5

lib/tests/modules/define-enable-force.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         enable = lib.mkForce false;

     

       5
       5
       +
       }

+3

lib/tests/modules/define-enable.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         enable = true;

     

       3
       3
       +
       }

+5

lib/tests/modules/define-force-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       lib.mkForce {

     

       4
       4
       +
         enable = false;

     

       5
       5
       +
       }

+5

lib/tests/modules/define-force-loaOfSub-foo-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       lib.mkForce {

     

       4
       4
       +
         loaOfSub.foo.enable = false;

     

       5
       5
       +
       }

+3

lib/tests/modules/define-loaOfSub-bar-enable.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         loaOfSub.bar.enable = true;

     

       3
       3
       +
       }

+3

lib/tests/modules/define-loaOfSub-bar.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         loaOfSub.bar = {};

     

       3
       3
       +
       }

+5

lib/tests/modules/define-loaOfSub-foo-enable-force.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         loaOfSub.foo.enable = lib.mkForce false;

     

       5
       5
       +
       }

+3

lib/tests/modules/define-loaOfSub-foo-enable.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         loaOfSub.foo.enable = true;

     

       3
       3
       +
       }

+7

lib/tests/modules/define-loaOfSub-foo-force-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         loaOfSub.foo = lib.mkForce {

     

       5
       5
       +
           enable = false;

     

       6
       6
       +
         };

     

       7
       7
       +
       }

+3

lib/tests/modules/define-loaOfSub-foo.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         loaOfSub.foo = {};

     

       3
       3
       +
       }

+7

lib/tests/modules/define-loaOfSub-force-foo-enable.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         loaOfSub = lib.mkForce {

     

       5
       5
       +
           foo.enable = false;

     

       6
       6
       +
         };

     

       7
       7
       +
       }

+31

lib/tests/release.nix

···

       1
       1
       +
       { nixpkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with import ./../.. { };

     

       4
       4
       +
       with lib;

     

       5
       5
       +
       

     

       6
       6
       +
       stdenv.mkDerivation {

     

       7
       7
       +
         name = "nixpkgs-lib-tests";

     

       8
       8
       +
         buildInputs = [ nix ];

     

       9
       9
       +
         NIX_PATH="nixpkgs=${nixpkgs}";

     

       10
       10
       +
       

     

       11
       11
       +
         buildCommand = ''

     

       12
       12
       +
           datadir="${nix}/share"

     

       13
       13
       +
           export TEST_ROOT=$(pwd)/test-tmp

     

       14
       14
       +
           export NIX_STORE_DIR=$TEST_ROOT/store

     

       15
       15
       +
           export NIX_LOCALSTATE_DIR=$TEST_ROOT/var

     

       16
       16
       +
           export NIX_LOG_DIR=$TEST_ROOT/var/log/nix

     

       17
       17
       +
           export NIX_STATE_DIR=$TEST_ROOT/var/nix

     

       18
       18
       +
           export NIX_DB_DIR=$TEST_ROOT/db

     

       19
       19
       +
           export NIX_CONF_DIR=$TEST_ROOT/etc

     

       20
       20
       +
           export NIX_MANIFESTS_DIR=$TEST_ROOT/var/nix/manifests

     

       21
       21
       +
           export NIX_BUILD_HOOK=

     

       22
       22
       +
           export PAGER=cat

     

       23
       23
       +
           cacheDir=$TEST_ROOT/binary-cache

     

       24
       24
       +
           nix-store --init

     

       25
       25
       +
       

     

       26
       26
       +
           cd ${nixpkgs}/lib/tests

     

       27
       27
       +
           ./modules.sh

     

       28
       28
       +
       

     

       29
       29
       +
           touch $out

     

       30
       30
       +
         '';

     

       31
       31
       +
       }

+2

pkgs/top-level/release.nix

···

       23
       23
        
           { tarball = import ./make-tarball.nix { inherit nixpkgs officialRelease; };

     

       24
       24
        
       

     

       25
       25
        
             manual = import ../../doc;

     

       26
       26
       +
             lib.tests = import ../../lib/tests/release.nix { inherit nixpkgs; };

     

       26
       27
        
       

     

       27
       28
        
             unstable = pkgs.releaseTools.aggregate

     

       28
       29
        
               { name = "nixpkgs-${jobs.tarball.version}";

     
···

       30
       31
        
                 constituents =

     

       31
       32
        
                   [ jobs.tarball

     

       32
       33
        
                     jobs.manual

     

       34
       34
       +
                     jobs.lib.tests

     

       33
       35
        
                     jobs.stdenv.x86_64-linux

     

       34
       36
        
                     jobs.stdenv.i686-linux

     

       35
       37
        
                     jobs.stdenv.x86_64-darwin