commit 0667ef5dd5cc7aa00e7d5ebf4391b7ee1d414a0c · pyrox.dev/nixpkgs

lib/path/tests/default.nix

···

       7
       7
        
           inherit system;

     

       8
       8
        
         },

     

       9
       9
        
         libpath ? ../..,

     

       10
       10
       +
         # Random seed

     

       11
       11
       +
         seed ? null,

     

       10
       12
        
       }:

     

       11
       13
        
       pkgs.runCommand "lib-path-tests" {

     

       12
       14
        
         nativeBuildInputs = with pkgs; [

     

       13
       15
        
           nix

     

       16
       16
       +
           jq

     

       17
       17
       +
           bc

     

       14
       18
        
         ];

     

       15
       19
        
       } ''

     

       16
       20
        
         # Needed to make Nix evaluation work

     
···

       22
       26
        
         echo "Running unit tests lib/path/tests/unit.nix"

     

       23
       27
        
         nix-instantiate --eval lib/path/tests/unit.nix \

     

       24
       28
        
           --argstr libpath "$TEST_LIB"

     

       29
       29
       +
       

     

       30
       30
       +
         echo "Running property tests lib/path/tests/prop.sh"

     

       31
       31
       +
         bash lib/path/tests/prop.sh ${toString seed}

     

       25
       32
        
       

     

       26
       33
        
         touch $out

     

       27
       34
        
       ''

+64

lib/path/tests/generate.awk

···

       1
       1
       +
       # Generate random path-like strings, separated by null characters.

     

       2
       2
       +
       #

     

       3
       3
       +
       # Invocation:

     

       4
       4
       +
       #

     

       5
       5
       +
       #     awk -f ./generate.awk -v <variable>=<value> | tr '\0' '\n'

     

       6
       6
       +
       #

     

       7
       7
       +
       # Customizable variables (all default to 0):

     

       8
       8
       +
       # - seed: Deterministic random seed to use for generation

     

       9
       9
       +
       # - count: Number of paths to generate

     

       10
       10
       +
       # - extradotweight: Give extra weight to dots being generated

     

       11
       11
       +
       # - extraslashweight: Give extra weight to slashes being generated

     

       12
       12
       +
       # - extranullweight: Give extra weight to null being generated, making paths shorter

     

       13
       13
       +
       BEGIN {

     

       14
       14
       +
         # Random seed, passed explicitly for reproducibility

     

       15
       15
       +
         srand(seed)

     

       16
       16
       +
       

     

       17
       17
       +
         # Don't include special characters below 32

     

       18
       18
       +
         minascii = 32

     

       19
       19
       +
         # Don't include DEL at 128

     

       20
       20
       +
         maxascii = 127

     

       21
       21
       +
         upperascii = maxascii - minascii

     

       22
       22
       +
       

     

       23
       23
       +
         # add extra weight for ., in addition to the one weight from the ascii range

     

       24
       24
       +
         upperdot = upperascii + extradotweight

     

       25
       25
       +
       

     

       26
       26
       +
         # add extra weight for /, in addition to the one weight from the ascii range

     

       27
       27
       +
         upperslash = upperdot + extraslashweight

     

       28
       28
       +
       

     

       29
       29
       +
         # add extra weight for null, indicating the end of the string

     

       30
       30
       +
         # Must be at least 1 to have strings end at all

     

       31
       31
       +
         total = upperslash + 1 + extranullweight

     

       32
       32
       +
       

     

       33
       33
       +
         # new=1 indicates that it's a new string

     

       34
       34
       +
         new=1

     

       35
       35
       +
         while (count > 0) {

     

       36
       36
       +
       

     

       37
       37
       +
           # Random integer between [0, total)

     

       38
       38
       +
           value = int(rand() * total)

     

       39
       39
       +
       

     

       40
       40
       +
           if (value < upperascii) {

     

       41
       41
       +
             # Ascii range

     

       42
       42
       +
             printf("%c", value + minascii)

     

       43
       43
       +
             new=0

     

       44
       44
       +
       

     

       45
       45
       +
           } else if (value < upperdot) {

     

       46
       46
       +
             # Dot range

     

       47
       47
       +
             printf "."

     

       48
       48
       +
             new=0

     

       49
       49
       +
       

     

       50
       50
       +
           } else if (value < upperslash) {

     

       51
       51
       +
             # If it's the start of a new path, only generate a / in 10% of cases

     

       52
       52
       +
             # This is always an invalid subpath, which is not a very interesting case

     

       53
       53
       +
             if (new && rand() > 0.1) continue

     

       54
       54
       +
             printf "/"

     

       55
       55
       +
       

     

       56
       56
       +
           } else {

     

       57
       57
       +
             # Do not generate empty strings

     

       58
       58
       +
             if (new) continue

     

       59
       59
       +
             printf "\x00"

     

       60
       60
       +
             count--

     

       61
       61
       +
             new=1

     

       62
       62
       +
           }

     

       63
       63
       +
         }

     

       64
       64
       +
       }

+60

lib/path/tests/prop.nix

···

       1
       1
       +
       # Given a list of path-like strings, check some properties of the path library

     

       2
       2
       +
       # using those paths and return a list of attribute sets of the following form:

     

       3
       3
       +
       #

     

       4
       4
       +
       #     { <string> = <lib.path.subpath.normalise string>; }

     

       5
       5
       +
       #

     

       6
       6
       +
       # If `normalise` fails to evaluate, the attribute value is set to `""`.

     

       7
       7
       +
       # If not, the resulting value is normalised again and an appropriate attribute set added to the output list.

     

       8
       8
       +
       {

     

       9
       9
       +
         # The path to the nixpkgs lib to use

     

       10
       10
       +
         libpath,

     

       11
       11
       +
         # A flat directory containing files with randomly-generated

     

       12
       12
       +
         # path-like values

     

       13
       13
       +
         dir,

     

       14
       14
       +
       }:

     

       15
       15
       +
       let

     

       16
       16
       +
         lib = import libpath;

     

       17
       17
       +
       

     

       18
       18
       +
         # read each file into a string

     

       19
       19
       +
         strings = map (name:

     

       20
       20
       +
           builtins.readFile (dir + "/${name}")

     

       21
       21
       +
         ) (builtins.attrNames (builtins.readDir dir));

     

       22
       22
       +
       

     

       23
       23
       +
         inherit (lib.path.subpath) normalise isValid;

     

       24
       24
       +
         inherit (lib.asserts) assertMsg;

     

       25
       25
       +
       

     

       26
       26
       +
         normaliseAndCheck = str:

     

       27
       27
       +
           let

     

       28
       28
       +
             originalValid = isValid str;

     

       29
       29
       +
       

     

       30
       30
       +
             tryOnce = builtins.tryEval (normalise str);

     

       31
       31
       +
             tryTwice = builtins.tryEval (normalise tryOnce.value);

     

       32
       32
       +
       

     

       33
       33
       +
             absConcatOrig = /. + ("/" + str);

     

       34
       34
       +
             absConcatNormalised = /. + ("/" + tryOnce.value);

     

       35
       35
       +
           in

     

       36
       36
       +
             # Check the lib.path.subpath.normalise property to only error on invalid subpaths

     

       37
       37
       +
             assert assertMsg

     

       38
       38
       +
               (originalValid -> tryOnce.success)

     

       39
       39
       +
               "Even though string \"${str}\" is valid as a subpath, the normalisation for it failed";

     

       40
       40
       +
             assert assertMsg

     

       41
       41
       +
               (! originalValid -> ! tryOnce.success)

     

       42
       42
       +
               "Even though string \"${str}\" is invalid as a subpath, the normalisation for it succeeded";

     

       43
       43
       +
       

     

       44
       44
       +
             # Check normalisation idempotency

     

       45
       45
       +
             assert assertMsg

     

       46
       46
       +
               (originalValid -> tryTwice.success)

     

       47
       47
       +
               "For valid subpath \"${str}\", the normalisation \"${tryOnce.value}\" was not a valid subpath";

     

       48
       48
       +
             assert assertMsg

     

       49
       49
       +
               (originalValid -> tryOnce.value == tryTwice.value)

     

       50
       50
       +
               "For valid subpath \"${str}\", normalising it once gives \"${tryOnce.value}\" but normalising it twice gives a different result: \"${tryTwice.value}\"";

     

       51
       51
       +
       

     

       52
       52
       +
             # Check that normalisation doesn't change a string when appended to an absolute Nix path value

     

       53
       53
       +
             assert assertMsg

     

       54
       54
       +
               (originalValid -> absConcatOrig == absConcatNormalised)

     

       55
       55
       +
               "For valid subpath \"${str}\", appending to an absolute Nix path value gives \"${absConcatOrig}\", but appending the normalised result \"${tryOnce.value}\" gives a different value \"${absConcatNormalised}\"";

     

       56
       56
       +
       

     

       57
       57
       +
             # Return an empty string when failed

     

       58
       58
       +
             if tryOnce.success then tryOnce.value else "";

     

       59
       59
       +
       

     

       60
       60
       +
       in lib.genAttrs strings normaliseAndCheck

+179

lib/path/tests/prop.sh

···

       1
       1
       +
       #!/usr/bin/env bash

     

       2
       2
       +
       

     

       3
       3
       +
       # Property tests for the `lib.path` library

     

       4
       4
       +
       #

     

       5
       5
       +
       # It generates random path-like strings and runs the functions on

     

       6
       6
       +
       # them, checking that the expected laws of the functions hold

     

       7
       7
       +
       

     

       8
       8
       +
       set -euo pipefail

     

       9
       9
       +
       shopt -s inherit_errexit

     

       10
       10
       +
       

     

       11
       11
       +
       # https://stackoverflow.com/a/246128

     

       12
       12
       +
       SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

     

       13
       13
       +
       

     

       14
       14
       +
       if test -z "${TEST_LIB:-}"; then

     

       15
       15
       +
           TEST_LIB=$SCRIPT_DIR/../..

     

       16
       16
       +
       fi

     

       17
       17
       +
       

     

       18
       18
       +
       tmp="$(mktemp -d)"

     

       19
       19
       +
       clean_up() {

     

       20
       20
       +
           rm -rf "$tmp"

     

       21
       21
       +
       }

     

       22
       22
       +
       trap clean_up EXIT

     

       23
       23
       +
       mkdir -p "$tmp/work"

     

       24
       24
       +
       cd "$tmp/work"

     

       25
       25
       +
       

     

       26
       26
       +
       # Defaulting to a random seed but the first argument can override this

     

       27
       27
       +
       seed=${1:-$RANDOM}

     

       28
       28
       +
       echo >&2 "Using seed $seed, use \`lib/path/tests/prop.sh $seed\` to reproduce this result"

     

       29
       29
       +
       

     

       30
       30
       +
       # The number of random paths to generate. This specific number was chosen to

     

       31
       31
       +
       # be fast enough while still generating enough variety to detect bugs.

     

       32
       32
       +
       count=500

     

       33
       33
       +
       

     

       34
       34
       +
       debug=0

     

       35
       35
       +
       # debug=1 # print some extra info

     

       36
       36
       +
       # debug=2 # print generated values

     

       37
       37
       +
       

     

       38
       38
       +
       # Fine tuning parameters to balance the number of generated invalid paths

     

       39
       39
       +
       # to the variance in generated paths.

     

       40
       40
       +
       extradotweight=64   # Larger value: more dots

     

       41
       41
       +
       extraslashweight=64 # Larger value: more slashes

     

       42
       42
       +
       extranullweight=16  # Larger value: shorter strings

     

       43
       43
       +
       

     

       44
       44
       +
       die() {

     

       45
       45
       +
           echo >&2 "test case failed: " "$@"

     

       46
       46
       +
           exit 1

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       if [[ "$debug" -ge 1 ]]; then

     

       50
       50
       +
           echo >&2 "Generating $count random path-like strings"

     

       51
       51
       +
       fi

     

       52
       52
       +
       

     

       53
       53
       +
       # Read stream of null-terminated strings entry-by-entry into bash,

     

       54
       54
       +
       # write it to a file and the `strings` array.

     

       55
       55
       +
       declare -a strings=()

     

       56
       56
       +
       mkdir -p "$tmp/strings"

     

       57
       57
       +
       while IFS= read -r -d $'\0' str; do

     

       58
       58
       +
           echo -n "$str" > "$tmp/strings/${#strings[@]}"

     

       59
       59
       +
           strings+=("$str")

     

       60
       60
       +
       done < <(awk \

     

       61
       61
       +
           -f "$SCRIPT_DIR"/generate.awk \

     

       62
       62
       +
           -v seed="$seed" \

     

       63
       63
       +
           -v count="$count" \

     

       64
       64
       +
           -v extradotweight="$extradotweight" \

     

       65
       65
       +
           -v extraslashweight="$extraslashweight" \

     

       66
       66
       +
           -v extranullweight="$extranullweight")

     

       67
       67
       +
       

     

       68
       68
       +
       if [[ "$debug" -ge 1 ]]; then

     

       69
       69
       +
           echo >&2 "Trying to normalise the generated path-like strings with Nix"

     

       70
       70
       +
       fi

     

       71
       71
       +
       

     

       72
       72
       +
       # Precalculate all normalisations with a single Nix call. Calling Nix for each

     

       73
       73
       +
       # string individually would take way too long

     

       74
       74
       +
       nix-instantiate --eval --strict --json \

     

       75
       75
       +
           --argstr libpath "$TEST_LIB" \

     

       76
       76
       +
           --argstr dir "$tmp/strings" \

     

       77
       77
       +
           "$SCRIPT_DIR"/prop.nix \

     

       78
       78
       +
           >"$tmp/result.json"

     

       79
       79
       +
       

     

       80
       80
       +
       # Uses some jq magic to turn the resulting attribute set into an associative

     

       81
       81
       +
       # bash array assignment

     

       82
       82
       +
       declare -A normalised_result="($(jq '

     

       83
       83
       +
           to_entries

     

       84
       84
       +
           | map("[\(.key | @sh)]=\(.value | @sh)")

     

       85
       85
       +
           | join(" \n")' -r < "$tmp/result.json"))"

     

       86
       86
       +
       

     

       87
       87
       +
       # Looks up a normalisation result for a string

     

       88
       88
       +
       # Checks that the normalisation is only failing iff it's an invalid subpath

     

       89
       89
       +
       # For valid subpaths, returns 0 and prints the normalisation result

     

       90
       90
       +
       # For invalid subpaths, returns 1

     

       91
       91
       +
       normalise() {

     

       92
       92
       +
           local str=$1

     

       93
       93
       +
           # Uses the same check for validity as in the library implementation

     

       94
       94
       +
           if [[ "$str" == "" || "$str" == /* || "$str" =~ ^(.*/)?\.\.(/.*)?$ ]]; then

     

       95
       95
       +
               valid=

     

       96
       96
       +
           else

     

       97
       97
       +
               valid=1

     

       98
       98
       +
           fi

     

       99
       99
       +
       

     

       100
       100
       +
           normalised=${normalised_result[$str]}

     

       101
       101
       +
           # An empty string indicates failure, this is encoded in ./prop.nix

     

       102
       102
       +
           if [[ -n "$normalised" ]]; then

     

       103
       103
       +
               if [[ -n "$valid" ]]; then

     

       104
       104
       +
                   echo "$normalised"

     

       105
       105
       +
               else

     

       106
       106
       +
                   die "For invalid subpath \"$str\", lib.path.subpath.normalise returned this result: \"$normalised\""

     

       107
       107
       +
               fi

     

       108
       108
       +
           else

     

       109
       109
       +
               if [[ -n "$valid" ]]; then

     

       110
       110
       +
                   die "For valid subpath \"$str\", lib.path.subpath.normalise failed"

     

       111
       111
       +
               else

     

       112
       112
       +
                   if [[ "$debug" -ge 2 ]]; then

     

       113
       113
       +
                       echo >&2 "String \"$str\" is not a valid subpath"

     

       114
       114
       +
                   fi

     

       115
       115
       +
                   # Invalid and it correctly failed, we let the caller continue if they catch the exit code

     

       116
       116
       +
                   return 1

     

       117
       117
       +
               fi

     

       118
       118
       +
           fi

     

       119
       119
       +
       }

     

       120
       120
       +
       

     

       121
       121
       +
       # Intermediate result populated by test_idempotency_realpath

     

       122
       122
       +
       # and used in test_normalise_uniqueness

     

       123
       123
       +
       #

     

       124
       124
       +
       # Contains a mapping from a normalised subpath to the realpath result it represents

     

       125
       125
       +
       declare -A norm_to_real

     

       126
       126
       +
       

     

       127
       127
       +
       test_idempotency_realpath() {

     

       128
       128
       +
           if [[ "$debug" -ge 1 ]]; then

     

       129
       129
       +
               echo >&2 "Checking idempotency of each result and making sure the realpath result isn't changed"

     

       130
       130
       +
           fi

     

       131
       131
       +
       

     

       132
       132
       +
           # Count invalid subpaths to display stats

     

       133
       133
       +
           invalid=0

     

       134
       134
       +
           for str in "${strings[@]}"; do

     

       135
       135
       +
               if ! result=$(normalise "$str"); then

     

       136
       136
       +
                   ((invalid++)) || true

     

       137
       137
       +
                   continue

     

       138
       138
       +
               fi

     

       139
       139
       +
       

     

       140
       140
       +
               # Check the law that it doesn't change the result of a realpath

     

       141
       141
       +
               mkdir -p -- "$str" "$result"

     

       142
       142
       +
               real_orig=$(realpath -- "$str")

     

       143
       143
       +
               real_norm=$(realpath -- "$result")

     

       144
       144
       +
       

     

       145
       145
       +
               if [[ "$real_orig" != "$real_norm" ]]; then

     

       146
       146
       +
                   die "realpath of the original string \"$str\" (\"$real_orig\") is not the same as realpath of the normalisation \"$result\" (\"$real_norm\")"

     

       147
       147
       +
               fi

     

       148
       148
       +
       

     

       149
       149
       +
               if [[ "$debug" -ge 2 ]]; then

     

       150
       150
       +
                   echo >&2 "String \"$str\" gets normalised to \"$result\" and file path \"$real_orig\""

     

       151
       151
       +
               fi

     

       152
       152
       +
               norm_to_real["$result"]="$real_orig"

     

       153
       153
       +
           done

     

       154
       154
       +
           if [[ "$debug" -ge 1 ]]; then

     

       155
       155
       +
               echo >&2 "$(bc <<< "scale=1; 100 / $count * $invalid")% of the total $count generated strings were invalid subpath strings, and were therefore ignored"

     

       156
       156
       +
           fi

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       test_normalise_uniqueness() {

     

       160
       160
       +
           if [[ "$debug" -ge 1 ]]; then

     

       161
       161
       +
               echo >&2 "Checking for the uniqueness law"

     

       162
       162
       +
           fi

     

       163
       163
       +
       

     

       164
       164
       +
           for norm_p in "${!norm_to_real[@]}"; do

     

       165
       165
       +
               real_p=${norm_to_real["$norm_p"]}

     

       166
       166
       +
               for norm_q in "${!norm_to_real[@]}"; do

     

       167
       167
       +
                   real_q=${norm_to_real["$norm_q"]}

     

       168
       168
       +
                   # Checks normalisation uniqueness law for each pair of values

     

       169
       169
       +
                   if [[ "$norm_p" != "$norm_q" && "$real_p" == "$real_q" ]]; then

     

       170
       170
       +
                       die "Normalisations \"$norm_p\" and \"$norm_q\" are different, but the realpath of them is the same: \"$real_p\""

     

       171
       171
       +
                   fi

     

       172
       172
       +
               done

     

       173
       173
       +
           done

     

       174
       174
       +
       }

     

       175
       175
       +
       

     

       176
       176
       +
       test_idempotency_realpath

     

       177
       177
       +
       test_normalise_uniqueness

     

       178
       178
       +
       

     

       179
       179
       +
       echo >&2 tests ok