Split tests (#19)

* split tests, reorg types

checkmate/modules/tests.nix

···
-{ inputs, ... }:
-{
-  perSystem =
-    { lib, ... }:
-    let
-      transpose = import ../../nix { inherit lib; };
+{ inputs, lib, ... }:
+let
+  targetNix = "${inputs.target}/nix";
+  targetLib = "${inputs.target}/nix/lib.nix";
+  targetMod = "${inputs.target}/nix/flakeModule.nix";
 
-      mkFlake =
-        mod:
-        inputs.flake-parts.lib.mkFlake
-          {
-            inputs.self = [ ];
-          }
-          {
-            systems = [ ];
-            imports = [
-              ../../nix/flakeModule.nix
-              inputs.flake-parts.flakeModules.modules
-              mod
-              (fooMod "aspectOne")
-              (fooMod "aspectTwo")
-              (fooMod "aspectThree")
-            ];
-          };
+  transpose = import targetNix { inherit lib; };
 
-      fooMod = aspect: {
+  mkFlake =
+    mod:
+    inputs.flake-parts.lib.mkFlake
+      {
+        inputs.self = [ ];
+      }
+      {
+        systems = [ ];
         imports = [
-          { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; }
-          { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; }
-          { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; }
+          targetMod
+          inputs.flake-parts.flakeModules.modules
+          mod
+          (fooMod "aspectOne")
+          (fooMod "aspectTwo")
+          (fooMod "aspectThree")
         ];
       };
 
-      fooOpt = {
-        options.foo = lib.mkOption {
-          type = lib.types.str;
-          default = "<unset>";
-        };
-        options.bar = lib.mkOption {
-          type = lib.types.listOf lib.types.str;
-          default = [ ];
-        };
-        options.baz = lib.mkOption {
-          type = lib.types.lazyAttrsOf lib.types.str;
-          default = { };
-        };
-      };
-
-      evalMod =
-        class: mod:
-        (lib.evalModules {
-          inherit class;
-          modules = [ mod ];
-        }).config;
-    in
-    {
-      nix-unit.tests = {
-        transpose."test swaps parent and child attrNames" = {
-          expr = transpose { a.b.c = 1; };
-          expected = {
-            b.a.c = 1;
-          };
-        };
-
-        transpose."test common childs become one parent" = {
-          expr = transpose {
-            a.b = 1;
-            c.b = 2;
-          };
-          expected.b = {
-            a = 1;
-            c = 2;
-          };
-        };
-
-        new-scope."test usage without flakes" =
-          let
-            flake-aspects-lib = import ../../nix/lib.nix lib;
-            # first eval is like evaling the flake.
-            first = lib.evalModules {
-              modules = [
-                (flake-aspects-lib.new-scope "hello")
-                {
-                  hello.aspects =
-                    { aspects, ... }:
-                    {
-                      a.b.c = [ "world" ];
-                      a.includes = [ aspects.x ];
-                      x.b =
-                        { lib, ... }:
-                        {
-                          c = lib.splitString " " "mundo cruel";
-                        };
-                    };
-                }
-              ];
-            };
-            # second eval is like evaling its nixosConfiguration
-            second = lib.evalModules {
-              modules = [
-                { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; }
-                first.config.hello.modules.b.a
-              ];
-            };
-            expr = lib.sort (a: b: a < b) second.config.c;
-            expected = [
-              "cruel"
-              "mundo"
-              "world"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test provides default" =
-          let
-            flake =
-              inputs.flake-parts.lib.mkFlake
-                {
-                  inputs.self = [ ];
-                  moduleLocation = builtins.toString ./.;
-                }
-                {
-                  systems = [ ];
-                  imports = [
-                    ../../nix/flakeModule.nix
-                    inputs.flake-parts.flakeModules.modules
-                  ];
-                };
-            expr = flake.modules;
-            expected = { };
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test transposes to flake.modules" =
-          let
-            flake = mkFlake {
-              flake.aspects.aspectOne = {
-                classOne.foo = "niri";
-                classTwo.foo = "paper.spoon";
-              };
-            };
-            expr = {
-              classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo;
-              classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo;
-            };
-            expected = {
-              classOne = "niri";
-              classTwo = "paper.spoon";
-            };
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test dependencies on aspects" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    description = "os config";
-                    includes = with aspects; [ aspectTwo ];
-                    classOne.bar = [ "os" ];
-                  };
-
-                  aspectTwo = {
-                    description = "user config at os level";
-                    classOne.bar = [ "user" ];
-                  };
-                };
-            };
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "os"
-              "user"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test resolve aspect-chain" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    name = "one";
-                    includes = [ aspects.aspectOne.provides.dos ];
-                    classOne.bar = [ "zzz" ];
-                    provides.dos =
-                      { aspect-chain, ... }:
-                      {
-                        name = "dos";
-                        includes = [ aspects.aspectOne.provides.tres ];
-                        classOne.bar = map (x: x.name) aspect-chain;
-                      };
+  fooMod = aspect: {
+    imports = [
+      { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; }
+      { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; }
+      { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; }
+    ];
+  };
 
-                    provides.tres =
-                      { aspect-chain, ... }:
-                      {
-                        name = "tres";
-                        classOne.bar = [ (lib.last aspect-chain).name ];
-                      };
-                  };
-                };
-            };
-            mod = {
-              imports = [
-                fooOpt
-                (flake.aspects.aspectOne.resolve { class = "classOne"; })
-              ];
-            };
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar;
-            expected = [
-              "dos"
-              "one"
-              "zzz"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
+  fooOpt = {
+    options.foo = lib.mkOption {
+      type = lib.types.str;
+      default = "<unset>";
+    };
+    options.bar = lib.mkOption {
+      type = lib.types.listOf lib.types.str;
+      default = [ ];
+    };
+    options.baz = lib.mkOption {
+      type = lib.types.lazyAttrsOf lib.types.str;
+      default = { };
+    };
+  };
 
-        aspects."test modules resolved" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    name = "one";
-                    includes = [ aspects.aspectOne.provides.dos ];
-                    classOne.bar = [ "zzz" ];
-                    provides.dos =
-                      { aspect-chain, ... }:
-                      {
-                        name = "dos";
-                        includes = [ aspects.aspectOne.provides.tres ];
-                        classOne.bar = map (x: x.name) aspect-chain;
-                      };
-
-                    provides.tres =
-                      { aspect-chain, ... }:
-                      {
-                        name = "tres";
-                        classOne.bar = [ (lib.last aspect-chain).name ];
-                      };
-                  };
-                };
-            };
-            mod = {
-              imports = [
-                fooOpt
-                (flake.aspects.aspectOne.modules.classOne)
-              ];
-            };
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar;
-            expected = [
-              "dos"
-              "one"
-              "zzz"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test provides" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne.includes = with aspects.aspectTwo.provides; [
-                    foo
-                    bar
-                  ];
-                  aspectOne.classOne = { }; # must be present for mixing dependencies.
-                  aspectTwo = {
-                    classOne.bar = [ "class one not included" ];
-                    classTwo.bar = [ "class two not included" ];
-                    provides.foo =
-                      { class, aspect-chain }:
-                      {
-                        name = "aspectTwo.foo";
-                        description = "aspectTwo foo provided";
-                        includes = [
-                          aspects.aspectThree.provides.moo
-                          aspects.aspectTwo.provides.baz
-                        ];
-                        classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ];
-                        classTwo.bar = [ "foo class two not included" ];
-                      };
-                    # a provider can be immediately an aspect object.
-                    provides.bar = {
-                      # classOne is missing on bar
-                      classTwo.bar = [ "bar class two not included" ];
-                    };
-                    # _ is an shortcut alias of provides.
-                    _.baz = {
-                      # classOne is missing on bar
-                      classTwo.bar = [ "baz" ];
-                    };
-                  };
-                  aspectThree.provides.moo =
-                    { aspect-chain, class }:
-                    {
-                      classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ];
-                    };
-                };
-            };
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "three:classOne:aspectOne/aspectTwo.foo"
-              "two:classOne:aspectOne"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test provides using fixpoints" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    classOne.bar = [ "1" ];
-                    includes = [
-                      aspects.aspectTwo
-                    ];
-                  };
-
-                  aspectTwo = {
-                    classOne.bar = [ "2" ];
-                    includes = [ aspects.aspectTwo.provides.three-and-four-and-five ];
-                    provides =
-                      { provides, ... }:
-                      {
-                        three-and-four-and-five = {
-                          classOne.bar = [ "3" ];
-                          includes = [
-                            provides.four
-                            aspects.five
-                          ];
-                        };
-                        four = {
-                          classOne.bar = [ "4" ];
-                        };
-                      };
-                  };
-
-                  five.classOne.bar = [ "5" ];
-                };
-            };
-
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "1"
-              "2"
-              "3"
-              "4"
-              "5"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test provides parametrized modules" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ];
-                  aspectOne.classOne.bar = [ "1" ];
-
-                  aspectTwo.provides.hello = world: {
-                    classOne.bar = [ world ];
-                  };
-                };
-            };
-
-            expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "1"
-              "mundo"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test override default provider" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne =
-                    { aspect, ... }:
-                    {
-                      includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ];
-                      classOne = { }; # required for propagation
-                    };
-
-                  aspectTwo.__functor =
-                    _:
-                    { message }: # args must be always named
-                    { class, aspect-chain }:
-                    { aspect, ... }:
-                    {
-                      classOne.bar = [
-                        "foo"
-                        aspect.name
-                        message
-                        class
-                      ]
-                      ++ (lib.map (x: x.name) aspect-chain);
-                    };
-                  aspectTwo.classOne.bar = [ "itself not included" ];
-                };
-            };
-
-            expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "foo"
-              "<function body>"
-              "hello aspectOne"
-              "classOne"
-              "aspectOne"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test override default provider includes" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    classOne.bar = [ "should-not-be-present" ];
-                    includes = [ aspects.aspectTwo ];
-                    __functor = aspect: {
-                      includes = [
-                        { classOne.bar = [ "from-functor" ]; }
-                      ]
-                      ++ map (f: f { message = "hello"; }) aspect.includes;
-                    };
-                  };
-                  aspectTwo.__functor =
-                    _aspect:
-                    { message }:
-                    {
-                      classOne.bar = [ message ];
-                    };
-                };
-            };
-
-            expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "hello"
-              "from-functor"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-
-        aspects."test define top-level context-aware aspect" =
-          let
-            flake = mkFlake {
-              flake.aspects =
-                { aspects, ... }:
-                {
-                  aspectOne = {
-                    classOne.bar = [ "should-not-be-present" ];
-                    includes = [ aspects.aspectTwo ];
-                    __functor = aspect: {
-                      includes = [
-                        { classOne.bar = [ "from-functor" ]; }
-                      ]
-                      ++ map (f: f { message = "hello"; }) aspect.includes;
-                    };
-                  };
-                  aspectTwo =
-                    { message }:
-                    {
-                      classOne.bar = [ message ];
-                    };
-                };
-            };
-
-            expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
-            expected = [
-              "hello"
-              "from-functor"
-            ];
-          in
-          {
-            inherit expr expected;
-          };
-      };
-
-    };
+  evalMod =
+    class: mod:
+    (lib.evalModules {
+      inherit class;
+      modules = [ mod ];
+    }).config;
+in
+{
+  _module.args = {
+    inherit
+      transpose
+      targetLib
+      targetMod
+      targetNix
+      ;
+    inherit mkFlake evalMod fooOpt;
+  };
 }

checkmate/modules/tests/aspect_chain.nix

···
+{
+  lib,
+  mkFlake,
+  evalMod,
+  fooOpt,
+  ...
+}:
+{
+
+  flake.tests."test resolve aspect-chain" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne = {
+              name = "one";
+              includes = [ aspects.aspectOne.provides.dos ];
+              classOne.bar = [ "zzz" ];
+              provides.dos =
+                { aspect-chain, ... }:
+                {
+                  name = "dos";
+                  includes = [ aspects.aspectOne.provides.tres ];
+                  classOne.bar = map (x: x.name) aspect-chain;
+                };
+
+              provides.tres =
+                { aspect-chain, ... }:
+                {
+                  name = "tres";
+                  classOne.bar = [ (lib.last aspect-chain).name ];
+                };
+            };
+          };
+      };
+      mod = {
+        imports = [
+          fooOpt
+          (flake.aspects.aspectOne.resolve { class = "classOne"; })
+        ];
+      };
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar;
+      expected = [
+        "dos"
+        "one"
+        "zzz"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+}

checkmate/modules/tests/aspect_default_provider_functor.nix

···
+{
+  mkFlake,
+  evalMod,
+  lib,
+  ...
+}:
+{
+
+  flake.tests."test override default provider" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne =
+              { aspect, ... }:
+              {
+                includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ];
+                classOne = { }; # required for propagation
+              };
+
+            aspectTwo.__functor =
+              _:
+              { message }: # args must be always named
+              { class, aspect-chain }:
+              { aspect, ... }:
+              {
+                classOne.bar = [
+                  "foo"
+                  aspect.name
+                  message
+                  class
+                ]
+                ++ (lib.map (x: x.name) aspect-chain);
+              };
+            aspectTwo.classOne.bar = [ "itself not included" ];
+          };
+      };
+
+      expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "foo"
+        "<function body>"
+        "hello aspectOne"
+        "classOne"
+        "aspectOne"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_default_provider_override.nix

···
+{
+  mkFlake,
+  evalMod,
+  ...
+}:
+{
+
+  flake.tests."test override default provider includes" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne = {
+              classOne.bar = [ "should-not-be-present" ];
+              includes = [ aspects.aspectTwo ];
+              __functor = aspect: {
+                includes = [
+                  { classOne.bar = [ "from-functor" ]; }
+                ]
+                ++ map (f: f { message = "hello"; }) aspect.includes;
+              };
+            };
+            aspectTwo.__functor =
+              _aspect:
+              { message }:
+              {
+                classOne.bar = [ message ];
+              };
+          };
+      };
+
+      expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "hello"
+        "from-functor"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+}

checkmate/modules/tests/aspect_dependencies.nix

···
+{
+  mkFlake,
+  evalMod,
+  lib,
+  ...
+}:
+{
+
+  flake.tests."test dependencies on aspects" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne = {
+              description = "os config";
+              includes = with aspects; [ aspectTwo ];
+              classOne.bar = [ "os" ];
+            };
+
+            aspectTwo = {
+              description = "user config at os level";
+              classOne.bar = [ "user" ];
+            };
+          };
+      };
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "os"
+        "user"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_fixpoint.nix

···
+{
+  lib,
+  mkFlake,
+  evalMod,
+  ...
+}:
+{
+
+  flake.tests."test provides using fixpoints" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }@top:
+          {
+            aspectOne = {
+              classOne.bar = [ "1" ];
+              includes = [
+                aspects.aspectTwo
+              ];
+            };
+
+            aspectTwo = {
+              classOne.bar = [ "2" ];
+              includes = [ aspects.aspectTwo.provides.three-and-four-and-five ];
+              provides =
+                { aspects, ... }:
+                {
+                  three-and-four-and-five = {
+                    classOne.bar = [ "3" ];
+                    includes = [
+                      aspects.four
+                      top.aspects.five
+                    ];
+                  };
+                  four = {
+                    classOne.bar = [ "4" ];
+                  };
+                };
+            };
+
+            five.classOne.bar = [ "5" ];
+          };
+      };
+
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "1"
+        "2"
+        "3"
+        "4"
+        "5"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_modules_resolved.nix

···
+{
+  lib,
+  mkFlake,
+  evalMod,
+  fooOpt,
+  ...
+}:
+{
+
+  flake.tests."test modules resolved" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne = {
+              name = "one";
+              includes = [ aspects.aspectOne.provides.dos ];
+              classOne.bar = [ "zzz" ];
+              provides.dos =
+                { aspect-chain, ... }:
+                {
+                  name = "dos";
+                  includes = [ aspects.aspectOne.provides.tres ];
+                  classOne.bar = map (x: x.name) aspect-chain;
+                };
+
+              provides.tres =
+                { aspect-chain, ... }:
+                {
+                  name = "tres";
+                  classOne.bar = [ (lib.last aspect-chain).name ];
+                };
+            };
+          };
+      };
+      mod = {
+        imports = [
+          fooOpt
+          (flake.aspects.aspectOne.modules.classOne)
+        ];
+      };
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar;
+      expected = [
+        "dos"
+        "one"
+        "zzz"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_parametric.nix

···
+{
+  mkFlake,
+  evalMod,
+  lib,
+  ...
+}:
+{
+
+  flake.tests."test provides parametrized modules" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ];
+            aspectOne.classOne.bar = [ "1" ];
+
+            aspectTwo.provides.hello = world: {
+              classOne.bar = [ world ];
+            };
+          };
+      };
+
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "1"
+        "mundo"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_provides.nix

···
+{
+  lib,
+  mkFlake,
+  evalMod,
+  ...
+}:
+{
+
+  flake.tests."test provides" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne.includes = with aspects.aspectTwo.provides; [
+              foo
+              bar
+            ];
+            aspectOne.classOne = { }; # must be present for mixing dependencies.
+            aspectTwo = {
+              classOne.bar = [ "class one not included" ];
+              classTwo.bar = [ "class two not included" ];
+              provides.foo =
+                { class, aspect-chain }:
+                {
+                  name = "aspectTwo.foo";
+                  description = "aspectTwo foo provided";
+                  includes = [
+                    aspects.aspectThree.provides.moo
+                    aspects.aspectTwo.provides.baz
+                  ];
+                  classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ];
+                  classTwo.bar = [ "foo class two not included" ];
+                };
+              # a provider can be immediately an aspect object.
+              provides.bar = {
+                # classOne is missing on bar
+                classTwo.bar = [ "bar class two not included" ];
+              };
+              # _ is an shortcut alias of provides.
+              _.baz = {
+                # classOne is missing on bar
+                classTwo.bar = [ "baz" ];
+              };
+            };
+            aspectThree.provides.moo =
+              { aspect-chain, class }:
+              {
+                classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ];
+              };
+          };
+      };
+      expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "three:classOne:aspectOne/aspectTwo.foo"
+        "two:classOne:aspectOne"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

checkmate/modules/tests/aspect_toplevel_parametric.nix

···
+{
+  mkFlake,
+  evalMod,
+  ...
+}:
+{
+
+  flake.tests."test define top-level context-aware aspect" =
+    let
+      flake = mkFlake {
+        flake.aspects =
+          { aspects, ... }:
+          {
+            aspectOne = {
+              classOne.bar = [ "should-not-be-present" ];
+              includes = [ aspects.aspectTwo ];
+              __functor = aspect: {
+                includes = [
+                  { classOne.bar = [ "from-functor" ]; }
+                ]
+                ++ map (f: f { message = "hello"; }) aspect.includes;
+              };
+            };
+            aspectTwo =
+              { message }:
+              {
+                classOne.bar = [ message ];
+              };
+          };
+      };
+
+      expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar;
+      expected = [
+        "hello"
+        "from-functor"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+}

checkmate/modules/tests/default_empty.nix

···
+{
+  inputs,
+  targetMod,
+  ...
+}:
+{
+
+  flake.tests."test provides default" =
+    let
+      flake =
+        inputs.flake-parts.lib.mkFlake
+          {
+            inputs.self = [ ];
+            moduleLocation = builtins.toString ./.;
+          }
+          {
+            systems = [ ];
+            imports = [
+              targetMod
+              inputs.flake-parts.flakeModules.modules
+            ];
+          };
+      expr = flake.modules;
+      expected = { };
+    in
+    {
+      inherit expr expected;
+    };
+}

checkmate/modules/tests/tranpose_flake_modules.nix

···
+{
+  mkFlake,
+  evalMod,
+  ...
+}:
+{
+
+  flake.tests."test transposes to flake.modules" =
+    let
+      flake = mkFlake {
+        flake.aspects.aspectOne = {
+          classOne.foo = "niri";
+          classTwo.foo = "paper.spoon";
+        };
+      };
+      expr = {
+        classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo;
+        classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo;
+      };
+      expected = {
+        classOne = "niri";
+        classTwo = "paper.spoon";
+      };
+    in
+    {
+      inherit expr expected;
+    };
+}

checkmate/modules/tests/transpose_common.nix

···
+{ transpose, ... }:
+{
+
+  flake.tests."test transpose common childs become one parent" = {
+    expr = transpose {
+      a.b = 1;
+      c.b = 2;
+    };
+    expected.b = {
+      a = 1;
+      c = 2;
+    };
+  };
+
+}

checkmate/modules/tests/transpose_swap.nix

···
+{ transpose, ... }:
+{
+
+  flake.tests."test transpose swaps parent and child attrNames" = {
+    expr = transpose { a.b.c = 1; };
+    expected = {
+      b.a.c = 1;
+    };
+  };
+}

checkmate/modules/tests/without_flakes.nix

···
+{ lib, targetLib, ... }:
+{
+
+  flake.tests."test usage without flakes" =
+    let
+      flake-aspects-lib = import targetLib lib;
+      # first eval is like evaling the flake.
+      first = lib.evalModules {
+        modules = [
+          (flake-aspects-lib.new-scope "hello")
+          {
+            hello.aspects =
+              { aspects, ... }:
+              {
+                a.b.c = [ "world" ];
+                a.includes = [ aspects.x ];
+                x.b =
+                  { lib, ... }:
+                  {
+                    c = lib.splitString " " "mundo cruel";
+                  };
+              };
+          }
+        ];
+      };
+      # second eval is like evaling its nixosConfiguration
+      second = lib.evalModules {
+        modules = [
+          { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; }
+          first.config.hello.modules.b.a
+        ];
+      };
+      expr = lib.sort (a: b: a < b) second.config.c;
+      expected = [
+        "cruel"
+        "mundo"
+        "world"
+      ];
+    in
+    {
+      inherit expr expected;
+    };
+
+}

nix/types.nix

···
   aspectsType = lib.types.submodule (
     { config, ... }:
     {
-      freeformType = lib.types.attrsOf (lib.types.either aspectSubmoduleAttrs providerType);
+      freeformType = lib.types.attrsOf providerType;
       config._module.args.aspects = config;
     }
   );
···
   );
 
   functionProviderType = lib.types.either functionToAspect (lib.types.functionTo providerType);
-  providerType = lib.types.either functionProviderType aspectSubmodule;
+  providerType = lib.types.either aspectSubmoduleAttrs functionProviderType;
 
   aspectSubmoduleAttrs = lib.types.addCheck aspectSubmodule (
     m: (!builtins.isFunction m) || (isAspectSubmoduleFn m)
···
       options.provides = lib.mkOption {
         description = "Providers of aspect for other aspects";
         default = { };
-        type = lib.types.submodule (
-          { config, ... }:
-          {
-            freeformType = lib.types.attrsOf providerType;
-            config._module.args.provides = config;
-          }
-        );
+        type = aspectsType;
       };
       options.__functor = lib.mkOption {
         internal = true;