go.fuchsia.dev/infra@v0.0.0-20240507153436-9b593402251b/cmd/recipe_wrapper/props/props_test.go

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package props

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	buildbucketpb "go.chromium.org/luci/buildbucket/proto"
	apipb "go.chromium.org/luci/swarming/proto/api"
	"google.golang.org/protobuf/testing/protocmp"
	"google.golang.org/protobuf/types/known/structpb"
)

func TestGetStringInputProperty(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name          string
		props         map[string]any
		expectedValue string
		expectErr     bool
	}{
		{
			name: "valid string",
			props: map[string]any{
				"string": "foo",
			},
			expectedValue: "foo",
		},
		{
			name:          "unset",
			props:         map[string]any{},
			expectedValue: "",
		},
		{
			name: "invalid value",
			props: map[string]any{
				"string": 123,
			},
			expectErr: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			build := buildWithProperties(t, test.props)
			value, err := String(build, "string")
			if err == nil {
				if test.expectErr {
					t.Fatalf("expected error, got nil")
				}
			} else if !test.expectErr {
				t.Fatalf("got unexpected error: %s", err)
			}
			if value != test.expectedValue {
				t.Fatalf("expected string value %s, got %s", test.expectedValue, value)
			}
		})
	}
}

func TestGetBoolInputProperty(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name          string
		props         map[string]any
		expectedValue bool
		expectErr     bool
	}{
		{
			name: "valid bool",
			props: map[string]any{
				"bool": true,
			},
			expectedValue: true,
		},
		{
			name:          "unset",
			props:         map[string]any{},
			expectedValue: false,
		},
		{
			name: "invalid value",
			props: map[string]any{
				"bool": 123,
			},
			expectErr: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			build := buildWithProperties(t, test.props)
			value, err := Bool(build, "bool")
			if err == nil {
				if test.expectErr {
					t.Fatalf("expected error, got nil")
				}
			} else if !test.expectErr {
				t.Fatalf("got unexpected error %q", err)
			}
			if value != test.expectedValue {
				t.Fatalf("expected bool value %t, got %t", test.expectedValue, value)
			}
		})
	}
}

func TestSetInputProperty(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		props     map[string]any
		key       string
		value     any
		expectErr bool
	}{
		{
			name:  "string value",
			props: map[string]any{},
			key:   "foo",
			value: "bar",
		},
		{
			name: "overwrite nested value",
			props: map[string]any{
				"foo": map[string]any{
					"foo": "",
				},
			},
			key:   "foo",
			value: "bar",
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			build := buildWithProperties(t, test.props)
			err := SetBuildInputProperty(build, test.key, test.value)
			if err == nil {
				if test.expectErr {
					t.Fatalf("expected error, got nil")
				}
			} else if !test.expectErr {
				t.Fatalf("got unexpected error: %s", err)
			}
			gotValue, err := String(build, test.key)
			if err == nil {
				if test.expectErr {
					t.Fatalf("expected error, got nil")
				}
			} else if !test.expectErr {
				t.Fatalf("got unexpected error: %s", err)
			}
			if test.value != gotValue {
				t.Fatalf("expected value %s, got %s", test.value, gotValue)
			}
		})
	}
}

func TestGetProtoInputProperty(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		key   string
		props map[string]any
		// We somewhat arbitrarily choose CASReference as the proto message for
		// testing this general-purpose function because it contains a good mix
		// of field types, and it's a type that we actually care about reading
		// from a property.
		expected *apipb.CASReference
	}{
		{
			name: "property missing",
			key:  "prop",
			props: map[string]any{
				"foo": "bar",
			},
			expected: &apipb.CASReference{},
		},
		{
			name: "property set",
			key:  "prop",
			props: map[string]any{
				"prop": map[string]any{
					"cas_instance": "cas_instance_name",
					"digest": map[string]any{
						"hash": "abc123",
						// jsonpb serializes int64 to string.
						"size_bytes": "587",
					},
				},
				"foo": "bar",
			},
			expected: &apipb.CASReference{
				CasInstance: "cas_instance_name",
				Digest: &apipb.Digest{
					Hash:      "abc123",
					SizeBytes: 587,
				},
			},
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			build := buildWithProperties(t, test.props)
			casRef := &apipb.CASReference{}
			if err := Proto(build, test.key, casRef); err != nil {
				t.Fatal(err)
			}
			if diff := cmp.Diff(test.expected, casRef, protocmp.Transform()); diff != "" {
				t.Errorf("Unexpected CAS reference diff (-want +got):\n%s", diff)
			}
		})
	}
}

// buildWithProperties returns a Build proto object with the given input
// properties.
func buildWithProperties(t *testing.T, props map[string]any) *buildbucketpb.Build {
	t.Helper()
	structProps, err := structpb.NewStruct(props)
	if err != nil {
		t.Fatal(err)
	}
	return &buildbucketpb.Build{
		Input: &buildbucketpb.Build_Input{
			Properties: structProps,
		},
	}
}