136 lines
4.1 KiB
Go
136 lines
4.1 KiB
Go
package resources
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/terraform-plugin-framework/diag"
|
|
"github.com/hashicorp/terraform-plugin-framework/types"
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
|
)
|
|
|
|
func TestValidatePackageSource(t *testing.T) {
|
|
var diagnostics diag.Diagnostics
|
|
ok := validatePackageSource(types.StringValue("code"), types.StringNull(), &diagnostics)
|
|
if !ok || diagnostics.HasError() {
|
|
t.Fatalf("expected valid source_dir-only config")
|
|
}
|
|
|
|
diagnostics = diag.Diagnostics{}
|
|
ok = validatePackageSource(types.StringNull(), types.StringValue("main.zip"), &diagnostics)
|
|
if !ok || diagnostics.HasError() {
|
|
t.Fatalf("expected valid code_path-only config")
|
|
}
|
|
|
|
diagnostics = diag.Diagnostics{}
|
|
ok = validatePackageSource(types.StringNull(), types.StringNull(), &diagnostics)
|
|
if ok || !diagnostics.HasError() {
|
|
t.Fatalf("expected invalid config when both values are empty")
|
|
}
|
|
}
|
|
|
|
func TestLoadPackageLiteralFromSourceDir(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
mainPath := filepath.Join(tempDir, "main.py")
|
|
content := []byte("def main():\n return 'ok'\n")
|
|
if err := os.WriteFile(mainPath, content, 0o600); err != nil {
|
|
t.Fatalf("write temp main.py: %v", err)
|
|
}
|
|
|
|
loaded, err := loadPackageLiteral(tempDir, "")
|
|
if err != nil {
|
|
t.Fatalf("loadPackageLiteral returned error: %v", err)
|
|
}
|
|
if string(loaded) != string(content) {
|
|
t.Fatalf("unexpected loaded content")
|
|
}
|
|
}
|
|
|
|
func TestPackageToUnstructured(t *testing.T) {
|
|
input := packageResourceModel{
|
|
Name: types.StringValue("pkg-a"),
|
|
Environment: types.StringValue("env-a"),
|
|
}
|
|
|
|
obj := packageToUnstructured(input, "default", []byte("print('hi')"))
|
|
literal, found, err := unstructured.NestedString(obj.Object, "spec", "deployment", "literal")
|
|
if err != nil || !found {
|
|
t.Fatalf("deployment.literal not found")
|
|
}
|
|
|
|
decoded, err := base64.StdEncoding.DecodeString(literal)
|
|
if err != nil {
|
|
t.Fatalf("decode literal: %v", err)
|
|
}
|
|
if string(decoded) != "print('hi')" {
|
|
t.Fatalf("unexpected decoded literal: %q", string(decoded))
|
|
}
|
|
}
|
|
|
|
func TestResolveNamespace(t *testing.T) {
|
|
if got := resolveNamespace(types.StringValue("custom"), "default"); got != "custom" {
|
|
t.Fatalf("unexpected namespace: %q", got)
|
|
}
|
|
if got := resolveNamespace(types.StringNull(), "default"); got != "default" {
|
|
t.Fatalf("unexpected namespace fallback: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestUnstructuredToPackageModelSetsNullComputed(t *testing.T) {
|
|
obj := &unstructured.Unstructured{Object: map[string]interface{}{
|
|
"apiVersion": "fission.io/v1",
|
|
"kind": "Package",
|
|
"metadata": map[string]interface{}{
|
|
"name": "pkg-a",
|
|
"namespace": "default",
|
|
},
|
|
"spec": map[string]interface{}{
|
|
"environment": map[string]interface{}{"name": "env-a"},
|
|
},
|
|
}}
|
|
|
|
state := unstructuredToPackageModel(obj, packageResourceModel{})
|
|
if !state.BuildStatus.IsNull() {
|
|
t.Fatalf("expected build_status to be null when status is absent")
|
|
}
|
|
if !state.BuildLog.IsNull() {
|
|
t.Fatalf("expected build_log to be null when status is absent")
|
|
}
|
|
}
|
|
|
|
func TestHTTPTriggerRoundTrip(t *testing.T) {
|
|
ctx := context.Background()
|
|
methods, diagnostics := types.ListValueFrom(ctx, types.StringType, []string{"GET", "POST"})
|
|
if diagnostics.HasError() {
|
|
t.Fatalf("failed to create methods list")
|
|
}
|
|
|
|
model := httpTriggerResourceModel{
|
|
Name: types.StringValue("tr-a"),
|
|
Function: types.StringValue("fn-a"),
|
|
URL: types.StringValue("/hello"),
|
|
Methods: methods,
|
|
CreateIngress: types.BoolValue(true),
|
|
Host: types.StringValue("fission.kube5s.ru"),
|
|
}
|
|
|
|
obj, err := httpTriggerToUnstructured(ctx, model, "default")
|
|
if err != nil {
|
|
t.Fatalf("httpTriggerToUnstructured error: %v", err)
|
|
}
|
|
|
|
state := unstructuredToHTTPTriggerModel(ctx, obj, model)
|
|
if state.Name.ValueString() != "tr-a" {
|
|
t.Fatalf("unexpected trigger name: %q", state.Name.ValueString())
|
|
}
|
|
if state.Function.ValueString() != "fn-a" {
|
|
t.Fatalf("unexpected function name: %q", state.Function.ValueString())
|
|
}
|
|
if state.URL.ValueString() != "/hello" {
|
|
t.Fatalf("unexpected url: %q", state.URL.ValueString())
|
|
}
|
|
}
|