// Copyright 2021 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 main

import (
	"io/ioutil"
	"os"
	"testing"

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

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

	tests := []struct {
		name             string
		inputProperties  map[string]interface{}
		builderData      string
		expectProperties map[string]interface{}
		expectErr        bool
	}{
		{
			name: "property versioning disabled",
			inputProperties: map[string]interface{}{
				"foo": "bar",
			},
			expectProperties: map[string]interface{}{
				"foo": "bar",
			},
		},
		{
			name: "property versioning enabled",
			inputProperties: map[string]interface{}{
				"enable_property_versioning": true,
			},
			builderData: `
				swarming {
					builders {
						properties: '{"foo": "bar"}'
					}
				}`,
			expectProperties: map[string]interface{}{
				"enable_property_versioning": true,
				"foo":                        "bar",
			},
		},
		{
			name: "request properties override integration.git properties",
			builderData: `
				swarming {
					builders {
						properties: '{"foo": "bar"}'
					}
				}`,
			inputProperties: map[string]interface{}{
				"enable_property_versioning": true,
				"foo":                        "user",
			},
			expectProperties: map[string]interface{}{
				"enable_property_versioning": true,
				"foo":                        "user",
			},
		},
		{
			name: "Multiple builders",
			inputProperties: map[string]interface{}{
				"enable_property_versioning": true,
			},
			builderData: `
				swarming {
					builders {
						properties: '{"mock_property": "1"}'
					}
					builders {
						properties: '{"mock_property": "2"}'
					}
				}`,
			expectErr: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			tmpFile, err := ioutil.TempFile(t.TempDir(), "builder.textproto")
			if err != nil {
				t.Fatal(err)
			}
			defer tmpFile.Close()
			defer os.Remove(tmpFile.Name())
			if _, err := tmpFile.Write([]byte(test.builderData)); err != nil {
				t.Fatal(err)
			}
			build := &buildbucketpb.Build{Input: &buildbucketpb.Build_Input{}}
			build.Input.Properties, err = structpb.NewStruct(test.inputProperties)
			if err != nil {
				t.Fatal(err)
			}
			err = resolveBuildProperties(tmpFile.Name(), build)
			if err != nil {
				if !test.expectErr {
					t.Fatalf("got unexpected error: %v", err)
				}
				return
			} else if test.expectErr {
				t.Fatalf("expected error, got nil")
			}
			if diff := cmp.Diff(test.expectProperties, build.Input.Properties.AsMap()); diff != "" {
				t.Errorf("mergeProperties(): output differs (-want, +got):\n%s", diff)
			}
		})
	}
}

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

	tests := []struct {
		name             string
		builderData      string
		expectProperties map[string]interface{}
		expectErr        bool
	}{
		{
			name:        "Builder file data doesn't match the Bucket schema",
			builderData: `"foo":bar`,
			expectErr:   true,
		},
		{
			name: "Different type of properties",
			builderData: `
				swarming {
					builders {
						properties:
						'{'
						'  "nested_map": {'
						'    "server": "url"'
						'  },'
						'  "number": 1234,'
						'  "bool": true'
						'}'
					}
				}`,
			expectProperties: map[string]interface{}{
				"nested_map": map[string]interface{}{
					"server": "url",
				},
				"number": float64(1234),
				"bool":   true,
			},
		},
		{
			name:      "No builders in builder file",
			expectErr: true,
		},
		{
			name: "Multiple builders in builder file",
			builderData: `
				swarming {
					builders {
						properties: '{"mock_property": ""}'
					}
					builders {
						properties: '{"mock_property": ""}'
					}
				}`,
			expectErr: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			got, err := builderProperties([]byte(test.builderData))
			if err != nil {
				if !test.expectErr {
					t.Fatalf("got unexpected error: %v", err)
				}
				return
			} else if test.expectErr {
				t.Fatalf("expected error, got nil")
			}
			if diff := cmp.Diff(test.expectProperties, got.AsMap()); diff != "" {
				t.Errorf("builderProperties(): output differs (-want, +got):\n%s", diff)
			}
		})
	}
}