package rpc

import (
	"context"
	fmt "fmt"
	"sort"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"go.skia.org/infra/autoroll/go/config"
	"go.skia.org/infra/autoroll/go/config_vars"
	"go.skia.org/infra/autoroll/go/manual"
	manual_mocks "go.skia.org/infra/autoroll/go/manual/mocks"
	"go.skia.org/infra/autoroll/go/modes"
	modes_mocks "go.skia.org/infra/autoroll/go/modes/mocks"
	"go.skia.org/infra/autoroll/go/revision"
	"go.skia.org/infra/autoroll/go/status"
	status_mocks "go.skia.org/infra/autoroll/go/status/mocks"
	"go.skia.org/infra/autoroll/go/strategy"
	strategy_mocks "go.skia.org/infra/autoroll/go/strategy/mocks"
	unthrottle_mocks "go.skia.org/infra/autoroll/go/unthrottle/mocks"
	"go.skia.org/infra/go/allowed"
	"go.skia.org/infra/go/autoroll"
	"go.skia.org/infra/go/deepequal/assertdeep"
	"go.skia.org/infra/go/firestore"
	"go.skia.org/infra/go/git"
	"go.skia.org/infra/go/testutils/unittest"
	"google.golang.org/protobuf/types/known/timestamppb"
)

const (
	// Fake user emails.
	viewer = "viewer@google.com"
	editor = "editor@google.com"
	admin  = "admin@google.com"
)

var (
	// Allow fake users.
	viewers = allowed.NewAllowedFromList([]string{viewer, editor, admin})
	editors = allowed.NewAllowedFromList([]string{editor, admin})
	admins  = allowed.NewAllowedFromList([]string{admin})

	// Current at time of writing.
	currentTime = time.Unix(1598467386, 0).UTC()
)

func defaultBranchTmpl(t *testing.T) *config_vars.Template {
	tmpl, err := config_vars.NewTemplate(git.DefaultBranch)
	require.NoError(t, err)
	return tmpl
}

func makeFakeModeChange(cfg *config.Config) *modes.ModeChange {
	return &modes.ModeChange{
		Message: "dry run!",
		// We can't use the first enum value, or assertdeep.Copy will fail.
		Mode:   modes.ModeDryRun,
		Roller: cfg.RollerName,
		Time:   timeNowFunc(),
		User:   "me@google.com",
	}
}

func makeFakeStrategyChange(cfg *config.Config) *strategy.StrategyChange {
	return &strategy.StrategyChange{
		Message: "set strategy",
		// We can't use the first enum value, or assertdeep.Copy will fail.
		Strategy: strategy.ROLL_STRATEGY_N_BATCH,
		Roller:   cfg.RollerName,
		Time:     timeNowFunc(),
		User:     "you@google.com",
	}
}

func makeFakeManualRollRequest(cfg *config.Config) *manual.ManualRollRequest {
	return &manual.ManualRollRequest{
		Id:                "manual123",
		DbModified:        timeNowFunc(),
		Requester:         "me@google.com",
		Result:            manual.RESULT_UNKNOWN,
		ResultDetails:     "no results yet",
		Revision:          "fake-rev",
		RollerName:        cfg.RollerName,
		Status:            manual.STATUS_STARTED,
		Timestamp:         timeNowFunc(),
		Url:               "https://fake-manual-roll",
		DryRun:            true,
		NoEmail:           true,
		NoResolveRevision: true,
	}
}

func makeFakeRoll() *autoroll.AutoRollIssue {
	return &autoroll.AutoRollIssue{
		Closed:         false,
		IsDryRun:       false,
		DryRunFinished: false,
		DryRunSuccess:  false,
		CqFinished:     false,
		CqSuccess:      false,
		Issue:          12345,
		Result:         autoroll.ROLL_RESULT_DRY_RUN_IN_PROGRESS,
		RollingFrom:    "abc123",
		RollingTo:      "def456",
		Subject:        "Roll dep from abc123 to def456",
		TryResults: []*autoroll.TryResult{
			{
				Builder:  "test-bot",
				Category: "cq",
				Created:  timeNowFunc(),
				Result:   autoroll.TRYBOT_RESULT_SUCCESS,
				Status:   autoroll.TRYBOT_STATUS_COMPLETED,
				Url:      "https://fake-try.result",
			},
			{
				Builder:  "perf-bot",
				Category: "cq",
				Created:  timeNowFunc(),
				Result:   autoroll.TRYBOT_RESULT_CANCELED,
				Status:   autoroll.TRYBOT_STATUS_STARTED,
				Url:      "https://fake-try.result",
			},
		},
	}
}

func makeFakeStatus(cfg *config.Config) *status.AutoRollStatus {
	current := makeFakeRoll()
	last := makeFakeRoll()
	return &status.AutoRollStatus{
		AutoRollMiniStatus: status.AutoRollMiniStatus{
			Mode:                modes.ModeRunning,
			CurrentRollRev:      "def456",
			LastRollRev:         "abc123",
			NumFailedRolls:      1,
			NumNotRolledCommits: 2,
		},
		Status:         "rolling",
		ChildHead:      "def456",
		ChildName:      cfg.ChildDisplayName,
		FullHistoryUrl: "http://fake",
		IssueUrlBase:   "http://fake2",
		NotRolledRevisions: []*revision.Revision{
			{
				Id:          "999abc",
				Description: "Commit 999abc",
				Display:     "9",
				Timestamp:   timeNowFunc(),
				URL:         "https://rev/999abc",
			},
			{
				Id:          "def456",
				Description: "Commit def456",
				Display:     "d",
				Timestamp:   timeNowFunc(),
				URL:         "https://rev/def456",
			},
		},
		ParentName:      cfg.ParentDisplayName,
		CurrentRoll:     current,
		LastRoll:        last,
		Recent:          []*autoroll.AutoRollIssue{current, last},
		ValidModes:      modes.ValidModes,
		ValidStrategies: cfg.ValidStrategies(),
		Error:           "no error",
		ThrottledUntil:  timeNowFunc().Unix(),
	}
}

func makeRoller(ctx context.Context, t *testing.T, name string, mdb *manual_mocks.DB) *AutoRoller {
	cfg := &config.Config{
		ChildDisplayName:  name + "_child",
		ParentDisplayName: name + "_parent",
		ParentWaterfall:   "https://parent",
		RollerName:        name,
		RepoManager: &config.Config_ParentChildRepoManager{
			ParentChildRepoManager: &config.ParentChildRepoManagerConfig{
				Child: &config.ParentChildRepoManagerConfig_GitilesChild{
					GitilesChild: &config.GitilesChildConfig{
						Gitiles: &config.GitilesConfig{
							Branch:  git.DefaultBranch,
							RepoUrl: "https://fake.child",
						},
					},
				},
				Parent: &config.ParentChildRepoManagerConfig_GitilesParent{
					GitilesParent: &config.GitilesParentConfig{
						Gitiles: &config.GitilesConfig{
							Branch:  git.DefaultBranch,
							RepoUrl: "https://fake.parent",
						},
						Dep: &config.DependencyConfig{
							Primary: &config.VersionFileConfig{
								Id: "https://fake.child",
							},
						},
						Gerrit: &config.GerritConfig{},
					},
				},
			},
		},
		SupportsManualRolls: true,
		TimeWindow:          "24h",
	}
	currentStatus := makeFakeStatus(cfg)
	statusDB := &status_mocks.DB{}
	statusDB.On("Get", ctx, name).Return(currentStatus, nil)
	statusCache, err := status.NewCache(ctx, statusDB, name)
	require.NoError(t, err)

	modeHistory := &modes_mocks.ModeHistory{}
	modeHistory.On("CurrentMode").Return(makeFakeModeChange(cfg))
	strategyHistory := &strategy_mocks.StrategyHistory{}
	strategyHistory.On("CurrentStrategy").Return(makeFakeStrategyChange(cfg))

	manualReq := makeFakeManualRollRequest(cfg)
	mdb.On("GetRecent", cfg.RollerName, 2 /* number of not-rolled revs in fake status */).Return([]*manual.ManualRollRequest{manualReq}, nil)

	return &AutoRoller{
		Cfg:      cfg,
		Mode:     modeHistory,
		Status:   statusCache,
		Strategy: strategyHistory,
	}
}

func setup(t *testing.T) (context.Context, map[string]*AutoRoller, *autoRollServerImpl) {
	timeNowFunc = func() time.Time {
		return currentTime
	}
	ctx := context.Background()
	mdb := &manual_mocks.DB{}
	r1 := makeRoller(ctx, t, "roller1", mdb)
	r2 := makeRoller(ctx, t, "roller2", mdb)
	rollers := map[string]*AutoRoller{
		r1.Cfg.RollerName: r1,
		r2.Cfg.RollerName: r2,
	}
	srv := newAutoRollServerImpl(rollers, mdb, &unthrottle_mocks.Throttle{}, viewers, editors, admins)
	return ctx, rollers, srv
}

func TestGetRollers(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	req := &GetRollersRequest{}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.GetRollers(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized viewer")
	mockUser = "no-access@google.com"
	res, err = srv.GetRollers(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"no-access@google.com\" is not an authorized viewer")

	// Check results.
	mockUser = viewer
	res, err = srv.GetRollers(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, res)
	expectRollers := make([]*AutoRollMiniStatus, 0, len(rollers))
	for _, roller := range rollers {
		status := makeFakeStatus(roller.Cfg)
		ms, err := convertMiniStatus(&status.AutoRollMiniStatus, roller.Cfg.RollerName, roller.Mode.CurrentMode().Mode, roller.Cfg.ChildDisplayName, roller.Cfg.ParentDisplayName)
		require.NoError(t, err)
		expectRollers = append(expectRollers, ms)
	}
	sort.Sort(autoRollMiniStatusSlice(expectRollers))
	assertdeep.Equal(t, &GetRollersResponse{
		Rollers: expectRollers,
	}, res)
}

func TestGetMiniStatus(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &GetMiniStatusRequest{
		RollerId: "this roller doesn't exist",
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.GetMiniStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized viewer")
	mockUser = "no-access@google.com"
	res, err = srv.GetMiniStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"no-access@google.com\" is not an authorized viewer")

	// Check error for unknown roller.
	mockUser = viewer
	res, err = srv.GetMiniStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	req.RollerId = roller.Cfg.RollerName
	res, err = srv.GetMiniStatus(ctx, req)
	require.NoError(t, err)
	mode, err := convertMode(roller.Mode.CurrentMode().Mode)
	require.NoError(t, err)
	assertdeep.Equal(t, &GetMiniStatusResponse{
		Status: &AutoRollMiniStatus{
			ChildName:      roller.Cfg.ChildDisplayName,
			Mode:           mode,
			ParentName:     roller.Cfg.ParentDisplayName,
			RollerId:       roller.Cfg.RollerName,
			CurrentRollRev: "def456",
			LastRollRev:    "abc123",
			NumFailed:      1,
			NumBehind:      2,
		},
	}, res)
}

func TestGetStatus(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &GetStatusRequest{
		RollerId: "this roller doesn't exist",
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.GetStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized viewer")
	mockUser = "no-access@google.com"
	res, err = srv.GetStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"no-access@google.com\" is not an authorized viewer")

	// Check error for unknown roller.
	mockUser = viewer
	res, err = srv.GetStatus(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	req.RollerId = roller.Cfg.RollerName
	res, err = srv.GetStatus(ctx, req)
	require.NoError(t, err)
	st := makeFakeStatus(roller.Cfg)
	manualReqs, err := srv.manualRollDB.GetRecent(roller.Cfg.RollerName, len(st.NotRolledRevisions))
	expect, err := convertStatus(st, roller.Cfg, roller.Mode.CurrentMode(), roller.Strategy.CurrentStrategy(), manualReqs)
	require.NoError(t, err)
	assertdeep.Equal(t, &GetStatusResponse{
		Status: expect,
	}, res)
}

func TestSetMode(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &SetModeRequest{
		Message:  "new mode",
		Mode:     Mode_DRY_RUN,
		RollerId: "this roller doesn't exist",
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.SetMode(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized editor")
	mockUser = viewer
	res, err = srv.SetMode(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"viewer@google.com\" is not an authorized editor")

	// Check error for unknown roller.
	mockUser = editor
	res, err = srv.SetMode(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	roller.Mode.(*modes_mocks.ModeHistory).On("Add", ctx, modes.ModeDryRun, editor, req.Message).Return(nil)
	req.RollerId = roller.Cfg.RollerName
	res, err = srv.SetMode(ctx, req)
	require.NoError(t, err)
	st := makeFakeStatus(roller.Cfg)
	manualReqs, err := srv.manualRollDB.GetRecent(roller.Cfg.RollerName, len(st.NotRolledRevisions))
	expect, err := convertStatus(st, roller.Cfg, roller.Mode.CurrentMode(), roller.Strategy.CurrentStrategy(), manualReqs)
	require.NoError(t, err)
	assertdeep.Equal(t, &SetModeResponse{
		Status: expect,
	}, res)
}

func TestSetStrategy(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &SetStrategyRequest{
		Message:  "new strategy",
		RollerId: "this roller doesn't exist",
		Strategy: Strategy_SINGLE,
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.SetStrategy(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized editor")
	mockUser = viewer
	res, err = srv.SetStrategy(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"viewer@google.com\" is not an authorized editor")

	// Check error for unknown roller.
	mockUser = editor
	res, err = srv.SetStrategy(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	roller.Strategy.(*strategy_mocks.StrategyHistory).On("Add", ctx, strategy.ROLL_STRATEGY_SINGLE, editor, req.Message).Return(nil)
	req.RollerId = roller.Cfg.RollerName
	res, err = srv.SetStrategy(ctx, req)
	require.NoError(t, err)
	st := makeFakeStatus(roller.Cfg)
	manualReqs, err := srv.manualRollDB.GetRecent(roller.Cfg.RollerName, len(st.NotRolledRevisions))
	expect, err := convertStatus(st, roller.Cfg, roller.Mode.CurrentMode(), roller.Strategy.CurrentStrategy(), manualReqs)
	require.NoError(t, err)
	assertdeep.Equal(t, &SetStrategyResponse{
		Status: expect,
	}, res)
}

func TestCreateManualRoll(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &CreateManualRollRequest{
		RollerId: "this roller doesn't exist",
		Revision: "abc123",
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.CreateManualRoll(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized editor")
	mockUser = viewer
	res, err = srv.CreateManualRoll(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"viewer@google.com\" is not an authorized editor")

	// Check error for unknown roller.
	mockUser = editor
	res, err = srv.CreateManualRoll(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	req.RollerId = roller.Cfg.RollerName
	manualReq := &manual.ManualRollRequest{
		RollerName: req.RollerId,
		Revision:   req.Revision,
		Requester:  mockUser,
		Status:     manual.STATUS_PENDING,
		Timestamp:  firestore.FixTimestamp(timeNowFunc()),
	}
	srv.manualRollDB.(*manual_mocks.DB).On("Put", manualReq).Return(nil)
	res, err = srv.CreateManualRoll(ctx, req)
	require.NoError(t, err)
	expect, err := convertManualRollRequest(manualReq)
	require.NoError(t, err)
	assertdeep.Equal(t, &CreateManualRollResponse{
		Roll: expect,
	}, res)
}

func TestUnthrottle(t *testing.T) {
	unittest.SmallTest(t)

	// Setup, mocks.
	ctx, rollers, srv := setup(t)
	roller := rollers["roller1"]
	req := &UnthrottleRequest{
		RollerId: "this roller doesn't exist",
	}

	// Check authorization.
	mockUser := ""
	srv.MockGetUserForTesting(func(ctx context.Context) string {
		return mockUser
	})
	res, err := srv.Unthrottle(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"\" is not an authorized editor")
	mockUser = viewer
	res, err = srv.Unthrottle(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error permission_denied: \"viewer@google.com\" is not an authorized editor")

	// Check error for unknown roller.
	mockUser = editor
	res, err = srv.Unthrottle(ctx, req)
	require.Nil(t, res)
	require.EqualError(t, err, "twirp error not_found: Unknown roller")

	// Check results.
	req.RollerId = roller.Cfg.RollerName
	srv.throttle.(*unthrottle_mocks.Throttle).On("Unthrottle", ctx, req.RollerId).Return(nil)
	res, err = srv.Unthrottle(ctx, req)
	require.NoError(t, err)
	assertdeep.Equal(t, &UnthrottleResponse{}, res)
}

func TestConvertMiniStatus(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	r := rollers["roller1"]
	st := r.Status.Get()
	mode, err := convertMode(r.Mode.CurrentMode().Mode)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertMiniStatus(&st.AutoRollMiniStatus, r.Cfg.RollerName, r.Mode.CurrentMode().Mode, r.Cfg.ChildDisplayName, r.Cfg.ParentDisplayName)
	require.NoError(t, err)
	assertdeep.Copy(t, &AutoRollMiniStatus{
		RollerId:       r.Cfg.RollerName,
		Mode:           mode,
		CurrentRollRev: st.CurrentRollRev,
		LastRollRev:    st.LastRollRev,
		ChildName:      st.ChildName,
		ParentName:     st.ParentName,
		NumFailed:      int32(st.NumFailedRolls),
		NumBehind:      int32(st.NumNotRolledCommits),
	}, actual)
}

func TestConvertRollCL(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	r := rollers["roller1"]
	st := r.Status.Get()
	roll := st.LastRoll
	res, err := convertRollCLResult(roll.Result)
	require.NoError(t, err)
	tjs, err := convertTryJobs(roll.TryResults)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertRollCL(roll)
	require.NoError(t, err)
	assertdeep.Copy(t, &AutoRollCL{
		Id:          fmt.Sprintf("%d", roll.Issue),
		Result:      res,
		Subject:     roll.Subject,
		RollingTo:   roll.RollingTo,
		RollingFrom: roll.RollingFrom,
		Created:     timestamppb.New(roll.Created),
		Modified:    timestamppb.New(roll.Modified),
		TryJobs:     tjs,
	}, actual)
}

func TestConvertTryJob(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	tr := rollers["roller1"].Status.Get().LastRoll.TryResults[0]
	res, err := convertTryJobResult(tr.Result)
	require.NoError(t, err)
	st, err := convertTryJobStatus(tr.Status)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertTryJob(tr)
	require.NoError(t, err)
	assertdeep.Copy(t, &TryJob{
		Name:     tr.Builder,
		Status:   st,
		Result:   res,
		Url:      tr.Url,
		Category: tr.Category,
	}, actual)
}

func TestConvertModeChange(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	m := rollers["roller1"].Mode.CurrentMode()
	mode, err := convertMode(m.Mode)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertModeChange(m)
	require.NoError(t, err)
	assertdeep.Copy(t, &ModeChange{
		Message:  m.Message,
		Mode:     mode,
		RollerId: m.Roller,
		Time:     timestamppb.New(m.Time),
		User:     m.User,
	}, actual)
}

func TestConvertStrategyChange(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	s := rollers["roller1"].Strategy.CurrentStrategy()
	strat, err := convertStrategy(s.Strategy)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertStrategyChange(s)
	require.NoError(t, err)
	assertdeep.Copy(t, &StrategyChange{
		Message:  s.Message,
		RollerId: s.Roller,
		Strategy: strat,
		Time:     timestamppb.New(s.Time),
		User:     s.User,
	}, actual)
}

func TestConvertRevision(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	rev := rollers["roller1"].Status.Get().NotRolledRevisions[0]

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	assertdeep.Copy(t, &Revision{
		Description: rev.Description,
		Display:     rev.Display,
		Id:          rev.Id,
		Time:        timestamppb.New(rev.Timestamp),
		Url:         rev.URL,
	}, convertRevision(rev))
}

func TestConvertConfig(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, _ := setup(t)
	cfg := rollers["roller1"].Cfg

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	assertdeep.Copy(t, &AutoRollConfig{
		ParentWaterfall:     cfg.ParentWaterfall,
		RollerId:            cfg.RollerName,
		SupportsManualRolls: cfg.SupportsManualRolls,
		TimeWindow:          cfg.TimeWindow,
	}, convertConfig(cfg))
}

func TestConvertManualRollRequest(t *testing.T) {
	unittest.SmallTest(t)

	req := &manual.ManualRollRequest{
		Id:                "999",
		RollerName:        "roller1",
		Revision:          "abc123",
		Requester:         editor,
		Result:            manual.RESULT_SUCCESS,
		Status:            manual.STATUS_COMPLETE,
		Timestamp:         firestore.FixTimestamp(timeNowFunc()),
		Url:               "https://999",
		DryRun:            true,
		NoEmail:           true,
		NoResolveRevision: true,
	}

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertManualRollRequest(req)
	require.NoError(t, err)
	result, err := convertManualRollResult(req.Result)
	require.NoError(t, err)
	status, err := convertManualRollStatus(req.Status)
	require.NoError(t, err)
	assertdeep.Copy(t, &ManualRoll{
		Id:                req.Id,
		RollerId:          req.RollerName,
		Revision:          req.Revision,
		Requester:         req.Requester,
		Result:            result,
		Status:            status,
		Timestamp:         timestamppb.New(req.Timestamp),
		Url:               req.Url,
		DryRun:            true,
		NoEmail:           true,
		NoResolveRevision: true,
	}, actual)
}

func TestConvertStatus(t *testing.T) {
	unittest.SmallTest(t)

	_, rollers, srv := setup(t)
	r := rollers["roller1"]
	cfg := r.Cfg
	st := r.Status.Get()
	mode, err := convertModeChange(r.Mode.CurrentMode())
	require.NoError(t, err)
	strat, err := convertStrategyChange(r.Strategy.CurrentStrategy())
	require.NoError(t, err)
	manualReqs, err := srv.manualRollDB.GetRecent(cfg.RollerName, len(st.NotRolledRevisions))
	require.NoError(t, err)
	ms, err := convertMiniStatus(&st.AutoRollMiniStatus, cfg.RollerName, r.Mode.CurrentMode().Mode, cfg.ChildDisplayName, cfg.ParentDisplayName)
	require.NoError(t, err)
	currentRoll, err := convertRollCL(st.CurrentRoll)
	require.NoError(t, err)
	lastRoll, err := convertRollCL(st.LastRoll)
	require.NoError(t, err)
	recentRolls, err := convertRollCLs(st.Recent)
	require.NoError(t, err)

	// Use Copy to ensure that the test checks all of the fields. Note that it
	// only checks top-level fields and does not dig into member structs.
	actual, err := convertStatus(st, cfg, r.Mode.CurrentMode(), r.Strategy.CurrentStrategy(), manualReqs)
	require.NoError(t, err)
	mreqs, err := convertManualRollRequests(manualReqs)
	require.NoError(t, err)
	assertdeep.Copy(t, &AutoRollStatus{
		MiniStatus:         ms,
		Status:             st.Status,
		Config:             convertConfig(cfg),
		FullHistoryUrl:     st.FullHistoryUrl,
		IssueUrlBase:       st.IssueUrlBase,
		Mode:               mode,
		Strategy:           strat,
		NotRolledRevisions: convertRevisions(st.NotRolledRevisions),
		CurrentRoll:        currentRoll,
		LastRoll:           lastRoll,
		RecentRolls:        recentRolls,
		ManualRolls:        mreqs,
		Error:              st.Error,
		ThrottledUntil:     timestamppb.New(time.Unix(st.ThrottledUntil, 0)),
	}, actual)
}