Split tests

checkmate/modules/tests/aspect_chain.nix

@@ -0,0 +1,53 @@
+{
+  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

@@ -0,0 +1,53 @@
+{
+  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

@@ -0,0 +1,42 @@
+{
+  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

@@ -0,0 +1,37 @@
+{
+  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

@@ -0,0 +1,58 @@
+{
+  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

@@ -0,0 +1,54 @@
+{
+  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

@@ -0,0 +1,34 @@
+{
+  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;
+    };
+
+}