+509 -58

checkmate/modules/tests.nix

··· 1 1 - { inputs, lib, ... }: 2 2 - let 3 3 - targetNix = "${inputs.target}/nix"; 4 4 - targetLib = "${inputs.target}/nix/lib.nix"; 5 5 - targetMod = "${inputs.target}/nix/flakeModule.nix"; 1 1 + { inputs, ... }: 2 2 + { 3 3 + perSystem = 4 4 + { lib, ... }: 5 5 + let 6 6 + transpose = import ../../nix { inherit lib; }; 6 7 7 7 - transpose = import targetNix { inherit lib; }; 8 8 + mkFlake = 9 9 + mod: 10 10 + inputs.flake-parts.lib.mkFlake 11 11 + { 12 12 + inputs.self = [ ]; 13 13 + } 14 14 + { 15 15 + systems = [ ]; 16 16 + imports = [ 17 17 + ../../nix/flakeModule.nix 18 18 + inputs.flake-parts.flakeModules.modules 19 19 + mod 20 20 + (fooMod "aspectOne") 21 21 + (fooMod "aspectTwo") 22 22 + (fooMod "aspectThree") 23 23 + ]; 24 24 + }; 8 25 9 9 - mkFlake = 10 10 - mod: 11 11 - inputs.flake-parts.lib.mkFlake 12 12 - { 13 13 - inputs.self = [ ]; 14 14 - } 15 15 - { 16 16 - systems = [ ]; 26 26 + fooMod = aspect: { 17 27 imports = [ 18 18 - targetMod 19 19 - inputs.flake-parts.flakeModules.modules 20 20 - mod 21 21 - (fooMod "aspectOne") 22 22 - (fooMod "aspectTwo") 23 23 - (fooMod "aspectThree") 28 28 + { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; } 29 29 + { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; } 30 30 + { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; } 24 31 ]; 25 32 }; 26 33 27 27 - fooMod = aspect: { 28 28 - imports = [ 29 29 - { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; } 30 30 - { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; } 31 31 - { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; } 32 32 - ]; 33 33 - }; 34 34 + fooOpt = { 35 35 + options.foo = lib.mkOption { 36 36 + type = lib.types.str; 37 37 + default = "<unset>"; 38 38 + }; 39 39 + options.bar = lib.mkOption { 40 40 + type = lib.types.listOf lib.types.str; 41 41 + default = [ ]; 42 42 + }; 43 43 + options.baz = lib.mkOption { 44 44 + type = lib.types.lazyAttrsOf lib.types.str; 45 45 + default = { }; 46 46 + }; 47 47 + }; 48 48 + 49 49 + evalMod = 50 50 + class: mod: 51 51 + (lib.evalModules { 52 52 + inherit class; 53 53 + modules = [ mod ]; 54 54 + }).config; 55 55 + in 56 56 + { 57 57 + nix-unit.tests = { 58 58 + transpose."test swaps parent and child attrNames" = { 59 59 + expr = transpose { a.b.c = 1; }; 60 60 + expected = { 61 61 + b.a.c = 1; 62 62 + }; 63 63 + }; 64 64 + 65 65 + transpose."test common childs become one parent" = { 66 66 + expr = transpose { 67 67 + a.b = 1; 68 68 + c.b = 2; 69 69 + }; 70 70 + expected.b = { 71 71 + a = 1; 72 72 + c = 2; 73 73 + }; 74 74 + }; 75 75 + 76 76 + new-scope."test usage without flakes" = 77 77 + let 78 78 + flake-aspects-lib = import ../../nix/lib.nix lib; 79 79 + # first eval is like evaling the flake. 80 80 + first = lib.evalModules { 81 81 + modules = [ 82 82 + (flake-aspects-lib.new-scope "hello") 83 83 + { 84 84 + hello.aspects = 85 85 + { aspects, ... }: 86 86 + { 87 87 + a.b.c = [ "world" ]; 88 88 + a.includes = [ aspects.x ]; 89 89 + x.b = 90 90 + { lib, ... }: 91 91 + { 92 92 + c = lib.splitString " " "mundo cruel"; 93 93 + }; 94 94 + }; 95 95 + } 96 96 + ]; 97 97 + }; 98 98 + # second eval is like evaling its nixosConfiguration 99 99 + second = lib.evalModules { 100 100 + modules = [ 101 101 + { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; } 102 102 + first.config.hello.modules.b.a 103 103 + ]; 104 104 + }; 105 105 + expr = lib.sort (a: b: a < b) second.config.c; 106 106 + expected = [ 107 107 + "cruel" 108 108 + "mundo" 109 109 + "world" 110 110 + ]; 111 111 + in 112 112 + { 113 113 + inherit expr expected; 114 114 + }; 115 115 + 116 116 + aspects."test provides default" = 117 117 + let 118 118 + flake = 119 119 + inputs.flake-parts.lib.mkFlake 120 120 + { 121 121 + inputs.self = [ ]; 122 122 + moduleLocation = builtins.toString ./.; 123 123 + } 124 124 + { 125 125 + systems = [ ]; 126 126 + imports = [ 127 127 + ../../nix/flakeModule.nix 128 128 + inputs.flake-parts.flakeModules.modules 129 129 + ]; 130 130 + }; 131 131 + expr = flake.modules; 132 132 + expected = { }; 133 133 + in 134 134 + { 135 135 + inherit expr expected; 136 136 + }; 137 137 + 138 138 + aspects."test transposes to flake.modules" = 139 139 + let 140 140 + flake = mkFlake { 141 141 + flake.aspects.aspectOne = { 142 142 + classOne.foo = "niri"; 143 143 + classTwo.foo = "paper.spoon"; 144 144 + }; 145 145 + }; 146 146 + expr = { 147 147 + classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo; 148 148 + classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo; 149 149 + }; 150 150 + expected = { 151 151 + classOne = "niri"; 152 152 + classTwo = "paper.spoon"; 153 153 + }; 154 154 + in 155 155 + { 156 156 + inherit expr expected; 157 157 + }; 158 158 + 159 159 + aspects."test dependencies on aspects" = 160 160 + let 161 161 + flake = mkFlake { 162 162 + flake.aspects = 163 163 + { aspects, ... }: 164 164 + { 165 165 + aspectOne = { 166 166 + description = "os config"; 167 167 + includes = with aspects; [ aspectTwo ]; 168 168 + classOne.bar = [ "os" ]; 169 169 + }; 170 170 + 171 171 + aspectTwo = { 172 172 + description = "user config at os level"; 173 173 + classOne.bar = [ "user" ]; 174 174 + }; 175 175 + }; 176 176 + }; 177 177 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 178 178 + expected = [ 179 179 + "os" 180 180 + "user" 181 181 + ]; 182 182 + in 183 183 + { 184 184 + inherit expr expected; 185 185 + }; 186 186 + 187 187 + aspects."test resolve aspect-chain" = 188 188 + let 189 189 + flake = mkFlake { 190 190 + flake.aspects = 191 191 + { aspects, ... }: 192 192 + { 193 193 + aspectOne = { 194 194 + name = "one"; 195 195 + includes = [ aspects.aspectOne.provides.dos ]; 196 196 + classOne.bar = [ "zzz" ]; 197 197 + provides.dos = 198 198 + { aspect-chain, ... }: 199 199 + { 200 200 + name = "dos"; 201 201 + includes = [ aspects.aspectOne.provides.tres ]; 202 202 + classOne.bar = map (x: x.name) aspect-chain; 203 203 + }; 204 204 + 205 205 + provides.tres = 206 206 + { aspect-chain, ... }: 207 207 + { 208 208 + name = "tres"; 209 209 + classOne.bar = [ (lib.last aspect-chain).name ]; 210 210 + }; 211 211 + }; 212 212 + }; 213 213 + }; 214 214 + mod = { 215 215 + imports = [ 216 216 + fooOpt 217 217 + (flake.aspects.aspectOne.resolve { class = "classOne"; }) 218 218 + ]; 219 219 + }; 220 220 + expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 221 221 + expected = [ 222 222 + "dos" 223 223 + "one" 224 224 + "zzz" 225 225 + ]; 226 226 + in 227 227 + { 228 228 + inherit expr expected; 229 229 + }; 230 230 + 231 231 + aspects."test modules resolved" = 232 232 + let 233 233 + flake = mkFlake { 234 234 + flake.aspects = 235 235 + { aspects, ... }: 236 236 + { 237 237 + aspectOne = { 238 238 + name = "one"; 239 239 + includes = [ aspects.aspectOne.provides.dos ]; 240 240 + classOne.bar = [ "zzz" ]; 241 241 + provides.dos = 242 242 + { aspect-chain, ... }: 243 243 + { 244 244 + name = "dos"; 245 245 + includes = [ aspects.aspectOne.provides.tres ]; 246 246 + classOne.bar = map (x: x.name) aspect-chain; 247 247 + }; 248 248 + 249 249 + provides.tres = 250 250 + { aspect-chain, ... }: 251 251 + { 252 252 + name = "tres"; 253 253 + classOne.bar = [ (lib.last aspect-chain).name ]; 254 254 + }; 255 255 + }; 256 256 + }; 257 257 + }; 258 258 + mod = { 259 259 + imports = [ 260 260 + fooOpt 261 261 + (flake.aspects.aspectOne.modules.classOne) 262 262 + ]; 263 263 + }; 264 264 + expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 265 265 + expected = [ 266 266 + "dos" 267 267 + "one" 268 268 + "zzz" 269 269 + ]; 270 270 + in 271 271 + { 272 272 + inherit expr expected; 273 273 + }; 274 274 + 275 275 + aspects."test provides" = 276 276 + let 277 277 + flake = mkFlake { 278 278 + flake.aspects = 279 279 + { aspects, ... }: 280 280 + { 281 281 + aspectOne.includes = with aspects.aspectTwo.provides; [ 282 282 + foo 283 283 + bar 284 284 + ]; 285 285 + aspectOne.classOne = { }; # must be present for mixing dependencies. 286 286 + aspectTwo = { 287 287 + classOne.bar = [ "class one not included" ]; 288 288 + classTwo.bar = [ "class two not included" ]; 289 289 + provides.foo = 290 290 + { class, aspect-chain }: 291 291 + { 292 292 + name = "aspectTwo.foo"; 293 293 + description = "aspectTwo foo provided"; 294 294 + includes = [ 295 295 + aspects.aspectThree.provides.moo 296 296 + aspects.aspectTwo.provides.baz 297 297 + ]; 298 298 + classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 299 299 + classTwo.bar = [ "foo class two not included" ]; 300 300 + }; 301 301 + # a provider can be immediately an aspect object. 302 302 + provides.bar = { 303 303 + # classOne is missing on bar 304 304 + classTwo.bar = [ "bar class two not included" ]; 305 305 + }; 306 306 + # _ is an shortcut alias of provides. 307 307 + _.baz = { 308 308 + # classOne is missing on bar 309 309 + classTwo.bar = [ "baz" ]; 310 310 + }; 311 311 + }; 312 312 + aspectThree.provides.moo = 313 313 + { aspect-chain, class }: 314 314 + { 315 315 + classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 316 316 + }; 317 317 + }; 318 318 + }; 319 319 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 320 320 + expected = [ 321 321 + "three:classOne:aspectOne/aspectTwo.foo" 322 322 + "two:classOne:aspectOne" 323 323 + ]; 324 324 + in 325 325 + { 326 326 + inherit expr expected; 327 327 + }; 328 328 + 329 329 + aspects."test provides using fixpoints" = 330 330 + let 331 331 + flake = mkFlake { 332 332 + flake.aspects = 333 333 + { aspects, ... }: 334 334 + { 335 335 + aspectOne = { 336 336 + classOne.bar = [ "1" ]; 337 337 + includes = [ 338 338 + aspects.aspectTwo 339 339 + ]; 340 340 + }; 341 341 + 342 342 + aspectTwo = { 343 343 + classOne.bar = [ "2" ]; 344 344 + includes = [ aspects.aspectTwo.provides.three-and-four-and-five ]; 345 345 + provides = 346 346 + { provides, ... }: 347 347 + { 348 348 + three-and-four-and-five = { 349 349 + classOne.bar = [ "3" ]; 350 350 + includes = [ 351 351 + provides.four 352 352 + aspects.five 353 353 + ]; 354 354 + }; 355 355 + four = { 356 356 + classOne.bar = [ "4" ]; 357 357 + }; 358 358 + }; 359 359 + }; 360 360 + 361 361 + five.classOne.bar = [ "5" ]; 362 362 + }; 363 363 + }; 364 364 + 365 365 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 366 366 + expected = [ 367 367 + "1" 368 368 + "2" 369 369 + "3" 370 370 + "4" 371 371 + "5" 372 372 + ]; 373 373 + in 374 374 + { 375 375 + inherit expr expected; 376 376 + }; 377 377 + 378 378 + aspects."test provides parametrized modules" = 379 379 + let 380 380 + flake = mkFlake { 381 381 + flake.aspects = 382 382 + { aspects, ... }: 383 383 + { 384 384 + aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ]; 385 385 + aspectOne.classOne.bar = [ "1" ]; 386 386 + 387 387 + aspectTwo.provides.hello = world: { 388 388 + classOne.bar = [ world ]; 389 389 + }; 390 390 + }; 391 391 + }; 392 392 + 393 393 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 394 394 + expected = [ 395 395 + "1" 396 396 + "mundo" 397 397 + ]; 398 398 + in 399 399 + { 400 400 + inherit expr expected; 401 401 + }; 402 402 + 403 403 + aspects."test override default provider" = 404 404 + let 405 405 + flake = mkFlake { 406 406 + flake.aspects = 407 407 + { aspects, ... }: 408 408 + { 409 409 + aspectOne = 410 410 + { aspect, ... }: 411 411 + { 412 412 + includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ]; 413 413 + classOne = { }; # required for propagation 414 414 + }; 415 415 + 416 416 + aspectTwo.__functor = 417 417 + _: 418 418 + { message }: # args must be always named 419 419 + { class, aspect-chain }: 420 420 + { aspect, ... }: 421 421 + { 422 422 + classOne.bar = [ 423 423 + "foo" 424 424 + aspect.name 425 425 + message 426 426 + class 427 427 + ] 428 428 + ++ (lib.map (x: x.name) aspect-chain); 429 429 + }; 430 430 + aspectTwo.classOne.bar = [ "itself not included" ]; 431 431 + }; 432 432 + }; 433 433 + 434 434 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 435 435 + expected = [ 436 436 + "foo" 437 437 + "<function body>" 438 438 + "hello aspectOne" 439 439 + "classOne" 440 440 + "aspectOne" 441 441 + ]; 442 442 + in 443 443 + { 444 444 + inherit expr expected; 445 445 + }; 446 446 + 447 447 + aspects."test override default provider includes" = 448 448 + let 449 449 + flake = mkFlake { 450 450 + flake.aspects = 451 451 + { aspects, ... }: 452 452 + { 453 453 + aspectOne = { 454 454 + classOne.bar = [ "should-not-be-present" ]; 455 455 + includes = [ aspects.aspectTwo ]; 456 456 + __functor = aspect: { 457 457 + includes = [ 458 458 + { classOne.bar = [ "from-functor" ]; } 459 459 + ] 460 460 + ++ map (f: f { message = "hello"; }) aspect.includes; 461 461 + }; 462 462 + }; 463 463 + aspectTwo.__functor = 464 464 + _aspect: 465 465 + { message }: 466 466 + { 467 467 + classOne.bar = [ message ]; 468 468 + }; 469 469 + }; 470 470 + }; 471 471 + 472 472 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 473 473 + expected = [ 474 474 + "hello" 475 475 + "from-functor" 476 476 + ]; 477 477 + in 478 478 + { 479 479 + inherit expr expected; 480 480 + }; 481 481 + 482 482 + aspects."test define top-level context-aware aspect" = 483 483 + let 484 484 + flake = mkFlake { 485 485 + flake.aspects = 486 486 + { aspects, ... }: 487 487 + { 488 488 + aspectOne = { 489 489 + classOne.bar = [ "should-not-be-present" ]; 490 490 + includes = [ aspects.aspectTwo ]; 491 491 + __functor = aspect: { 492 492 + includes = [ 493 493 + { classOne.bar = [ "from-functor" ]; } 494 494 + ] 495 495 + ++ map (f: f { message = "hello"; }) aspect.includes; 496 496 + }; 497 497 + }; 498 498 + aspectTwo = 499 499 + { message }: 500 500 + { 501 501 + classOne.bar = [ message ]; 502 502 + }; 503 503 + }; 504 504 + }; 34 505 35 35 - fooOpt = { 36 36 - options.foo = lib.mkOption { 37 37 - type = lib.types.str; 38 38 - default = "<unset>"; 39 39 - }; 40 40 - options.bar = lib.mkOption { 41 41 - type = lib.types.listOf lib.types.str; 42 42 - default = [ ]; 43 43 - }; 44 44 - options.baz = lib.mkOption { 45 45 - type = lib.types.lazyAttrsOf lib.types.str; 46 46 - default = { }; 47 47 - }; 48 48 - }; 506 506 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 507 507 + expected = [ 508 508 + "hello" 509 509 + "from-functor" 510 510 + ]; 511 511 + in 512 512 + { 513 513 + inherit expr expected; 514 514 + }; 515 515 + }; 49 516 50 50 - evalMod = 51 51 - class: mod: 52 52 - (lib.evalModules { 53 53 - inherit class; 54 54 - modules = [ mod ]; 55 55 - }).config; 56 56 - in 57 57 - { 58 58 - _module.args = { 59 59 - inherit 60 60 - transpose 61 61 - targetLib 62 62 - targetMod 63 63 - targetNix 64 64 - ; 65 65 - inherit mkFlake evalMod fooOpt; 66 66 - }; 517 517 + }; 67 518 }

-53

checkmate/modules/tests/aspect_chain.nix

··· 1 1 - { 2 2 - lib, 3 3 - mkFlake, 4 4 - evalMod, 5 5 - fooOpt, 6 6 - ... 7 7 - }: 8 8 - { 9 9 - 10 10 - flake.tests."test resolve aspect-chain" = 11 11 - let 12 12 - flake = mkFlake { 13 13 - flake.aspects = 14 14 - { aspects, ... }: 15 15 - { 16 16 - aspectOne = { 17 17 - name = "one"; 18 18 - includes = [ aspects.aspectOne.provides.dos ]; 19 19 - classOne.bar = [ "zzz" ]; 20 20 - provides.dos = 21 21 - { aspect-chain, ... }: 22 22 - { 23 23 - name = "dos"; 24 24 - includes = [ aspects.aspectOne.provides.tres ]; 25 25 - classOne.bar = map (x: x.name) aspect-chain; 26 26 - }; 27 27 - 28 28 - provides.tres = 29 29 - { aspect-chain, ... }: 30 30 - { 31 31 - name = "tres"; 32 32 - classOne.bar = [ (lib.last aspect-chain).name ]; 33 33 - }; 34 34 - }; 35 35 - }; 36 36 - }; 37 37 - mod = { 38 38 - imports = [ 39 39 - fooOpt 40 40 - (flake.aspects.aspectOne.resolve { class = "classOne"; }) 41 41 - ]; 42 42 - }; 43 43 - expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 44 44 - expected = [ 45 45 - "dos" 46 46 - "one" 47 47 - "zzz" 48 48 - ]; 49 49 - in 50 50 - { 51 51 - inherit expr expected; 52 52 - }; 53 53 - }

-53

checkmate/modules/tests/aspect_default_provider_functor.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - lib, 5 5 - ... 6 6 - }: 7 7 - { 8 8 - 9 9 - flake.tests."test override default provider" = 10 10 - let 11 11 - flake = mkFlake { 12 12 - flake.aspects = 13 13 - { aspects, ... }: 14 14 - { 15 15 - aspectOne = 16 16 - { aspect, ... }: 17 17 - { 18 18 - includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ]; 19 19 - classOne = { }; # required for propagation 20 20 - }; 21 21 - 22 22 - aspectTwo.__functor = 23 23 - _: 24 24 - { message }: # args must be always named 25 25 - { class, aspect-chain }: 26 26 - { aspect, ... }: 27 27 - { 28 28 - classOne.bar = [ 29 29 - "foo" 30 30 - aspect.name 31 31 - message 32 32 - class 33 33 - ] 34 34 - ++ (lib.map (x: x.name) aspect-chain); 35 35 - }; 36 36 - aspectTwo.classOne.bar = [ "itself not included" ]; 37 37 - }; 38 38 - }; 39 39 - 40 40 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 41 41 - expected = [ 42 42 - "foo" 43 43 - "<function body>" 44 44 - "hello aspectOne" 45 45 - "classOne" 46 46 - "aspectOne" 47 47 - ]; 48 48 - in 49 49 - { 50 50 - inherit expr expected; 51 51 - }; 52 52 - 53 53 - }

-42

checkmate/modules/tests/aspect_default_provider_override.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - ... 5 5 - }: 6 6 - { 7 7 - 8 8 - flake.tests."test override default provider includes" = 9 9 - let 10 10 - flake = mkFlake { 11 11 - flake.aspects = 12 12 - { aspects, ... }: 13 13 - { 14 14 - aspectOne = { 15 15 - classOne.bar = [ "should-not-be-present" ]; 16 16 - includes = [ aspects.aspectTwo ]; 17 17 - __functor = aspect: { 18 18 - includes = [ 19 19 - { classOne.bar = [ "from-functor" ]; } 20 20 - ] 21 21 - ++ map (f: f { message = "hello"; }) aspect.includes; 22 22 - }; 23 23 - }; 24 24 - aspectTwo.__functor = 25 25 - _aspect: 26 26 - { message }: 27 27 - { 28 28 - classOne.bar = [ message ]; 29 29 - }; 30 30 - }; 31 31 - }; 32 32 - 33 33 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 34 34 - expected = [ 35 35 - "hello" 36 36 - "from-functor" 37 37 - ]; 38 38 - in 39 39 - { 40 40 - inherit expr expected; 41 41 - }; 42 42 - }

-37

checkmate/modules/tests/aspect_dependencies.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - lib, 5 5 - ... 6 6 - }: 7 7 - { 8 8 - 9 9 - flake.tests."test dependencies on aspects" = 10 10 - let 11 11 - flake = mkFlake { 12 12 - flake.aspects = 13 13 - { aspects, ... }: 14 14 - { 15 15 - aspectOne = { 16 16 - description = "os config"; 17 17 - includes = with aspects; [ aspectTwo ]; 18 18 - classOne.bar = [ "os" ]; 19 19 - }; 20 20 - 21 21 - aspectTwo = { 22 22 - description = "user config at os level"; 23 23 - classOne.bar = [ "user" ]; 24 24 - }; 25 25 - }; 26 26 - }; 27 27 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 28 28 - expected = [ 29 29 - "os" 30 30 - "user" 31 31 - ]; 32 32 - in 33 33 - { 34 34 - inherit expr expected; 35 35 - }; 36 36 - 37 37 - }

-58

checkmate/modules/tests/aspect_fixpoint.nix

··· 1 1 - { 2 2 - lib, 3 3 - mkFlake, 4 4 - evalMod, 5 5 - ... 6 6 - }: 7 7 - { 8 8 - 9 9 - flake.tests."test provides using fixpoints" = 10 10 - let 11 11 - flake = mkFlake { 12 12 - flake.aspects = 13 13 - { aspects, ... }@top: 14 14 - { 15 15 - aspectOne = { 16 16 - classOne.bar = [ "1" ]; 17 17 - includes = [ 18 18 - aspects.aspectTwo 19 19 - ]; 20 20 - }; 21 21 - 22 22 - aspectTwo = { 23 23 - classOne.bar = [ "2" ]; 24 24 - includes = [ aspects.aspectTwo.provides.three-and-four-and-five ]; 25 25 - provides = 26 26 - { aspects, ... }: 27 27 - { 28 28 - three-and-four-and-five = { 29 29 - classOne.bar = [ "3" ]; 30 30 - includes = [ 31 31 - aspects.four 32 32 - top.aspects.five 33 33 - ]; 34 34 - }; 35 35 - four = { 36 36 - classOne.bar = [ "4" ]; 37 37 - }; 38 38 - }; 39 39 - }; 40 40 - 41 41 - five.classOne.bar = [ "5" ]; 42 42 - }; 43 43 - }; 44 44 - 45 45 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 46 46 - expected = [ 47 47 - "1" 48 48 - "2" 49 49 - "3" 50 50 - "4" 51 51 - "5" 52 52 - ]; 53 53 - in 54 54 - { 55 55 - inherit expr expected; 56 56 - }; 57 57 - 58 58 - }

-54

checkmate/modules/tests/aspect_modules_resolved.nix

··· 1 1 - { 2 2 - lib, 3 3 - mkFlake, 4 4 - evalMod, 5 5 - fooOpt, 6 6 - ... 7 7 - }: 8 8 - { 9 9 - 10 10 - flake.tests."test modules resolved" = 11 11 - let 12 12 - flake = mkFlake { 13 13 - flake.aspects = 14 14 - { aspects, ... }: 15 15 - { 16 16 - aspectOne = { 17 17 - name = "one"; 18 18 - includes = [ aspects.aspectOne.provides.dos ]; 19 19 - classOne.bar = [ "zzz" ]; 20 20 - provides.dos = 21 21 - { aspect-chain, ... }: 22 22 - { 23 23 - name = "dos"; 24 24 - includes = [ aspects.aspectOne.provides.tres ]; 25 25 - classOne.bar = map (x: x.name) aspect-chain; 26 26 - }; 27 27 - 28 28 - provides.tres = 29 29 - { aspect-chain, ... }: 30 30 - { 31 31 - name = "tres"; 32 32 - classOne.bar = [ (lib.last aspect-chain).name ]; 33 33 - }; 34 34 - }; 35 35 - }; 36 36 - }; 37 37 - mod = { 38 38 - imports = [ 39 39 - fooOpt 40 40 - (flake.aspects.aspectOne.modules.classOne) 41 41 - ]; 42 42 - }; 43 43 - expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 44 44 - expected = [ 45 45 - "dos" 46 46 - "one" 47 47 - "zzz" 48 48 - ]; 49 49 - in 50 50 - { 51 51 - inherit expr expected; 52 52 - }; 53 53 - 54 54 - }

-34

checkmate/modules/tests/aspect_parametric.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - lib, 5 5 - ... 6 6 - }: 7 7 - { 8 8 - 9 9 - flake.tests."test provides parametrized modules" = 10 10 - let 11 11 - flake = mkFlake { 12 12 - flake.aspects = 13 13 - { aspects, ... }: 14 14 - { 15 15 - aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ]; 16 16 - aspectOne.classOne.bar = [ "1" ]; 17 17 - 18 18 - aspectTwo.provides.hello = world: { 19 19 - classOne.bar = [ world ]; 20 20 - }; 21 21 - }; 22 22 - }; 23 23 - 24 24 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 25 25 - expected = [ 26 26 - "1" 27 27 - "mundo" 28 28 - ]; 29 29 - in 30 30 - { 31 31 - inherit expr expected; 32 32 - }; 33 33 - 34 34 - }

-63

checkmate/modules/tests/aspect_provides.nix

··· 1 1 - { 2 2 - lib, 3 3 - mkFlake, 4 4 - evalMod, 5 5 - ... 6 6 - }: 7 7 - { 8 8 - 9 9 - flake.tests."test provides" = 10 10 - let 11 11 - flake = mkFlake { 12 12 - flake.aspects = 13 13 - { aspects, ... }: 14 14 - { 15 15 - aspectOne.includes = with aspects.aspectTwo.provides; [ 16 16 - foo 17 17 - bar 18 18 - ]; 19 19 - aspectOne.classOne = { }; # must be present for mixing dependencies. 20 20 - aspectTwo = { 21 21 - classOne.bar = [ "class one not included" ]; 22 22 - classTwo.bar = [ "class two not included" ]; 23 23 - provides.foo = 24 24 - { class, aspect-chain }: 25 25 - { 26 26 - name = "aspectTwo.foo"; 27 27 - description = "aspectTwo foo provided"; 28 28 - includes = [ 29 29 - aspects.aspectThree.provides.moo 30 30 - aspects.aspectTwo.provides.baz 31 31 - ]; 32 32 - classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 33 33 - classTwo.bar = [ "foo class two not included" ]; 34 34 - }; 35 35 - # a provider can be immediately an aspect object. 36 36 - provides.bar = { 37 37 - # classOne is missing on bar 38 38 - classTwo.bar = [ "bar class two not included" ]; 39 39 - }; 40 40 - # _ is an shortcut alias of provides. 41 41 - _.baz = { 42 42 - # classOne is missing on bar 43 43 - classTwo.bar = [ "baz" ]; 44 44 - }; 45 45 - }; 46 46 - aspectThree.provides.moo = 47 47 - { aspect-chain, class }: 48 48 - { 49 49 - classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 50 50 - }; 51 51 - }; 52 52 - }; 53 53 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 54 54 - expected = [ 55 55 - "three:classOne:aspectOne/aspectTwo.foo" 56 56 - "two:classOne:aspectOne" 57 57 - ]; 58 58 - in 59 59 - { 60 60 - inherit expr expected; 61 61 - }; 62 62 - 63 63 - }

-41

checkmate/modules/tests/aspect_toplevel_parametric.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - ... 5 5 - }: 6 6 - { 7 7 - 8 8 - flake.tests."test define top-level context-aware aspect" = 9 9 - let 10 10 - flake = mkFlake { 11 11 - flake.aspects = 12 12 - { aspects, ... }: 13 13 - { 14 14 - aspectOne = { 15 15 - classOne.bar = [ "should-not-be-present" ]; 16 16 - includes = [ aspects.aspectTwo ]; 17 17 - __functor = aspect: { 18 18 - includes = [ 19 19 - { classOne.bar = [ "from-functor" ]; } 20 20 - ] 21 21 - ++ map (f: f { message = "hello"; }) aspect.includes; 22 22 - }; 23 23 - }; 24 24 - aspectTwo = 25 25 - { message }: 26 26 - { 27 27 - classOne.bar = [ message ]; 28 28 - }; 29 29 - }; 30 30 - }; 31 31 - 32 32 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 33 33 - expected = [ 34 34 - "hello" 35 35 - "from-functor" 36 36 - ]; 37 37 - in 38 38 - { 39 39 - inherit expr expected; 40 40 - }; 41 41 - }

-29

checkmate/modules/tests/default_empty.nix

··· 1 1 - { 2 2 - inputs, 3 3 - targetMod, 4 4 - ... 5 5 - }: 6 6 - { 7 7 - 8 8 - flake.tests."test provides default" = 9 9 - let 10 10 - flake = 11 11 - inputs.flake-parts.lib.mkFlake 12 12 - { 13 13 - inputs.self = [ ]; 14 14 - moduleLocation = builtins.toString ./.; 15 15 - } 16 16 - { 17 17 - systems = [ ]; 18 18 - imports = [ 19 19 - targetMod 20 20 - inputs.flake-parts.flakeModules.modules 21 21 - ]; 22 22 - }; 23 23 - expr = flake.modules; 24 24 - expected = { }; 25 25 - in 26 26 - { 27 27 - inherit expr expected; 28 28 - }; 29 29 - }

-28

checkmate/modules/tests/tranpose_flake_modules.nix

··· 1 1 - { 2 2 - mkFlake, 3 3 - evalMod, 4 4 - ... 5 5 - }: 6 6 - { 7 7 - 8 8 - flake.tests."test transposes to flake.modules" = 9 9 - let 10 10 - flake = mkFlake { 11 11 - flake.aspects.aspectOne = { 12 12 - classOne.foo = "niri"; 13 13 - classTwo.foo = "paper.spoon"; 14 14 - }; 15 15 - }; 16 16 - expr = { 17 17 - classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo; 18 18 - classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo; 19 19 - }; 20 20 - expected = { 21 21 - classOne = "niri"; 22 22 - classTwo = "paper.spoon"; 23 23 - }; 24 24 - in 25 25 - { 26 26 - inherit expr expected; 27 27 - }; 28 28 - }

-15

checkmate/modules/tests/transpose_common.nix

··· 1 1 - { transpose, ... }: 2 2 - { 3 3 - 4 4 - flake.tests."test transpose common childs become one parent" = { 5 5 - expr = transpose { 6 6 - a.b = 1; 7 7 - c.b = 2; 8 8 - }; 9 9 - expected.b = { 10 10 - a = 1; 11 11 - c = 2; 12 12 - }; 13 13 - }; 14 14 - 15 15 - }

-10

checkmate/modules/tests/transpose_swap.nix

··· 1 1 - { transpose, ... }: 2 2 - { 3 3 - 4 4 - flake.tests."test transpose swaps parent and child attrNames" = { 5 5 - expr = transpose { a.b.c = 1; }; 6 6 - expected = { 7 7 - b.a.c = 1; 8 8 - }; 9 9 - }; 10 10 - }

-44

checkmate/modules/tests/without_flakes.nix

··· 1 1 - { lib, targetLib, ... }: 2 2 - { 3 3 - 4 4 - flake.tests."test usage without flakes" = 5 5 - let 6 6 - flake-aspects-lib = import targetLib lib; 7 7 - # first eval is like evaling the flake. 8 8 - first = lib.evalModules { 9 9 - modules = [ 10 10 - (flake-aspects-lib.new-scope "hello") 11 11 - { 12 12 - hello.aspects = 13 13 - { aspects, ... }: 14 14 - { 15 15 - a.b.c = [ "world" ]; 16 16 - a.includes = [ aspects.x ]; 17 17 - x.b = 18 18 - { lib, ... }: 19 19 - { 20 20 - c = lib.splitString " " "mundo cruel"; 21 21 - }; 22 22 - }; 23 23 - } 24 24 - ]; 25 25 - }; 26 26 - # second eval is like evaling its nixosConfiguration 27 27 - second = lib.evalModules { 28 28 - modules = [ 29 29 - { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; } 30 30 - first.config.hello.modules.b.a 31 31 - ]; 32 32 - }; 33 33 - expr = lib.sort (a: b: a < b) second.config.c; 34 34 - expected = [ 35 35 - "cruel" 36 36 - "mundo" 37 37 - "world" 38 38 - ]; 39 39 - in 40 40 - { 41 41 - inherit expr expected; 42 42 - }; 43 43 - 44 44 - }

+9 -3

nix/types.nix

··· 5 5 aspectsType = lib.types.submodule ( 6 6 { config, ... }: 7 7 { 8 8 - freeformType = lib.types.attrsOf providerType; 8 8 + freeformType = lib.types.attrsOf (lib.types.either aspectSubmoduleAttrs providerType); 9 9 config._module.args.aspects = config; 10 10 } 11 11 ); ··· 30 30 ); 31 31 32 32 functionProviderType = lib.types.either functionToAspect (lib.types.functionTo providerType); 33 33 - providerType = lib.types.either aspectSubmoduleAttrs functionProviderType; 33 33 + providerType = lib.types.either functionProviderType aspectSubmodule; 34 34 35 35 aspectSubmoduleAttrs = lib.types.addCheck aspectSubmodule ( 36 36 m: (!builtins.isFunction m) || (isAspectSubmoduleFn m) ··· 78 78 options.provides = lib.mkOption { 79 79 description = "Providers of aspect for other aspects"; 80 80 default = { }; 81 81 - type = aspectsType; 81 81 + type = lib.types.submodule ( 82 82 + { config, ... }: 83 83 + { 84 84 + freeformType = lib.types.attrsOf providerType; 85 85 + config._module.args.provides = config; 86 86 + } 87 87 + ); 82 88 }; 83 89 options.__functor = lib.mkOption { 84 90 internal = true;