pkgs/pkgs-lib/tests/formats.nix

   1 { pkgs }:
   2 let
   3   inherit (pkgs) lib formats;
   4 in
   5 with lib;
   6 let
   7
   8   evalFormat = format: args: def:
   9     let
  10       formatSet = format args;
  11       config = formatSet.type.merge [] (imap1 (n: def: {
  12         # We check the input values, so that
  13         #  - we don't write nonsensical tests that will impede progress
  14         #  - the test author has a slightly more realistic view of the
  15         #    final format during development.
  16         value = lib.throwIfNot (formatSet.type.check def) (builtins.trace def "definition does not pass the type's check function") def;
  17         file = "def${toString n}";
  18       }) [ def ]);
  19     in formatSet.generate "test-format-file" config;
  20
  21   runBuildTest = name: { drv, expected }: pkgs.runCommand name {
  22     passAsFile = ["expected"];
  23     inherit expected drv;
  24   } ''
  25     if diff -u "$expectedPath" "$drv"; then
  26       touch "$out"
  27     else
  28       echo
  29       echo "Got different values than expected; diff above."
  30       exit 1
  31     fi
  32   '';
  33
  34   runBuildTests = tests: pkgs.linkFarm "nixpkgs-pkgs-lib-format-tests" (mapAttrsToList (name: value: { inherit name; path = runBuildTest name value; }) (filterAttrs (name: value: value != null) tests));
  35
  36 in runBuildTests {
  37
  38   testJsonAtoms = {
  39     drv = evalFormat formats.json {} {
  40       null = null;
  41       false = false;
  42       true = true;
  43       int = 10;
  44       float = 3.141;
  45       str = "foo";
  46       attrs.foo = null;
  47       list = [ null null ];
  48       path = ./formats.nix;
  49     };
  50     expected = ''
  51       {
  52         "attrs": {
  53           "foo": null
  54         },
  55         "false": false,
  56         "float": 3.141,
  57         "int": 10,
  58         "list": [
  59           null,
  60           null
  61         ],
  62         "null": null,
  63         "path": "${./formats.nix}",
  64         "str": "foo",
  65         "true": true
  66       }
  67     '';
  68   };
  69
  70   testYamlAtoms = {
  71     drv = evalFormat formats.yaml {} {
  72       null = null;
  73       false = false;
  74       true = true;
  75       float = 3.141;
  76       str = "foo";
  77       attrs.foo = null;
  78       list = [ null null ];
  79       path = ./formats.nix;
  80     };
  81     expected = ''
  82       attrs:
  83         foo: null
  84       'false': false
  85       float: 3.141
  86       list:
  87       - null
  88       - null
  89       'null': null
  90       path: ${./formats.nix}
  91       str: foo
  92       'true': true
  93     '';
  94   };
  95
  96   testIniAtoms = {
  97     drv = evalFormat formats.ini {} {
  98       foo = {
  99         bool = true;
 100         int = 10;
 101         float = 3.141;
 102         str = "string";
 103       };
 104     };
 105     expected = ''
 106       [foo]
 107       bool=true
 108       float=3.141000
 109       int=10
 110       str=string
 111     '';
 112   };
 113
 114   testIniDuplicateKeys = {
 115     drv = evalFormat formats.ini { listsAsDuplicateKeys = true; } {
 116       foo = {
 117         bar = [ null true "test" 1.2 10 ];
 118         baz = false;
 119         qux = "qux";
 120       };
 121     };
 122     expected = ''
 123       [foo]
 124       bar=null
 125       bar=true
 126       bar=test
 127       bar=1.200000
 128       bar=10
 129       baz=false
 130       qux=qux
 131     '';
 132   };
 133
 134   testIniListToValue = {
 135     drv = evalFormat formats.ini { listToValue = concatMapStringsSep ", " (generators.mkValueStringDefault {}); } {
 136       foo = {
 137         bar = [ null true "test" 1.2 10 ];
 138         baz = false;
 139         qux = "qux";
 140       };
 141     };
 142     expected = ''
 143       [foo]
 144       bar=null, true, test, 1.200000, 10
 145       baz=false
 146       qux=qux
 147     '';
 148   };
 149
 150   testKeyValueAtoms = {
 151     drv = evalFormat formats.keyValue {} {
 152       bool = true;
 153       int = 10;
 154       float = 3.141;
 155       str = "string";
 156     };
 157     expected = ''
 158       bool=true
 159       float=3.141000
 160       int=10
 161       str=string
 162     '';
 163   };
 164
 165   testKeyValueDuplicateKeys = {
 166     drv = evalFormat formats.keyValue { listsAsDuplicateKeys = true; } {
 167       bar = [ null true "test" 1.2 10 ];
 168       baz = false;
 169       qux = "qux";
 170     };
 171     expected = ''
 172       bar=null
 173       bar=true
 174       bar=test
 175       bar=1.200000
 176       bar=10
 177       baz=false
 178       qux=qux
 179     '';
 180   };
 181
 182   testKeyValueListToValue = {
 183     drv = evalFormat formats.keyValue { listToValue = concatMapStringsSep ", " (generators.mkValueStringDefault {}); } {
 184       bar = [ null true "test" 1.2 10 ];
 185       baz = false;
 186       qux = "qux";
 187     };
 188     expected = ''
 189       bar=null, true, test, 1.200000, 10
 190       baz=false
 191       qux=qux
 192     '';
 193   };
 194
 195   testTomlAtoms = {
 196     drv = evalFormat formats.toml {} {
 197       false = false;
 198       true = true;
 199       int = 10;
 200       float = 3.141;
 201       str = "foo";
 202       attrs.foo = "foo";
 203       list = [ 1 2 ];
 204       level1.level2.level3.level4 = "deep";
 205     };
 206     expected = ''
 207       false = false
 208       float = 3.141
 209       int = 10
 210       list = [1, 2]
 211       str = "foo"
 212       true = true
 213       [attrs]
 214       foo = "foo"
 215
 216       [level1.level2.level3]
 217       level4 = "deep"
 218     '';
 219   };
 220
 221   # This test is responsible for
 222   #   1. testing type coercions
 223   #   2. providing a more readable example test
 224   # Whereas java-properties/default.nix tests the low level escaping, etc.
 225   testJavaProperties = {
 226     drv = evalFormat formats.javaProperties {} {
 227       floaty = 3.1415;
 228       tautologies = true;
 229       contradictions = false;
 230       foo = "bar";
 231       # # Disallowed at eval time, because it's ambiguous:
 232       # # add to store or convert to string?
 233       # root = /root;
 234       "1" = 2;
 235       package = pkgs.hello;
 236       "ütf 8" = "dûh";
 237       # NB: Some editors (vscode) show this _whole_ line in right-to-left order
 238       "الجبر" = "أكثر من مجرد أرقام";
 239     };
 240     expected = ''
 241       # Generated with Nix
 242
 243       1 = 2
 244       contradictions = false
 245       floaty = 3.141500
 246       foo = bar
 247       package = ${pkgs.hello}
 248       tautologies = true
 249       \u00fctf\ 8 = d\u00fbh
 250       \u0627\u0644\u062c\u0628\u0631 = \u0623\u0643\u062b\u0631 \u0645\u0646 \u0645\u062c\u0631\u062f \u0623\u0631\u0642\u0627\u0645
 251     '';
 252   };
 253 }