package ingestion_processors

import (
	"context"
	"encoding/json"
	"errors"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"

	"go.skia.org/infra/go/httputils"
	"go.skia.org/infra/go/paramtools"
	"go.skia.org/infra/go/testutils"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/golden/go/clstore"
	mock_clstore "go.skia.org/infra/golden/go/clstore/mocks"
	"go.skia.org/infra/golden/go/code_review"
	"go.skia.org/infra/golden/go/code_review/gerrit_crs"
	mock_crs "go.skia.org/infra/golden/go/code_review/mocks"
	ci "go.skia.org/infra/golden/go/continuous_integration"
	mock_cis "go.skia.org/infra/golden/go/continuous_integration/mocks"
	"go.skia.org/infra/golden/go/ingestion"
	ingestion_mocks "go.skia.org/infra/golden/go/ingestion/mocks"
	"go.skia.org/infra/golden/go/jsonio"
	"go.skia.org/infra/golden/go/tjstore"
	mock_tjstore "go.skia.org/infra/golden/go/tjstore/mocks"
	"go.skia.org/infra/golden/go/types"
)

const (
	legacyGoldCtlFile = "testdata/legacy-tryjob-goldctl.json"
	githubGoldCtlFile = "testdata/github-goldctl.json"
)

func TestGerritBuildbucketFactory(t *testing.T) {
	unittest.LargeTest(t) // should use the emulator
	unittest.RequiresFirestoreEmulator(t)

	config := ingestion.Config{
		ExtraParams: map[string]string{
			firestoreProjectIDParam: "should-use-emulator",
			firestoreNamespaceParam: "testing",

			codeReviewSystemsParam: "gerrit,gerrit-internal",
			gerritURLParam:         "https://example-review.googlesource.com",
			gerritInternalURLParam: "https://example-internal-review.googlesource.com",

			continuousIntegrationSystemsParam: "buildbucket",
		},
	}
	ctx := gerrit_crs.TestContext(context.Background())
	p, err := newModularTryjobProcessor(ctx, nil, config, httputils.NewTimeoutClient(), nil)
	require.NoError(t, err)
	require.NotNil(t, p)

	gtp, ok := p.(*goldTryjobProcessor)
	require.True(t, ok)
	assert.Len(t, gtp.reviewSystems, 2)
	assert.Len(t, gtp.cisClients, 1)
	assert.Contains(t, gtp.cisClients, buildbucketCIS)
}

func TestGitHubCirrusBuildbucketFactory(t *testing.T) {
	unittest.LargeTest(t) // should use the emulator
	unittest.RequiresFirestoreEmulator(t)

	config := ingestion.Config{
		ExtraParams: map[string]string{
			firestoreProjectIDParam: "should-use-emulator",
			firestoreNamespaceParam: "testing",

			codeReviewSystemsParam:     "github",
			githubRepoParam:            "google/skia",
			githubCredentialsPathParam: "testdata/fake_token", // this is actually a file on disk.

			continuousIntegrationSystemsParam: "cirrus,buildbucket",
		},
	}

	ctx := gerrit_crs.TestContext(context.Background())
	p, err := newModularTryjobProcessor(ctx, nil, config, httputils.NewTimeoutClient(), nil)
	require.NoError(t, err)
	require.NotNil(t, p)

	gtp, ok := p.(*goldTryjobProcessor)
	require.True(t, ok)
	assert.Len(t, gtp.reviewSystems, 1)
	assert.Len(t, gtp.cisClients, 2)
	assert.Contains(t, gtp.cisClients, cirrusCIS)
	assert.Contains(t, gtp.cisClients, buildbucketCIS)
}

// TestTryJobProcessFreshStartSunnyDay tests the scenario in which we see data uploaded to Gerrit
// for a brand new CL, PS, and TryJob. There are no ignore rules and the known digests don't contain
// gerritDigest.
func TestTryJobProcessFreshStartSunnyDay(t *testing.T) {
	unittest.SmallTest(t)
	mcls := makeEmptyCLStore()
	mtjs := makeEmptyTJStore()
	defer mcls.AssertExpectations(t)
	defer mtjs.AssertExpectations(t)

	mcls.On("PutChangelist", testutils.AnyContext, clWithUpdatedTime(t, gerritCLID, gerritCLDate)).Return(nil).Twice()
	mcls.On("PutPatchset", testutils.AnyContext, makeGerritPatchset()).Return(nil).Once()

	mtjs.On("PutTryJob", testutils.AnyContext, gerritCombinedID, makeGerritBuildbucketTryJob()).Return(nil).Once()
	mtjs.On("PutResults", testutils.AnyContext, gerritCombinedID, legacyGoldCtlFile, makeTryJobResults(), anyTime).Return(nil).Once()

	gtp := goldTryjobProcessor{
		cisClients: makeBuildbucketCIS(),
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:     gerritCRS,
				Client: makeGerritCRS(),
				Store:  mcls,
				// URLTemplate unused here
			},
		},
		tryJobStore: mtjs,
	}

	fsResult, err := ingestion_mocks.MockResultFileLocationFromFile(legacyGoldCtlFile)
	require.NoError(t, err)

	err = gtp.Process(context.Background(), fsResult)
	require.NoError(t, err)
}

// TestTryJobProcessFreshStartGitHub tests the scenario in which we see data uploaded to GitHub for
// a brand new CL, PS, and TryJob. The PS is derived by id, not by order. The uploaded digest
// was not previously seen or triaged on master and is not covered by an ignore rule, so the
// created Patchset object should be marked as having UntriagedDigests.
func TestTryJobProcessFreshStartGitHub(t *testing.T) {
	unittest.SmallTest(t)
	mcls := makeEmptyCLStore()
	mtjs := makeEmptyTJStore()
	// We want to assert that the Process calls each of PutChangelist, PutPatchset, and PutTryJob
	// with the new, correct objects object. Further, it should call PutResults with the
	// appropriate TryJobResults.
	defer mcls.AssertExpectations(t)
	defer mtjs.AssertExpectations(t)

	mcls.On("PutChangelist", testutils.AnyContext, clWithUpdatedTime(t, githubCLID, makeGitHubCirrusTryJob().Updated)).Return(nil)
	mcls.On("PutPatchset", testutils.AnyContext, code_review.Patchset{
		SystemID:     githubPSID,
		ChangelistID: githubCLID,
		Order:        githubPSOrder,
		GitHash:      githubPSID,
	}).Return(nil).Once()

	combinedID := tjstore.CombinedPSID{CL: githubCLID, PS: githubPSID, CRS: "github"}
	mtjs.On("PutTryJob", testutils.AnyContext, combinedID, makeGitHubCirrusTryJob()).Return(nil)
	mtjs.On("PutResults", testutils.AnyContext, combinedID, githubGoldCtlFile, makeGitHubTryJobResults(), anyTime).Return(nil)

	gtp := goldTryjobProcessor{
		cisClients: makeCirrusCIS(),
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:     githubCRS,
				Client: makeGitHubCRS(),
				Store:  mcls,
				// URLTemplate unused here
			},
		},
		tryJobStore: mtjs,
	}

	fsResult, err := ingestion_mocks.MockResultFileLocationFromFile(githubGoldCtlFile)
	require.NoError(t, err)

	err = gtp.Process(context.Background(), fsResult)
	require.NoError(t, err)
}

// TestProcess_MultipleCIS_CorrectlyLooksUpTryJobs processes three results from different CIS
// (and has the CIS return an error to short-circuit the process code) and verifies that the
// two CIS we knew about were correctly contacted and the result with an unknown CIS was ignored.
func TestProcess_MultipleCIS_CorrectlyLooksUpTryJobs(t *testing.T) {
	unittest.SmallTest(t)
	mcls := &mock_clstore.Store{}
	// We can return whatever here, since we plan to error out when the tryjob gets read.
	mcls.On("GetChangelist", testutils.AnyContext, githubCLID).Return(makeChangelist(), nil)
	mcls.On("GetPatchset", testutils.AnyContext, githubCLID, githubPSID).Return(makeGerritPatchsets()[0], nil)

	bbClient := &mock_cis.Client{}
	bbClient.On("GetTryJob", testutils.AnyContext, mock.Anything).Return(ci.TryJob{}, errors.New("buildbucket error")).Once()
	defer bbClient.AssertExpectations(t) // make sure GetTryJob is called exactly once.

	cirrusClient := &mock_cis.Client{}
	cirrusClient.On("GetTryJob", testutils.AnyContext, mock.Anything).Return(ci.TryJob{}, errors.New("cirrus error")).Once()
	defer cirrusClient.AssertExpectations(t) // make sure GetTryJob is called exactly once.

	errorfulCISClients := map[string]ci.Client{
		buildbucketCIS: bbClient,
		cirrusCIS:      cirrusClient,
	}

	gtp := goldTryjobProcessor{
		cisClients: errorfulCISClients,
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:    githubCRS,
				Store: mcls,
				// Client, URLTemplate unused here
			},
		},
		tryJobStore: makeEmptyTJStore(),
	}

	err := gtp.Process(context.Background(), githubIngestionResultFromCIS(t, buildbucketCIS))
	require.Error(t, err)
	assert.Contains(t, err.Error(), "buildbucket error")

	err = gtp.Process(context.Background(), githubIngestionResultFromCIS(t, cirrusCIS))
	require.Error(t, err)
	assert.Contains(t, err.Error(), "cirrus error")

	err = gtp.Process(context.Background(), githubIngestionResultFromCIS(t, "unknown"))
	require.Error(t, err)
	assert.Equal(t, err, ingestion.IgnoreResultsFileErr)
}

func githubIngestionResultFromCIS(t *testing.T, cis string) ingestion.ResultFileLocation {
	// We provide the bare minimum to be a valid result
	gr := jsonio.GoldResults{
		Key: map[string]string{
			types.CorpusField: "arbitrary",
		},
		Results: []*jsonio.Result{
			{
				Key: map[string]string{
					types.PrimaryKeyField: "whatever",
				},
				// arbitrary, yet valid, md5 hash
				Digest: "46eb78c9711cb79197d47f448ba51338",
			},
		},
		// arbitrary, yet valid, sha1 (git) hash
		GitHash:                     "6eb2b22a052a9913fe3b9170fc217e84def40598",
		ChangelistID:                githubCLID,
		PatchsetID:                  githubPSID,
		CodeReviewSystem:            githubCRS,
		TryJobID:                    "whatever",
		ContinuousIntegrationSystem: cis,
	}
	b, err := json.Marshal(gr)
	require.NoError(t, err)

	// These two fields are arbitrary and don't affect the test.
	const name = "does not matter"
	ts := time.Date(2020, time.January, 2, 3, 4, 5, 0, time.UTC)

	return ingestion_mocks.MockResultFileLocationWithContent(name, b, ts)
}

// TestTryJobProcessCLExistsSunnyDay tests that the ingestion works when the CL already exists.
func TestTryJobProcessCLExistsSunnyDay(t *testing.T) {
	unittest.SmallTest(t)
	mcls := &mock_clstore.Store{}
	mtjs := makeEmptyTJStore()
	// We want to assert that the Process calls PutChangelist (with updated time), PutPatchset
	// (with the correct new object), PutTryJob with the new TryJob object and PutResults with
	// the appropriate TryJobResults.
	defer mcls.AssertExpectations(t)
	defer mtjs.AssertExpectations(t)

	mcls.On("GetChangelist", testutils.AnyContext, gerritCLID).Return(makeChangelist(), nil)
	mcls.On("GetPatchsetByOrder", testutils.AnyContext, gerritCLID, gerritPSOrder).Return(code_review.Patchset{}, clstore.ErrNotFound)
	mcls.On("PutPatchset", testutils.AnyContext, makeGerritPatchset()).Return(nil)
	mcls.On("PutChangelist", testutils.AnyContext, clWithUpdatedTime(t, gerritCLID, gerritCLDate)).Return(nil)

	mtjs.On("PutTryJob", testutils.AnyContext, gerritCombinedID, makeGerritBuildbucketTryJob()).Return(nil)
	mtjs.On("PutResults", testutils.AnyContext, gerritCombinedID,
		legacyGoldCtlFile, makeTryJobResults(), anyTime).Return(nil)

	gtp := goldTryjobProcessor{
		cisClients: makeBuildbucketCIS(),
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:     gerritCRS,
				Client: makeGerritCRS(),
				Store:  mcls,
				// URLTemplate unused here
			},
		},
		tryJobStore: mtjs,
	}

	fsResult, err := ingestion_mocks.MockResultFileLocationFromFile(legacyGoldCtlFile)
	require.NoError(t, err)

	err = gtp.Process(context.Background(), fsResult)
	require.NoError(t, err)
}

// TestTryJobProcessCLExistsPreviouslyAbandoned tests that the ingestion works when the
// CL already exists, but was marked abandoned at some point (and presumably was re-opened).
func TestTryJobProcessCLExistsPreviouslyAbandoned(t *testing.T) {
	unittest.SmallTest(t)
	mcls := &mock_clstore.Store{}
	mtjs := makeEmptyTJStore()
	// We want to assert that the Process calls PutChangelist (with updated time and no longer
	// abandoned), PutPatchset with the new object, PutTryJob with the new TryJob object,
	// and PutResults with the appropriate TryJobResults.
	defer mcls.AssertExpectations(t)
	defer mtjs.AssertExpectations(t)

	cl := makeChangelist()
	cl.Status = code_review.Abandoned
	mcls.On("GetChangelist", testutils.AnyContext, gerritCLID).Return(cl, nil)
	mcls.On("GetPatchsetByOrder", testutils.AnyContext, gerritCLID, gerritPSOrder).Return(code_review.Patchset{}, clstore.ErrNotFound)
	mcls.On("PutPatchset", testutils.AnyContext, makeGerritPatchset()).Return(nil)
	mcls.On("PutChangelist", testutils.AnyContext, clWithUpdatedTime(t, gerritCLID, gerritCLDate)).Return(nil)

	mtjs.On("PutTryJob", testutils.AnyContext, gerritCombinedID, makeGerritBuildbucketTryJob()).Return(nil)
	mtjs.On("PutResults", testutils.AnyContext, gerritCombinedID,
		legacyGoldCtlFile, makeTryJobResults(), anyTime).Return(nil)

	gtp := goldTryjobProcessor{
		cisClients: makeBuildbucketCIS(),
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:     gerritCRS,
				Client: makeGerritCRS(),
				Store:  mcls,
				// URLTemplate unused here
			},
		},
		tryJobStore: mtjs,
	}

	fsResult, err := ingestion_mocks.MockResultFileLocationFromFile(legacyGoldCtlFile)
	require.NoError(t, err)

	err = gtp.Process(context.Background(), fsResult)
	require.NoError(t, err)
}

// TestTryJobProcessPSExistsSunnyDay tests that the ingestion works when the
// CL and the PS already exists.
func TestTryJobProcessPSExistsSunnyDay(t *testing.T) {
	unittest.SmallTest(t)
	mcls := &mock_clstore.Store{}
	mtjs := makeEmptyTJStore()
	// We want to assert that the Process calls PutChangelist and PutPatchset (with updated times),
	// PutTryJob with the new TryJob object, and PutResults with the appropriate TryJobResults.
	defer mcls.AssertExpectations(t)
	defer mtjs.AssertExpectations(t)

	mcls.On("GetChangelist", testutils.AnyContext, gerritCLID).Return(makeChangelist(), nil)
	mcls.On("GetPatchsetByOrder", testutils.AnyContext, gerritCLID, gerritPSOrder).Return(makeGerritPatchset(), nil)
	mcls.On("PutChangelist", testutils.AnyContext, clWithUpdatedTime(t, gerritCLID, gerritCLDate)).Return(nil)
	mcls.On("PutPatchset", testutils.AnyContext, makeGerritPatchset()).Return(nil)

	mtjs.On("PutTryJob", testutils.AnyContext, gerritCombinedID, makeGerritBuildbucketTryJob()).Return(nil)
	mtjs.On("PutResults", testutils.AnyContext, gerritCombinedID,
		legacyGoldCtlFile, makeTryJobResults(), anyTime).Return(nil)

	gtp := goldTryjobProcessor{
		cisClients: makeBuildbucketCIS(),
		reviewSystems: []clstore.ReviewSystem{
			{
				ID:    gerritCRS,
				Store: mcls,
				// Client, URLTemplate unused here
			},
		},
		tryJobStore: mtjs,
	}

	fsResult, err := ingestion_mocks.MockResultFileLocationFromFile(legacyGoldCtlFile)
	require.NoError(t, err)

	err = gtp.Process(context.Background(), fsResult)
	require.NoError(t, err)
}

func makeEmptyCLStore() *mock_clstore.Store {
	mcls := &mock_clstore.Store{}
	mcls.On("GetChangelist", testutils.AnyContext, mock.Anything).Return(code_review.Changelist{}, clstore.ErrNotFound).Maybe()
	mcls.On("GetPatchsetByOrder", testutils.AnyContext, mock.Anything, mock.Anything).Return(code_review.Patchset{}, clstore.ErrNotFound).Maybe()
	mcls.On("GetPatchset", testutils.AnyContext, mock.Anything, mock.Anything).Return(code_review.Patchset{}, clstore.ErrNotFound).Maybe()

	return mcls
}

func makeEmptyTJStore() *mock_tjstore.Store {
	mtjs := &mock_tjstore.Store{}
	mtjs.On("GetTryJob", testutils.AnyContext, mock.Anything, mock.Anything).Return(ci.TryJob{}, tjstore.ErrNotFound).Maybe()
	return mtjs
}

// Below is the gerrit data that belongs to legacyGoldCtlFile. It doesn't need to be a super
// complex example because we have tests that test parseDMResults directly.
const (
	gerritCLID    = "1762193"
	gerritPSID    = "e1681c90cf6a4c3b6be2bc4b4cea59849c16a438"
	gerritPSOrder = 2
	gerritTJID    = "8904604368086838672"
)

var (
	gerritCombinedID = tjstore.CombinedPSID{CL: gerritCLID, PS: gerritPSID, CRS: gerritCRS}

	gerritCLDate = time.Date(2019, time.August, 19, 18, 17, 16, 0, time.UTC)

	anyTime = mock.MatchedBy(func(time.Time) bool { return true })
)

// These are functions to avoid mutations causing issues for future tests/checks
func makeTryJobResults() []tjstore.TryJobResult {
	return []tjstore.TryJobResult{
		{
			TryjobID: gerritTJID,
			System:   buildbucketCIS,
			Digest:   "690f72c0b56ae014c8ac66e7f25c0779",
			GroupParams: paramtools.Params{
				"device_id":     "0x1cb3",
				"device_string": "None",
				"msaa":          "True",
				"vendor_id":     "0x10de",
				"vendor_string": "None",
			},
			ResultParams: paramtools.Params{
				"name":        "Pixel_CanvasDisplayLinearRGBUnaccelerated2DGPUCompositing",
				"source_type": "chrome-gpu",
			},
			Options: paramtools.Params{
				"ext": "png",
			},
		},
	}
}

func makeChangelist() code_review.Changelist {
	return code_review.Changelist{
		SystemID: "1762193",
		Owner:    "test@example.com",
		Status:   code_review.Open,
		Subject:  "initial commit",
		Updated:  gerritCLDate,
	}
}

// clWithUpdatedTime returns a matcher that will assert the CL has properly had its Updated field
// updated.
func clWithUpdatedTime(t *testing.T, clID string, originalDate time.Time) interface{} {
	return mock.MatchedBy(func(cl code_review.Changelist) bool {
		assert.Equal(t, clID, cl.SystemID)
		assert.Equal(t, code_review.Open, cl.Status)
		// If the CL is being stored with the sentinel value, we can ignore the time check.
		if !cl.Updated.IsZero() {
			// Make sure the time is updated to be later than the original one (which was in November
			// or August, depending on the testcase). Since this test was authored after 1 Dec 2019 and
			// the Updated is set to time.Now(), we can just check that we are after then.
			assert.True(t, cl.Updated.After(originalDate))
		}

		// assert messages are easier to debug than "not matched" errors, so say that we matched,
		// but know the test will fail if any of the above asserts fail.
		return true
	})
}

func makeGerritPatchsets() []code_review.Patchset {
	return []code_review.Patchset{
		{
			SystemID:     "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1",
			ChangelistID: "1762193",
			Order:        1,
			GitHash:      "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1",
		},
		{
			SystemID:     gerritPSID,
			ChangelistID: "1762193",
			Order:        gerritPSOrder,
			GitHash:      gerritPSID,
		},
		{
			SystemID:     "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2",
			ChangelistID: "1762193",
			Order:        3,
			GitHash:      "b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2",
		},
	}
}

func makeGerritPatchset() code_review.Patchset {
	ps := makeGerritPatchsets()[1]
	return ps
}

func makeGerritBuildbucketTryJob() ci.TryJob {
	return ci.TryJob{
		SystemID:    gerritTJID,
		System:      buildbucketCIS,
		DisplayName: "my-task",
		Updated:     time.Date(2019, time.August, 19, 18, 20, 10, 0, time.UTC),
	}
}

func makeBuildbucketCIS() map[string]ci.Client {
	mcis := &mock_cis.Client{}
	mcis.On("GetTryJob", testutils.AnyContext, gerritTJID).Return(makeGerritBuildbucketTryJob(), nil)
	return map[string]ci.Client{
		buildbucketCIS: mcis,
	}
}

func makeGerritCRS() *mock_crs.Client {
	mcrs := &mock_crs.Client{}
	mcrs.On("GetChangelist", testutils.AnyContext, gerritCLID).Return(makeChangelist(), nil)
	mcrs.On("GetPatchset", testutils.AnyContext, gerritCLID, mock.Anything, mock.Anything).Return(makeGerritPatchsets()[1], nil)
	return mcrs
}

// Below is the gerrit data that belongs to githubGoldCtlFile, which is based on real data.
const (
	githubCLID    = "44474"
	githubPSOrder = 1
	githubPSID    = "fe1cad6c1a5d6dc7cea47f09efdd49f197a7f017"
	githubTJID    = "5489081055707136"
)

func makeGitHubCirrusTryJob() ci.TryJob {
	return ci.TryJob{
		SystemID:    githubTJID,
		System:      cirrusCIS,
		DisplayName: "my-github-task",
		Updated:     time.Date(2019, time.November, 19, 18, 20, 10, 0, time.UTC),
	}
}

func makeGitHubTryJobResults() []tjstore.TryJobResult {
	return []tjstore.TryJobResult{
		{
			TryjobID: githubTJID,
			System:   cirrusCIS,
			Digest:   "87599f3dec5b56dc110f1b63dc747182",
			GroupParams: paramtools.Params{
				"Platform": "windows",
			},
			ResultParams: paramtools.Params{
				"name":        "cupertino.date_picker_test.datetime.initial",
				"source_type": "flutter",
			},
			Options: paramtools.Params{
				"ext": "png",
			},
		},
		{
			TryjobID: githubTJID,
			System:   cirrusCIS,
			Digest:   "7d04fc1ef547a8e092495dab4294b4cd",
			GroupParams: paramtools.Params{
				"Platform": "windows",
			},
			ResultParams: paramtools.Params{
				"name":        "cupertino.date_picker_test.datetime.drag",
				"source_type": "flutter",
			},
			Options: paramtools.Params{
				"ext": "png",
			},
		},
	}
}

func makeCirrusCIS() map[string]ci.Client {
	mcis := &mock_cis.Client{}
	mcis.On("GetTryJob", testutils.AnyContext, githubTJID).Return(makeGitHubCirrusTryJob(), nil)
	return map[string]ci.Client{
		cirrusCIS: mcis,
	}
}

func makeGitHubCRS() *mock_crs.Client {
	cl := code_review.Changelist{
		SystemID: githubCLID,
		Owner:    "test@example.com",
		Status:   code_review.Open,
		Subject:  "initial commit",
		Updated:  time.Date(2019, time.November, 19, 18, 17, 16, 0, time.UTC),
	}

	ps := code_review.Patchset{
		SystemID:     "fe1cad6c1a5d6dc7cea47f09efdd49f197a7f017",
		ChangelistID: githubCLID,
		Order:        githubPSOrder,
		GitHash:      "fe1cad6c1a5d6dc7cea47f09efdd49f197a7f017",
	}
	mcrs := &mock_crs.Client{}
	mcrs.On("GetChangelist", testutils.AnyContext, githubCLID).Return(cl, nil)
	mcrs.On("GetPatchset", testutils.AnyContext, githubCLID, mock.Anything, mock.Anything).Return(ps, nil)
	return mcrs
}