fn_test.go

package main

import (
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"testing"
	"time"

	"github.com/crossplane/crossplane-runtime/v2/pkg/logging"
	"github.com/go-logr/logr/testr"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"google.golang.org/protobuf/testing/protocmp"
	"google.golang.org/protobuf/types/known/durationpb"
	"google.golang.org/protobuf/types/known/structpb"
	"k8s.io/utils/ptr"
	remoteauth "oras.land/oras-go/v2/registry/remote/auth"

	fnv1 "github.com/crossplane/function-sdk-go/proto/v1"
	"github.com/crossplane/function-sdk-go/resource"
	"github.com/crossplane/function-sdk-go/response"

	"kcl-lang.io/krm-kcl/pkg/kube"
)

func TestResetOCITokenCacheIfNeeded(t *testing.T) {
	ctx := context.Background()
	registry := "registry.example.com"
	scheme := remoteauth.SchemeBearer
	scopeKey := "repository:my-package:pull"
	staleToken := "fake-expired-bearer-token"
	log := logging.NewLogrLogger(testr.New(t))

	populateCache := func() {
		remoteauth.DefaultCache = remoteauth.NewCache()
		remoteauth.DefaultCache.Set(ctx, registry, scheme, scopeKey, func(_ context.Context) (string, error) {
			return staleToken, nil
		})
	}

	t.Run("first call always resets (zero ociCacheCreated)", func(t *testing.T) {
		populateCache()
		ociCacheMu.Lock()
		ociCacheCreated = time.Time{}
		ociCacheMu.Unlock()

		resetOCITokenCacheIfNeeded(log)

		_, err := remoteauth.DefaultCache.GetToken(ctx, registry, scheme, scopeKey)
		if err == nil {
			t.Fatal("expected cache miss after first-call reset, but stale token still present")
		}
	})

	t.Run("skips reset when cache is fresh", func(t *testing.T) {
		populateCache()
		ociCacheMu.Lock()
		ociCacheCreated = time.Now()
		ociCacheMu.Unlock()

		resetOCITokenCacheIfNeeded(log)

		got, err := remoteauth.DefaultCache.GetToken(ctx, registry, scheme, scopeKey)
		if err != nil {
			t.Fatalf("cache should still have the token, got error: %v", err)
		}
		if got != staleToken {
			t.Fatalf("expected %q, got %q", staleToken, got)
		}
	})

	t.Run("resets when maxAge exceeded", func(t *testing.T) {
		populateCache()
		ociCacheMu.Lock()
		ociCacheCreated = time.Now().Add(-ociCacheMaxAge - time.Second)
		ociCacheMu.Unlock()

		resetOCITokenCacheIfNeeded(log)

		_, err := remoteauth.DefaultCache.GetToken(ctx, registry, scheme, scopeKey)
		if err == nil {
			t.Fatal("expected cache miss after reset, but stale token still present")
		}
	})
}

func TestRunFunctionSimple(t *testing.T) {
	type args struct {
		ctx context.Context
		req *fnv1.RunFunctionRequest
	}
	type want struct {
		rsp *fnv1.RunFunctionResponse
		err error
	}

	var (
		cd = `{"apiVersion":"example.org/v1","kind":"CD","metadata":{"annotations":{"krm.kcl.dev/composition-resource-name":"cool-cd"},"name":"cool-cd"}}`
		xr = `{"apiVersion":"example.org/v1","kind":"XR","metadata":{"name":"cool-xr"},"spec":{"count":2}}`
	)

	cases := map[string]struct {
		reason        string
		defaultSource string
		args          args
		want          want
	}{
		"ResponseIsReturned": {
			reason: "The Function should return a fatal result if no input was specified",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "hello"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Resources",
							"source": "{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n    metadata.name = \"generated\"\n}"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "hello", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"generated": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"name":"generated"}}`),
							},
						},
					},
				},
			},
		},
		"DatabaseInstance": {
			reason: "The Function should return a fatal result if no input was specified",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "database-instance"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"source": "items = [{ \n    apiVersion: \"sql.gcp.upbound.io/v1beta1\"\n    kind: \"DatabaseInstance\"\n    metadata.name = \"database-instance\"\n    spec: {\n        forProvider: {\n            project: \"test-project\"\n            settings: [{databaseFlags: [{\n                name: \"log_checkpoints\"\n                value: \"on\"\n            }]}]\n        }\n    }\n}]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "database-instance", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"database-instance": {
								Resource: resource.MustStructJSON(`{"apiVersion": "sql.gcp.upbound.io/v1beta1", "kind": "DatabaseInstance", "metadata": {"name": "database-instance"}, "spec": {"forProvider": {"project": "test-project", "settings": [{"databaseFlags": [{"name": "log_checkpoints", "value": "on"}]}]}}}`),
							},
						},
					},
				},
			},
		},
		"CustomTTLIsHonoured": {
			reason: "spec.ttl should override the default function response TTL.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "custom-ttl"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Resources",
							"source": "{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n    metadata.name = \"generated\"\n}",
							"ttl": "5m"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "custom-ttl", Ttl: durationpb.New(5 * time.Minute)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"generated": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"name":"generated"}}`),
							},
						},
					},
				},
			},
		},
		"CustomTTLZeroRequeuesImmediately": {
			reason: "spec.ttl = 0s should be honoured and request an immediate requeue (no wait).",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "custom-ttl-zero"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Resources",
							"source": "{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n    metadata.name = \"generated\"\n}",
							"ttl": "0s"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "custom-ttl-zero", Ttl: durationpb.New(0)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"generated": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"name":"generated"}}`),
							},
						},
					},
				},
			},
		},
		"CredentialsProviderFlowsThrough": {
			reason: "Spec.Credentials.Provider must be populated from the kcl-registry credential data so downstream consumers (krm-kcl, kpm) can dispatch on it.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "creds-provider"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Resources",
							"source": "_creds = option(\"resource_list\")?.functionConfig?.spec?.credentials or {}\nitems = [{\n    apiVersion: \"v1\"\n    kind: \"ConfigMap\"\n    metadata.name = \"creds\"\n    data: {\n        provider = _creds.provider or \"\"\n        url = _creds.url or \"\"\n    }\n}]"
						}
					}`),
					Credentials: map[string]*fnv1.Credentials{
						"kcl-registry": {
							Source: &fnv1.Credentials_CredentialData{
								CredentialData: &fnv1.CredentialData{
									Data: map[string][]byte{
										"url":      []byte("gcr.io/my-project"),
										"provider": []byte("gcp"),
									},
								},
							},
						},
					},
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "creds-provider", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"creds": {
								Resource: resource.MustStructJSON(`{"apiVersion":"v1","kind":"ConfigMap","metadata":{"name":"creds"},"data":{"provider":"gcp","url":"gcr.io/my-project"}}`),
							},
						},
					},
				},
			},
		},
		"CustomCompositionResourceNameIsSet": {
			reason: "The Function should set value of crossplane.io/composition-resource-name annotation by krm.kcl.dev/composition-resource-name annotation ",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "hello"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.annotations = {\"krm.kcl.dev/composition-resource-name\": \"custom-composition-resource-name\"}\n}"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "hello", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"custom-composition-resource-name": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"annotations":{}}}`),
							},
						},
					},
				},
			},
		},
		"MultipleResource": {
			reason: "The Function should return multiple resources with different resource names",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "multiple-resource"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"source": "items = [\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.annotations = {\"krm.kcl.dev/composition-resource-name\": \"custom-composition-resource-name-0\"}\n}\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.annotations = {\"krm.kcl.dev/composition-resource-name\": \"custom-composition-resource-name-1\"}\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "multiple-resource", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"custom-composition-resource-name-0": {
								Resource: resource.MustStructJSON(`{"apiVersion": "example.org/v1", "kind": "Generated", "metadata": {"annotations": {}}}`),
							},
							"custom-composition-resource-name-1": {
								Resource: resource.MustStructJSON(`{"apiVersion": "example.org/v1", "kind": "Generated", "metadata": {"annotations": {}}}`),
							},
						},
					},
				},
			},
		},
		"ExtraResources": {
			reason: "The Function should return the desired composite with extra resources.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "extra-resources"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"ExtraResources\"\n  requirements = {\n    \"cool-extra-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchName: \"cool-extra-resource\"\n    }\n  }\n},\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"ExtraResources\"\n  requirements = {\n    \"another-cool-extra-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchLabels = {\n        key: \"value\"\n      }\n    }\n    \"yet-another-cool-extra-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchName: \"foo\"\n    }\n  }\n},\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"ExtraResources\"\n  requirements = {\n    \"all-cool-resources\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchLabels = {}\n    }\n  }\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "extra-resources", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Requirements: &fnv1.Requirements{
						ExtraResources: map[string]*fnv1.ResourceSelector{
							"cool-extra-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolExtraResource",
								Match: &fnv1.ResourceSelector_MatchName{
									MatchName: "cool-extra-resource",
								},
							},
							"another-cool-extra-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolExtraResource",
								Match: &fnv1.ResourceSelector_MatchLabels{
									MatchLabels: &fnv1.MatchLabels{
										Labels: map[string]string{"key": "value"},
									},
								},
							},
							"yet-another-cool-extra-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolExtraResource",
								Match: &fnv1.ResourceSelector_MatchName{
									MatchName: "foo",
								},
							},
							"all-cool-resources": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolExtraResource",
								Match: &fnv1.ResourceSelector_MatchLabels{
									MatchLabels: &fnv1.MatchLabels{
										Labels: map[string]string{},
									},
								},
							},
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
		},
		"ExtraResourcesNamespacedMatchName": {
			reason: "The Function should pass through a single extra namespaced resource with matchName and matchNamespace",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "extra-resources-namespace-matchname"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {"name": "basic"},
						"spec": {
							"target": "Default",
							"source": "items = [{ apiVersion: \"meta.krm.kcl.dev/v1alpha1\", kind: \"ExtraResources\", requirements = { \"cool-ns-resource-matchname\" = { apiVersion: \"example.m.org/v1\", kind: \"CoolExtraResource\", matchNamespace: \"cool-ns-scoped-ns\", matchName: \"cool-ns-scoped-resource\" } } }]"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "extra-resources-namespace-matchname", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Requirements: &fnv1.Requirements{
						ExtraResources: map[string]*fnv1.ResourceSelector{
							"cool-ns-resource-matchname": {
								ApiVersion: "example.m.org/v1",
								Kind:       "CoolExtraResource",
								Namespace:  ptr.To[string]("cool-ns-scoped-ns"),
								Match:      &fnv1.ResourceSelector_MatchName{MatchName: "cool-ns-scoped-resource"},
							},
						},
					},
					Desired: &fnv1.State{Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)}},
				},
			},
		},
		"ExtraResourcesIn": {
			reason: "The Function should return the extra resources from the request.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "extra-resources-in"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
            "source": "items = [v.Resource for v in option(\"params\").extraResources[\"cool1\"]]\n"
            }
          }`),
					ExtraResources: map[string]*fnv1.Resources{
						"cool1": {
							Items: []*fnv1.Resource{
								{Resource: resource.MustStructJSON(xr)},
								{Resource: resource.MustStructJSON(cd)},
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "extra-resources-in", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-xr": {
								Resource: resource.MustStructJSON(xr),
							},
							"cool-cd": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"CD","metadata":{"annotations":{},"name":"cool-cd"}}`),
							},
						},
					},
				},
			},
		},
		"DuplicateExtraResourceKey": {
			reason: "The Function should return a fatal result if the extra resource key is duplicated.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "duplicate-extra-resources"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"ExtraResources\"\n  requirements = {\n    \"cool-extra-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchName: \"cool-extra-resource\"\n    }\n  }\n}\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"ExtraResources\"\n  requirements = {\n    \"cool-extra-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolExtraResource\"\n      matchName: \"another-cool-extra-resource\"\n    }\n  }\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "duplicate-extra-resources", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{
						{
							Severity: fnv1.Severity_SEVERITY_FATAL,
							Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
							Message:  "cannot process xr and state with the pipeline output in *v1.RunFunctionResponse: duplicate extra resource key \"cool-extra-resource\"",
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
		},
		"RequiredResources": {
			reason: "The Function should return the desired composite with required resources.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "required-resources"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"RequiredResources\"\n  requirements = {\n    \"cool-required-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      name: \"cool-required-resource\"\n    }\n  }\n},\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"RequiredResources\"\n  requirements = {\n    \"another-cool-required-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      matchLabels = {\n        key: \"value\"\n      }\n    }\n    \"yet-another-cool-required-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      name: \"foo\"\n    }\n  }\n},\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"RequiredResources\"\n  requirements = {\n    \"all-cool-resources\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      matchLabels = {}\n    }\n  }\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "required-resources", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Requirements: &fnv1.Requirements{
						Resources: map[string]*fnv1.ResourceSelector{
							"cool-required-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolRequiredResource",
								Match: &fnv1.ResourceSelector_MatchName{
									MatchName: "cool-required-resource",
								},
							},
							"another-cool-required-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolRequiredResource",
								Match: &fnv1.ResourceSelector_MatchLabels{
									MatchLabels: &fnv1.MatchLabels{
										Labels: map[string]string{"key": "value"},
									},
								},
							},
							"yet-another-cool-required-resource": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolRequiredResource",
								Match: &fnv1.ResourceSelector_MatchName{
									MatchName: "foo",
								},
							},
							"all-cool-resources": {
								ApiVersion: "example.org/v1",
								Kind:       "CoolRequiredResource",
								Match: &fnv1.ResourceSelector_MatchLabels{
									MatchLabels: &fnv1.MatchLabels{
										Labels: map[string]string{},
									},
								},
							},
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
		},
		"RequiredResourcesNamespacedName": {
			reason: "The Function should pass through a single required namespaced resource with name and namespace",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "required-resources-namespace-matchname"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {"name": "basic"},
						"spec": {
							"target": "Default",
							"source": "items = [{ apiVersion: \"meta.krm.kcl.dev/v1alpha1\", kind: \"RequiredResources\", requirements = { \"cool-ns-resource-matchname\" = { apiVersion: \"example.m.org/v1\", kind: \"CoolRequiredResource\", namespace: \"cool-ns-scoped-ns\", name: \"cool-ns-scoped-resource\" } } }]"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "required-resources-namespace-matchname", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Requirements: &fnv1.Requirements{
						Resources: map[string]*fnv1.ResourceSelector{
							"cool-ns-resource-matchname": {
								ApiVersion: "example.m.org/v1",
								Kind:       "CoolRequiredResource",
								Namespace:  ptr.To[string]("cool-ns-scoped-ns"),
								Match:      &fnv1.ResourceSelector_MatchName{MatchName: "cool-ns-scoped-resource"},
							},
						},
					},
					Desired: &fnv1.State{Composite: &fnv1.Resource{Resource: resource.MustStructJSON(xr)}},
				},
			},
		},
		"RequiredResourcesIn": {
			reason: "The Function should return the required resources from the request.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "required-resources-in"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
            "source": "items = [v.Resource for v in option(\"params\").requiredResources[\"cool1\"]]\n"
            }
          }`),
					RequiredResources: map[string]*fnv1.Resources{
						"cool1": {
							Items: []*fnv1.Resource{
								{Resource: resource.MustStructJSON(xr)},
								{Resource: resource.MustStructJSON(cd)},
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "required-resources-in", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-xr": {
								Resource: resource.MustStructJSON(xr),
							},
							"cool-cd": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"CD","metadata":{"annotations":{},"name":"cool-cd"}}`),
							},
						},
					},
				},
			},
		},
		"DuplicateRequiredResourceKey": {
			reason: "The Function should return a fatal result if the required resource key is duplicated.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "duplicate-required-resources"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"RequiredResources\"\n  requirements = {\n    \"cool-required-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      name: \"cool-required-resource\"\n    }\n  }\n}\n{\n  apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n  kind: \"RequiredResources\"\n  requirements = {\n    \"cool-required-resource\" = {\n      apiVersion: \"example.org/v1\"\n      kind: \"CoolRequiredResource\"\n      name: \"another-cool-required-resource\"\n    }\n  }\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "duplicate-required-resources", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{
						{
							Severity: fnv1.Severity_SEVERITY_FATAL,
							Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
							Message:  "cannot process xr and state with the pipeline output in *v1.RunFunctionResponse: duplicate required resource key \"cool-required-resource\"",
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(xr),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-cd": {
								Resource: resource.MustStructJSON(cd),
							},
						},
					},
				},
			},
		},
		"EmptyInputWithDefaultSource": {
			reason:        "The function should use the default source when input is not provided and default source is set",
			defaultSource: "{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n    metadata.name = \"generated\"\n}",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta:  &fnv1.RequestMeta{Tag: "empty-input"},
					Input: nil,
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "empty-input", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
						Resources: map[string]*fnv1.Resource{
							"generated": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"name":"generated"}}`),
							},
						},
					},
				},
			},
		},
		"EmptyInputWithoutDefaultSource": {
			reason: "The function should fail when input is not provided and default source is not set",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta:  &fnv1.RequestMeta{Tag: "empty-input"},
					Input: nil,
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "empty-input", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{{
						Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
						Severity: fnv1.Severity_SEVERITY_FATAL,
						Message:  "invalid function input: spec.source: Required value: kcl source cannot be empty",
					}},
				},
			},
		},
		"SetConditions": {
			reason: "The Function should return the conditions from the request.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "set-conditions"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [{\n    apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n    kind: \"Conditions\"\n    conditions = [{\n        target: \"CompositeAndClaim\"\n        force: False\n        condition = {\n            type: \"DatabaseReady\"\n            status: \"False\"\n            reason: \"FailedToCreate\"\n            message: \"Encountered an error creating the database\"\n        }\n    },{\n        target: \"Composite\"\n        force: False\n        condition = {\n            type: \"DatabaseReady\"\n            status: \"False\"\n            reason: \"FailedToValidate\"\n            message: \"Encountered an error during validation\"\n        }\n    }]\n}]"
            			}
          			}`),
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "set-conditions", Ttl: durationpb.New(response.DefaultTTL)},
					Conditions: []*fnv1.Condition{
						{
							Type:    "DatabaseReady",
							Status:  fnv1.Status_STATUS_CONDITION_FALSE,
							Reason:  "FailedToCreate",
							Message: ptr.To("Encountered an error creating the database"),
							Target:  fnv1.Target_TARGET_COMPOSITE_AND_CLAIM.Enum(),
						},
					},
					Results: []*fnv1.Result{},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{},
					},
				},
			},
		},
		"OberwriteCondition": {
			reason: "The Function should overwrite the first condition with the same target.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "overwrite-conditions"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [{\n    apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n    kind: \"Conditions\"\n    conditions = [{\n        target: \"CompositeAndClaim\"\n        force: False\n        condition = {\n            type: \"DatabaseReady\"\n            status: \"False\"\n            reason: \"FailedToCreate\"\n            message: \"Encountered an error creating the database\"\n        }\n    },{\n        target: \"Composite\"\n        force: True\n        condition = {\n            type: \"DatabaseReady\"\n            status: \"False\"\n            reason: \"DatabaseValidation\"\n            message: \"Encountered an error during validation\"\n        }\n    }]\n}]"
            			}
          			}`),
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "overwrite-conditions", Ttl: durationpb.New(response.DefaultTTL)},
					Conditions: []*fnv1.Condition{
						{
							Type:    "DatabaseReady",
							Status:  fnv1.Status_STATUS_CONDITION_FALSE,
							Reason:  "FailedToCreate",
							Message: ptr.To("Encountered an error creating the database"),
							Target:  fnv1.Target_TARGET_COMPOSITE_AND_CLAIM.Enum(),
						},
						{
							Type:    "DatabaseReady",
							Status:  fnv1.Status_STATUS_CONDITION_FALSE,
							Reason:  "DatabaseValidation",
							Message: ptr.To("Encountered an error during validation"),
							Target:  fnv1.Target_TARGET_COMPOSITE.Enum(),
						},
					},
					Results: []*fnv1.Result{},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{},
					},
				},
			},
		},
		"SetEvents": {
			reason: "The Function should return the events from the request.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "set-conditions"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [{\n    apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n    kind: \"Events\"\n    events = [{\n        target: \"CompositeAndClaim\"\n        event = {\n            type: \"Warning\"\n            reason: \"ResourceLimitExceeded\"\n            message: \"The resource limit has been exceeded\"\n        }\n    },{\n        target: \"Composite\"\n        event = {\n            type: \"Warning\"\n            reason: \"ValidationFailed\"\n            message: \"The validation failed\"\n        }\n    }]\n}]"
            			}
          			}`),
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:       &fnv1.ResponseMeta{Tag: "set-conditions", Ttl: durationpb.New(response.DefaultTTL)},
					Conditions: []*fnv1.Condition{},
					Results: []*fnv1.Result{
						{
							Severity: fnv1.Severity_SEVERITY_WARNING,
							Message:  "The resource limit has been exceeded",
							Reason:   ptr.To("ResourceLimitExceeded"),
							Target:   fnv1.Target_TARGET_COMPOSITE_AND_CLAIM.Enum(),
						},
						{
							Severity: fnv1.Severity_SEVERITY_WARNING,
							Message:  "The validation failed",
							Reason:   ptr.To("ValidationFailed"),
							Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
						},
					},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{},
					},
				},
			},
		},
		"SetContext": {
			reason: "The Function should be able to set context.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "set-context"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [{\n    apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n    kind: \"Context\"\n    data = {contextField: \"contextValue\"}\n}]"
            			}
          			}`),
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "set-context", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Context: resource.MustStructJSON(
						`{
							"contextField": "contextValue"
						  }`,
					),
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{},
					},
				},
			},
		},
		"MergeContext": {
			reason: "The Function should be able to set context merging with the input one.",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "merge-context"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "items = [{\n    apiVersion: \"meta.krm.kcl.dev/v1alpha1\"\n    kind: \"Context\"\n    data = {contextField: \"contextValue\"}\n}]"
            			}
          			}`),
					Context: resource.MustStructJSON(
						`{
                            "inputContext": "valueFromPreviousContext"
                        }`,
					),
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta:    &fnv1.ResponseMeta{Tag: "merge-context", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{},
					Context: resource.MustStructJSON(
						`{
							"contextField": "contextValue",
							"inputContext": "valueFromPreviousContext"
						 }`,
					),
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"","kind":""}`),
						},
						Resources: map[string]*fnv1.Resource{},
					},
				},
			},
		},
		"DuplicateNameError": {
			reason: "The Function should return a fatal result if composed resources have duplicate name",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "duplicate-name-error"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"source": "items = [\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata = {\n  name = \"metadata-name\"\n  annotations = {\"krm.kcl.dev/composition-resource-name\": \"duplicate-resource-name\"}}\n}\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.name = \"duplicate-resource-name\"\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "duplicate-name-error", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{
						{
							Severity: fnv1.Severity_SEVERITY_FATAL,
							Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
							Message:  "cannot process xr and state with the pipeline output in *v1.RunFunctionResponse: multiple composed resources with name \"duplicate-resource-name\" returned: Generated/metadata-name and Generated/duplicate-resource-name. Set different metadata.name or metadata.annotations.\"krm.kcl.dev/composition-resource-name\" to distinguish them.",
						},
					}},
			},
		},
		"ComposedSameNameAsXR": {
			reason: "The Function should succeed even when a composed resource has the same name as a patched composite",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "hello"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Default",
							"source": "[{\n    apiVersion: \"example.org/v1\"\n    kind: \"XR\"\n metadata.name = \"cool-xr\"\n},{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.name = \"cool-xr\"\n}]"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "hello", Ttl: durationpb.New(response.DefaultTTL)},
					Desired: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR","status":{}}`),
						},
						Resources: map[string]*fnv1.Resource{
							"cool-xr": {
								Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"Generated","metadata":{"name":"cool-xr"}}`),
							},
						},
					},
				},
			},
		},
		"ResourcesTargetDuplicateNameError": {
			reason: "The Function should return a fatal result if composed resources have duplicate name",
			args: args{
				req: &fnv1.RunFunctionRequest{
					Meta: &fnv1.RequestMeta{Tag: "duplicate-name-error"},
					Input: resource.MustStructJSON(`{
						"apiVersion": "krm.kcl.dev/v1alpha1",
						"kind": "KCLInput",
						"metadata": {
							"name": "basic"
						},
						"spec": {
							"target": "Resources",
							"source": "items = [\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata = {\n  name = \"metadata-name\"\n  annotations = {\"krm.kcl.dev/composition-resource-name\": \"duplicate-resource-name\"}}\n}\n{\n    apiVersion: \"example.org/v1\"\n    kind: \"Generated\"\n metadata.name = \"duplicate-resource-name\"\n}\n]\n"
						}
					}`),
					Observed: &fnv1.State{
						Composite: &fnv1.Resource{
							Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
						},
					},
				},
			},
			want: want{
				rsp: &fnv1.RunFunctionResponse{
					Meta: &fnv1.ResponseMeta{Tag: "duplicate-name-error", Ttl: durationpb.New(response.DefaultTTL)},
					Results: []*fnv1.Result{
						{
							Severity: fnv1.Severity_SEVERITY_FATAL,
							Target:   fnv1.Target_TARGET_COMPOSITE.Enum(),
							Message:  "cannot process xr and state with the pipeline output in *v1.RunFunctionResponse: multiple composed resources with name \"duplicate-resource-name\" returned: Generated/metadata-name and Generated/duplicate-resource-name. Set different metadata.name or metadata.annotations.\"krm.kcl.dev/composition-resource-name\" to distinguish them.",
						},
					}},
			},
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			// NOTE: This means we can't run tests in parallel.
			defaultSource = tc.defaultSource

			// f := &Function{log: logging.NewNopLogger()}
			f := &Function{log: logging.NewLogrLogger(testr.New(t))}
			rsp, err := f.RunFunction(tc.args.ctx, tc.args.req)

			if diff := cmp.Diff(tc.want.rsp, rsp, protocmp.Transform()); diff != "" {
				t.Errorf("%s\nf.RunFunction(...): -want rsp, +got rsp:\n%s", tc.reason, diff)
			}

			if diff := cmp.Diff(tc.want.err, err, cmpopts.EquateErrors()); diff != "" {
				t.Errorf("%s\nf.RunFunction(...): -want err, +got err:\n%s", tc.reason, diff)
			}
		})
	}
}

// TestNestedIfAugAssignNoDuplicate is a regression test for issue #437.
//
// KCL 0.12.0–0.12.4 contained a lazy-evaluation replay bug: statements inside
// an `if` body whose block had an `else` branch were executed more than once,
// and `_items += [...]` accumulated on every replay. The result was two
// resources with the same `krm.kcl.dev/composition-resource-name` annotation,
// which the duplicate-name check rejects as a fatal result:
//
//	multiple composed resources with name "versioning" returned: ...
//
// Fixed upstream by kcl-lang/kcl#2120, #2139, #2142 (merged 2026-08), shipped
// via kcl-go / lib v0.12.5. This test asserts the bug stays fixed.
func TestNestedIfAugAssignNoDuplicate(t *testing.T) {
	// The inner `if` must have an `else` branch for the replay to trigger
	// (verified by Peefy in #437). With both outer and inner conditions true,
	// only the inner-`if`-then branch is logically taken, so the expected
	// output is three distinct resources: bucket, policy, versioning.
	src := "_items = [{\"apiVersion\": \"example.org/v1\", \"kind\": \"Bucket\", \"metadata\": {\"annotations\": {\"krm.kcl.dev/composition-resource-name\": \"bucket\"}}}]\n" +
		"if True:\n" +
		"    _items += [{\"apiVersion\": \"example.org/v1\", \"kind\": \"BucketPolicy\", \"metadata\": {\"annotations\": {\"krm.kcl.dev/composition-resource-name\": \"policy\"}}}]\n" +
		"    if True:\n" +
		"        _items += [{\"apiVersion\": \"example.org/v1\", \"kind\": \"BucketVersioning\", \"metadata\": {\"annotations\": {\"krm.kcl.dev/composition-resource-name\": \"versioning\"}}}]\n" +
		"    else:\n" +
		"        _items += [{\"apiVersion\": \"example.org/v1\", \"kind\": \"BucketOther\", \"metadata\": {\"annotations\": {\"krm.kcl.dev/composition-resource-name\": \"other\"}}}]\n" +
		"items = _items\n"

	srcJSON, err := json.Marshal(src)
	if err != nil {
		t.Fatalf("marshal source: %v", err)
	}

	req := &fnv1.RunFunctionRequest{
		Meta: &fnv1.RequestMeta{Tag: "nested-if-aug-assign"},
		Input: resource.MustStructJSON(`{
			"apiVersion": "krm.kcl.dev/v1alpha1",
			"kind": "KCLInput",
			"metadata": {"name": "basic"},
			"spec": {
				"target": "Default",
				"source": ` + string(srcJSON) + `
			}
		}`),
		Observed: &fnv1.State{
			Composite: &fnv1.Resource{
				Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
			},
		},
	}

	f := &Function{log: logging.NewLogrLogger(testr.New(t))}
	rsp, err := f.RunFunction(context.Background(), req)
	if err != nil {
		t.Fatalf("f.RunFunction: unexpected error: %v", err)
	}

	// No fatal result: the bug surfaces as a duplicate-resource-name fatal
	// from the crossplane-runtime pipeline, so an empty Results slice proves
	// the KCL runtime produced a non-duplicate `items` list.
	for _, r := range rsp.GetResults() {
		if r.GetSeverity() == fnv1.Severity_SEVERITY_FATAL {
			t.Fatalf("unexpected fatal result: %s", r.GetMessage())
		}
	}

	// Exact key set, in any order. A duplicate would push "versioning" twice
	// into the map (Go collapses duplicates silently, so the bug shows up as a
	// missing "policy" key with one of the resources lost), and would also
	// have triggered the fatal check above.
	gotKeys := make([]string, 0, len(rsp.GetDesired().GetResources()))
	for k := range rsp.GetDesired().GetResources() {
		gotKeys = append(gotKeys, k)
	}
	want := []string{"bucket", "policy", "versioning"}
	if diff := cmp.Diff(want, gotKeys, cmpopts.SortSlices(func(a, b string) bool { return a < b })); diff != "" {
		t.Errorf("unexpected resource keys (-want, +got):\n%s", diff)
	}
}

// TestListCompInsideLambdaIfElse is a regression test for issue #285.
//
// The original report described a "v0.11.4 duplicate-name" error with direct
// list comprehensions in KCL compositions. The reporter's program used a
// lambda (`_metadata`) whose body had an `if/else` assigning to a schema
// key, then built a list of resources via `_items += [...] for idx, s in
// subnets`. The KCL evaluator's lazy-evaluation replay applied the lambda
// body more than once, producing duplicate entries in `_items`, and the
// duplicate-name check in the crossplane-runtime pipeline rejected them.
//
// Same root cause as #437 (kcl-lang/kcl#1833 lazy-replay), same fix
// (kcl-lang/kcl#2120, #2139, #2142, shipped via kcl-go / lib v0.12.5).
func TestListCompInsideLambdaIfElse(t *testing.T) {
	// Mirrors the reproduction in #285, simplified to inline data.
	src := "_metadata = lambda id: str, suffix: str -> any {\n" +
		"    {\n" +
		"        metadata.annotations = {\n" +
		"            if suffix == \"\":\n" +
		"                \"krm.kcl.dev/composition-resource-name\" = id\n" +
		"            else:\n" +
		"                \"krm.kcl.dev/composition-resource-name\" = id + \"-\" + suffix\n" +
		"        }\n" +
		"    }\n" +
		"}\n" +
		"_items: [any] = []\n" +
		"_items += [_metadata(\"net\", \"public-${idx}\") for idx in [0, 1]]\n" +
		"_items += [_metadata(\"net\", \"private-${idx}\") for idx in [0, 1]]\n" +
		"items = _items\n"

	srcJSON, err := json.Marshal(src)
	if err != nil {
		t.Fatalf("marshal source: %v", err)
	}

	req := &fnv1.RunFunctionRequest{
		Meta: &fnv1.RequestMeta{Tag: "list-comp-lambda-if-else"},
		Input: resource.MustStructJSON(`{
			"apiVersion": "krm.kcl.dev/v1alpha1",
			"kind": "KCLInput",
			"metadata": {"name": "basic"},
			"spec": {
				"target": "Default",
				"source": ` + string(srcJSON) + `
			}
		}`),
		Observed: &fnv1.State{
			Composite: &fnv1.Resource{
				Resource: resource.MustStructJSON(`{"apiVersion":"example.org/v1","kind":"XR"}`),
			},
		},
	}

	f := &Function{log: logging.NewLogrLogger(testr.New(t))}
	rsp, err := f.RunFunction(context.Background(), req)
	if err != nil {
		t.Fatalf("f.RunFunction: unexpected error: %v", err)
	}

	for _, r := range rsp.GetResults() {
		if r.GetSeverity() == fnv1.Severity_SEVERITY_FATAL {
			t.Fatalf("unexpected fatal result: %s", r.GetMessage())
		}
	}

	gotKeys := make([]string, 0, len(rsp.GetDesired().GetResources()))
	for k := range rsp.GetDesired().GetResources() {
		gotKeys = append(gotKeys, k)
	}
	want := []string{"net-private-0", "net-private-1", "net-public-0", "net-public-1"}
	if diff := cmp.Diff(want, gotKeys, cmpopts.SortSlices(func(a, b string) bool { return a < b })); diff != "" {
		t.Errorf("unexpected resource keys (-want, +got):\n%s", diff)
	}
}

const (
	xrFile          = "xr.yaml"
	compositionFile = "composition.yaml"
)

func findXRandCompositionYAMLFiles(rootPath string) ([]string, error) {
	var dirs []string

	// Walk receives the root directory and a function to process each path
	err := filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
		if err != nil { // Handle potential errors
			return err
		}

		// Check if the current path is a directory and it contains xr.yaml file
		if info.IsDir() {
			xrPath := filepath.Join(path, xrFile)
			compositionPath := filepath.Join(path, compositionFile)
			if _, err := os.Stat(xrPath); err == nil {
				if _, err := os.Stat(compositionPath); err == nil {
					dirs = append(dirs, path) // File exists, add directory to list
				}
			}
		}

		return nil
	})

	return dirs, err
}

func readResourceFromFile(p string) (*structpb.Struct, error) {
	c, err := os.ReadFile(p)
	if err != nil {
		return nil, err
	}
	o, err := kube.ParseKubeObject(c)
	if err != nil {
		return nil, err
	}
	j, err := o.Node().MarshalJSON()
	if err != nil {
		return nil, err
	}
	return resource.MustStructJSON(string(j)), nil
}

func TestFunctionExamples(t *testing.T) {
	rootPath := "examples" // Change to your examples folder path
	dirs, err := findXRandCompositionYAMLFiles(rootPath)
	if err != nil {
		t.Fatal(err)
	}
	// Print all directories containing xr.yaml file
	for _, dir := range dirs {
		xrPath := filepath.Join(dir, xrFile)
		compositionPath := filepath.Join(dir, compositionFile)
		t.Run(compositionPath, func(t *testing.T) {
			f := &Function{log: logging.NewNopLogger()}
			input, err := readResourceFromFile(xrPath)
			if err != nil {
				t.Fatal(err)
			}
			oxr, err := readResourceFromFile(compositionPath)
			if err != nil {
				t.Fatal(err)
			}
			req := &fnv1.RunFunctionRequest{
				Input: input,
				// option("params").oxr
				Observed: &fnv1.State{
					Composite: &fnv1.Resource{
						Resource: oxr,
					},
				},
			}
			_, err = f.RunFunction(context.TODO(), req)
			if err != nil {
				t.Fatal(err)
			}
		})
	}
}