Test.go

// Package main generates a CompositionTest
package main

import (
	"encoding/json"
	"fmt"
	"os"

	"k8s.io/utils/ptr"
	"sigs.k8s.io/yaml"

	platformv1alpha1 "dev.upbound.io/models/com/example/platform/v1alpha1"
	metav1 "dev.upbound.io/models/io/k8s/meta/v1"
	s3v1beta1 "dev.upbound.io/models/io/upbound/aws/s3/v1beta1"
	metav1alpha1 "dev.upbound.io/models/io/upbound/dev/meta/v1alpha1"
)

func main() {
	xr := platformv1alpha1.XStorageBucket{
		APIVersion: ptr.To(platformv1alpha1.XStorageBucketAPIVersionplatformExampleComV1Alpha1),
		Kind:       ptr.To(platformv1alpha1.XStorageBucketKindXStorageBucket),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl"),
		},
		Spec: &platformv1alpha1.XStorageBucketSpec{
			Parameters: &platformv1alpha1.XStorageBucketSpecParameters{
				ACL:        ptr.To("public-read"),
				Region:     ptr.To("us-west-1"),
				Versioning: ptr.To(true),
			},
			CompositionSelector: &platformv1alpha1.XStorageBucketSpecCompositionSelector{
				MatchLabels: &map[string]string{
					"language": "kcl",
				},
			},
		},
	}

	acl := s3v1beta1.BucketACL{
		APIVersion: ptr.To(s3v1beta1.BucketACLApiVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketACLKindBucketACL),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-acl"),
		},
		Spec: &s3v1beta1.BucketACLSpec{
			ForProvider: &s3v1beta1.BucketACLSpecForProvider{
				ACL: ptr.To("public-read"),
				BucketRef: &s3v1beta1.BucketACLSpecForProviderBucketRef{
					Name: ptr.To("example-kcl-bucket"),
				},
				Region: ptr.To("us-west-1"),
			},
		},
	}

	boc := s3v1beta1.BucketOwnershipControls{
		APIVersion: ptr.To(s3v1beta1.BucketOwnershipControlsAPIVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketOwnershipControlsKindBucketOwnershipControls),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-boc"),
		},
		Spec: &s3v1beta1.BucketOwnershipControlsSpec{
			ForProvider: &s3v1beta1.BucketOwnershipControlsSpecForProvider{
				BucketRef: &s3v1beta1.BucketOwnershipControlsSpecForProviderBucketRef{
					Name: ptr.To("example-kcl-bucket"),
				},
				Region: ptr.To("us-west-1"),
				Rule: &[]s3v1beta1.BucketOwnershipControlsSpecForProviderRuleItem{
					{
						ObjectOwnership: ptr.To("BucketOwnerPreferred"),
					},
				},
			},
		},
	}

	bucket := s3v1beta1.Bucket{
		APIVersion: ptr.To(s3v1beta1.BucketAPIVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketKindBucket),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-bucket"),
		},
		Spec: &s3v1beta1.BucketSpec{
			ForProvider: &s3v1beta1.BucketSpecForProvider{
				Region: ptr.To("us-west-1"),
			},
		},
	}

	encryption := s3v1beta1.BucketServerSideEncryptionConfiguration{
		APIVersion: ptr.To(s3v1beta1.BucketServerSideEncryptionConfigurationAPIVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketServerSideEncryptionConfigurationKindBucketServerSideEncryptionConfiguration),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-encryption"),
		},
		Spec: &s3v1beta1.BucketServerSideEncryptionConfigurationSpec{
			ForProvider: &s3v1beta1.BucketServerSideEncryptionConfigurationSpecForProvider{
				BucketRef: &s3v1beta1.BucketServerSideEncryptionConfigurationSpecForProviderBucketRef{
					Name: ptr.To("example-kcl-bucket"),
				},
				Region: ptr.To("us-west-1"),
				Rule: &[]s3v1beta1.BucketServerSideEncryptionConfigurationSpecForProviderRuleItem{
					{
						ApplyServerSideEncryptionByDefault: &[]s3v1beta1.BucketServerSideEncryptionConfigurationSpecForProviderRuleItemApplyServerSideEncryptionByDefaultItem{
							{
								SseAlgorithm: ptr.To("AES256"),
							},
						},
						BucketKeyEnabled: ptr.To(true),
					},
				},
			},
		},
	}

	pab := s3v1beta1.BucketPublicAccessBlock{
		APIVersion: ptr.To(s3v1beta1.BucketPublicAccessBlockAPIVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketPublicAccessBlockKindBucketPublicAccessBlock),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-pab"),
		},
		Spec: &s3v1beta1.BucketPublicAccessBlockSpec{
			ForProvider: &s3v1beta1.BucketPublicAccessBlockSpecForProvider{
				BlockPublicAcls:   ptr.To(false),
				BlockPublicPolicy: ptr.To(false),
				BucketRef: &s3v1beta1.BucketPublicAccessBlockSpecForProviderBucketRef{
					Name: ptr.To("example-kcl-bucket"),
				},
				IgnorePublicAcls:      ptr.To(false),
				Region:                ptr.To("us-west-1"),
				RestrictPublicBuckets: ptr.To(false),
			},
		},
	}

	versioning := s3v1beta1.BucketVersioning{
		APIVersion: ptr.To(s3v1beta1.BucketVersioningAPIVersions3AwsUpboundIoV1Beta1),
		Kind:       ptr.To(s3v1beta1.BucketVersioningKindBucketVersioning),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To("example-kcl-versioning"),
		},
		Spec: &s3v1beta1.BucketVersioningSpec{
			ForProvider: &s3v1beta1.BucketVersioningSpecForProvider{
				BucketRef: &s3v1beta1.BucketVersioningSpecForProviderBucketRef{
					Name: ptr.To("example-kcl-bucket"),
				},
				Region: ptr.To("us-west-1"),
				VersioningConfiguration: &[]s3v1beta1.BucketVersioningSpecForProviderVersioningConfigurationItem{
					{
						Status: ptr.To("Enabled"),
					},
				},
			},
		},
	}

	// Convert typed resources to map[string]interface{}
	assertResources := resourcesToItems[metav1alpha1.CompositionTestSpecAssertResourcesItem](xr, acl, boc, bucket, encryption, pab, versioning)
	test := metav1alpha1.CompositionTest{
		APIVersion: ptr.To(metav1alpha1.CompositionTestAPIVersionmetaDevUpboundIoV1Alpha1),
		Kind:       ptr.To(metav1alpha1.CompositionTestKindCompositionTest),
		Metadata: &metav1.ObjectMeta{
			Name: ptr.To(""),
		},
		Spec: &metav1alpha1.CompositionTestSpec{
			AssertResources: &assertResources,
			CompositionPath: ptr.To("apis/kcl/composition.yaml"),
			XrPath:          ptr.To("examples/kcl/example.yaml"),
			XrdPath:         ptr.To("apis/xstoragebuckets/definition.yaml"),
			TimeoutSeconds:  ptr.To(120),
			Validate:        ptr.To(false),
		},
	}

	// Wrap in items array as expected by the test runner
	output := map[string]interface{}{
		"items": []interface{}{test},
	}

	out, err := yaml.Marshal(output)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error encoding YAML: %v\n", err)
		os.Exit(1)
	}
	fmt.Print(string(out))
}

func toItem[T any](resource interface{}) T {
	var item T
	if err := convertViaJSON(&item, resource); err != nil {
		panic(fmt.Sprintf("converting item: %v", err))
	}
	return item
}

func resourcesToItems[T any](resources ...interface{}) []T {
	items := make([]T, 0, len(resources))
	for _, res := range resources {
		items = append(items, toItem[T](res))
	}
	return items
}

func convertViaJSON(to, from any) error {
	bs, err := json.Marshal(from)
	if err != nil {
		return err
	}
	return json.Unmarshal(bs, to)
}