// Copyright 2018 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 resultstore_test

import (
	"context"
	"reflect"
	"testing"
	"time"

	"fuchsia.googlesource.com/infra/infra/tilo/resultstore"
	mocks "fuchsia.googlesource.com/infra/infra/tilo/resultstore/mocks"
	"github.com/golang/mock/gomock"

	api "google.golang.org/genproto/googleapis/devtools/resultstore/v2"
	"google.golang.org/genproto/protobuf/field_mask"
)

var (
	// The value of entity start times and durations is not important for these tests,
	// so we use the same value everywhere.
	may18_1993 = time.Date(1993, time.May, 18, 0, 0, 0, 0, time.UTC)

	// The specific values of the UUIDs are not important for these tests. We just want to
	// verify that the service sets some value other than the empty string, so we just use
	// the same UUID everywhere.
	testUUID = "uuid"
)

// serviceTestBed manages the setup and teardown phases of individual test cases.
type serviceTestBed struct {
	MockRPCClient *mocks.MockResultStoreUploadClient
	ctrl          *gomock.Controller
}

// Setup creates the service-under-test and should be run before every test case.
func (bed *serviceTestBed) Setup(t *testing.T, authToken string) (resultstore.Service, context.Context) {
	// Cache the mock controller so we can Finish() it during test teardown.
	bed.ctrl = gomock.NewController(t)
	bed.MockRPCClient = mocks.NewMockResultStoreUploadClient(bed.ctrl)

	// Force Service to re-use a fake UUID for testing by embedding the UUID in the
	// context object.
	ctx, err := resultstore.SetTestUUID(context.Background(), testUUID)
	if err != nil {
		t.Fatal(err)
	}

	ctx, err = resultstore.SetAuthToken(ctx, authToken)
	if err != nil {
		t.Fatal(err)
	}

	return resultstore.NewService(bed.MockRPCClient), ctx
}

// Teardown is used to clean up after every test-case.
func (bed *serviceTestBed) Teardown() {
	bed.ctrl.Finish()
}

// ExpectRPC is used to expect that a specific RPC message is recieved by the test bed.
// If an invalid message or no message is received, the test will fail.
func (bed *serviceTestBed) ExpectRPC() *mocks.MockResultStoreUploadClientMockRecorder {
	return bed.MockRPCClient.EXPECT()
}

func expectEqual(t *testing.T, expected interface{}, actual interface{}) {
	if !reflect.DeepEqual(expected, actual) {
		t.Errorf("Objects do not match:\n")
		t.Errorf("Expected: %+v\n", expected)
		t.Errorf("Actual:   %+v\n", actual)
	}
}

func TestService_CreateInvocation(t *testing.T) {
	t.Run("should return an Invocation from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.Invocation{
			ProjectID:  "123456789",
			ID:         "invocation_id",
			Users:      []string{"user"},
			Labels:     []string{"label"},
			Properties: map[string]string{"key": "value"},
			LogURL:     "http://test.log",
			StartTime:  may18_1993,
			Status:     resultstore.Passed,
		}

		testBed.ExpectRPC().
			CreateInvocation(ctx, &api.CreateInvocationRequest{
				RequestId:          testUUID,
				AuthorizationToken: "auth_token",
				InvocationId:       "invocation_id",
				Invocation:         input.ToResultStoreInvocation(),
			}).
			Return(input.ToResultStoreInvocation(), nil)

		output, err := service.CreateInvocation(ctx, input)
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_UpdateInvocation(t *testing.T) {
	t.Run("should return an Invocation from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.Invocation{
			ID:         "invocation_id",
			Properties: map[string]string{"key": "value"},
			ProjectID:  "project_id",
			StartTime:  may18_1993,
			Duration:   time.Hour,
			Users:      []string{"users"},
			Labels:     []string{"label"},
			LogURL:     "url",
			Status:     resultstore.Passed,
		}

		testBed.ExpectRPC().
			UpdateInvocation(ctx, &api.UpdateInvocationRequest{
				AuthorizationToken: "auth_token",
				Invocation:         input.ToResultStoreInvocation(),
				UpdateMask: &field_mask.FieldMask{
					Paths: []string{"timing.duration", "status_attributes"},
				},
			}).
			Return(input.ToResultStoreInvocation(), nil)

		output, err := service.UpdateInvocation(ctx, input)
		if err != nil {
			t.Fatal(err)
		}
		expectEqual(t, input, output)
	})
}

func TestService_FinishInvocation(t *testing.T) {
	t.Run("should return an Invocation from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		testBed.ExpectRPC().
			FinishInvocation(ctx, &api.FinishInvocationRequest{
				AuthorizationToken: "auth_token",
				Name:               "invocation_name",
			}).
			Return(&api.FinishInvocationResponse{}, nil)

		if err := service.FinishInvocation(ctx, "invocation_name"); err != nil {
			t.Fatal(err)
		}
	})
}

func TestService_CreateConfiguration(t *testing.T) {
	t.Run("should return a Configuration from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.Configuration{
			ID:           "configuration_id",
			InvocationID: "invocation_id",
			Properties:   map[string]string{"key": "value"},
		}

		testBed.ExpectRPC().
			CreateConfiguration(ctx, &api.CreateConfigurationRequest{
				RequestId:          testUUID,
				AuthorizationToken: "auth_token",
				Parent:             "invocation_name",
				ConfigId:           "configuration_id",
				Configuration:      input.ToResultStoreConfiguration(),
			}).
			Return(input.ToResultStoreConfiguration(), nil)

		output, err := service.CreateConfiguration(ctx, input, "invocation_name")
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_CreateTarget(t *testing.T) {
	t.Run("should return a Target from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.Target{
			ID:         "target_id",
			Properties: map[string]string{"key": "value"},
			StartTime:  may18_1993,
			Status:     resultstore.Passed,
		}

		testBed.ExpectRPC().
			CreateTarget(ctx, &api.CreateTargetRequest{
				RequestId:          testUUID,
				AuthorizationToken: "auth_token",
				Parent:             "invocation_name",
				TargetId:           input.ID,
				Target:             input.ToResultStoreTarget(),
			}).
			Return(input.ToResultStoreTarget(), nil)

		output, err := service.CreateTarget(ctx, input, "invocation_name")
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_UpdateTarget(t *testing.T) {
	t.Run("should return a Target from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.Target{
			ID:           "target_id",
			InvocationID: "invocation_id",
			Properties:   map[string]string{"key": "value"},
			StartTime:    may18_1993,
			Duration:     time.Hour,
			Status:       resultstore.Passed,
		}

		testBed.ExpectRPC().
			UpdateTarget(ctx, &api.UpdateTargetRequest{
				AuthorizationToken: "auth_token",
				Target:             input.ToResultStoreTarget(),
				UpdateMask: &field_mask.FieldMask{
					Paths: []string{"timing.duration", "status_attributes"},
				},
			}).
			Return(input.ToResultStoreTarget(), nil)

		output, err := service.UpdateTarget(ctx, input)
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_FinishTarget(t *testing.T) {
	t.Run("should return a Target from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		testBed.ExpectRPC().
			FinishTarget(ctx, &api.FinishTargetRequest{
				AuthorizationToken: "auth_token",
				Name:               "target_name",
			}).
			Return(&api.FinishTargetResponse{}, nil)

		if err := service.FinishTarget(ctx, "target_name"); err != nil {
			t.Fatal(err)
		}
	})
}

func TestService_CreateConfiguredTarget(t *testing.T) {
	t.Run("should return a ConfiguredTarget from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.ConfiguredTarget{
			InvocationID: "invocation_id",
			TargetID:     "target_id",
			ConfigID:     "configuration_id",
			Properties:   map[string]string{"key": "value"},
			StartTime:    may18_1993,
			Status:       resultstore.Passed,
		}

		testBed.ExpectRPC().
			CreateConfiguredTarget(ctx, &api.CreateConfiguredTargetRequest{
				RequestId:          testUUID,
				AuthorizationToken: "auth_token",
				Parent:             "target_name",
				ConfigId:           "configuration_id",
				ConfiguredTarget:   input.ToResultStoreConfiguredTarget(),
			}).
			Return(input.ToResultStoreConfiguredTarget(), nil)

		output, err := service.CreateConfiguredTarget(ctx, input, "target_name")
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_UpdateConfiguredTarget(t *testing.T) {
	t.Run("should return a ConfiguredTarget from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.ConfiguredTarget{
			ConfigID:   "configuration_id",
			Properties: map[string]string{"key": "value"},
			Status:     resultstore.Passed,
			StartTime:  may18_1993,
			Duration:   time.Hour,
		}

		testBed.ExpectRPC().
			UpdateConfiguredTarget(ctx, &api.UpdateConfiguredTargetRequest{
				AuthorizationToken: "auth_token",
				ConfiguredTarget:   input.ToResultStoreConfiguredTarget(),
				UpdateMask: &field_mask.FieldMask{
					Paths: []string{"timing.duration", "status_attributes"},
				},
			}).
			Return(input.ToResultStoreConfiguredTarget(), nil)

		output, err := service.UpdateConfiguredTarget(ctx, input)
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_FinishConfiguredTarget(t *testing.T) {
	t.Run("should return a ConfiguredTarget from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		testBed.ExpectRPC().
			FinishConfiguredTarget(ctx, &api.FinishConfiguredTargetRequest{
				AuthorizationToken: "auth_token",
				Name:               "configured_target_name",
			}).
			Return(&api.FinishConfiguredTargetResponse{}, nil)

		if err := service.FinishConfiguredTarget(ctx, "configured_target_name"); err != nil {
			t.Fatal(err)
		}
	})
}

func TestService_CreateTestAction(t *testing.T) {
	t.Run("should return an Action from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.TestAction{
			ID:           "test",
			InvocationID: "invocation_id",
			TargetID:     "target_id",
			ConfigID:     "configuration_id",
			TestSuite:    "test_suite",
			TestLogURI:   "http://test.log",
			StartTime:    may18_1993,
			Status:       resultstore.Passed,
		}

		testBed.ExpectRPC().
			CreateAction(ctx, &api.CreateActionRequest{
				RequestId:          testUUID,
				AuthorizationToken: "auth_token",
				Parent:             "configured_target_name",
				ActionId:           input.ID,
				Action:             input.ToResultStoreAction(),
			}).
			Return(input.ToResultStoreAction(), nil)

		output, err := service.CreateTestAction(ctx, input, "configured_target_name")
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}

func TestService_UpdateTestAction(t *testing.T) {
	t.Run("should return an Action from an RPC response", func(t *testing.T) {
		testBed := new(serviceTestBed)
		service, ctx := testBed.Setup(t, "auth_token")
		defer testBed.Teardown()

		input := &resultstore.TestAction{
			ID:           "test",
			InvocationID: "invocation_id",
			TargetID:     "target_id",
			ConfigID:     "configuration_id",
			TestSuite:    "test_suite",
			TestLogURI:   "http://test.log",
			StartTime:    may18_1993,
			Duration:     time.Hour,
			Status:       resultstore.Passed,
		}

		testBed.ExpectRPC().
			UpdateAction(ctx, &api.UpdateActionRequest{
				AuthorizationToken: "auth_token",
				Action:             input.ToResultStoreAction(),
				UpdateMask: &field_mask.FieldMask{
					Paths: []string{"timing.duration", "status_attributes"},
				},
			}).
			Return(input.ToResultStoreAction(), nil)

		output, err := service.UpdateTestAction(ctx, input)
		if err != nil {
			t.Fatal(err)
		}

		expectEqual(t, input, output)
	})
}