cmd/cl-util/gerrit_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 main

import (
	"context"
	"fmt"
	"testing"

	"github.com/golang/mock/gomock"
	"github.com/golang/protobuf/ptypes/empty"
	"github.com/google/go-cmp/cmp"
	gerritpb "go.chromium.org/luci/common/proto/gerrit"
)

func TestCreateChange(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project  string
		subject  string
		commit   string
		expected *gerritpb.ChangeInfo
	}{
		{
			project:  "test-project",
			subject:  "dummy change",
			commit:   "foobar",
			expected: &gerritpb.ChangeInfo{Number: int64(123456)},
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.CreateChangeRequest{
			Project:    test.project,
			Ref:        "refs/heads/master",
			Subject:    test.subject,
			BaseCommit: test.commit,
		}
		// Client returns a successful ChangeInfo response.
		resp := gerritpb.ChangeInfo{Number: int64(123456)}
		mockGerritClient.EXPECT().CreateChange(gomock.Any(), &req).Return(&resp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		changeInfo, err := mockGerritClientWrapper.createChange(ctx, test.subject, test.commit)
		if err != nil {
			t.Fatalf("got unexpected err: %v", err)
		}
		if diff := cmp.Diff(test.expected, changeInfo); diff != "" {
			t.Fatalf("different (-want +got):\n%s", diff)
		}
	}
}

func TestFailedCreateChange(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project string
		subject string
		commit  string
	}{
		{
			project: "test-project",
			subject: "dummy change",
			commit:  "foobar",
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.CreateChangeRequest{
			Project:    test.project,
			Ref:        "refs/heads/master",
			Subject:    test.subject,
			BaseCommit: test.commit,
		}
		// Client returns an error upon CreateChange call.
		mockGerritClient.EXPECT().CreateChange(gomock.Any(), &req).Return(nil, fmt.Errorf("failed to create change"))
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		changeInfo, err := mockGerritClientWrapper.createChange(ctx, test.subject, test.commit)
		if err == nil {
			t.Fatalf("expected error, got nil")
		}
		if changeInfo != nil {
			t.Fatalf("expected nil change info, got %s", changeInfo)
		}
	}
}

func TestEditFile(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
		filepath  string
		contents  string
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
			filepath:  "path/to/file",
			contents:  "dummy contents",
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.ChangeEditFileContentRequest{
			Number:   test.changeNum,
			Project:  test.project,
			FilePath: test.filepath,
			Content:  []byte(test.contents),
		}
		// Client returns an empty, non-error response after editing file.
		mockGerritClient.EXPECT().ChangeEditFileContent(gomock.Any(), &req).Return(&empty.Empty{}, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.editFile(ctx, test.changeNum, test.filepath, test.contents)
		if err != nil {
			t.Fatalf("got unexpected err: %v", err)
		}
	}
}

func TestFailedEditFile(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
		filepath  string
		contents  string
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
			filepath:  "path/to/file",
			contents:  "dummy contents",
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.ChangeEditFileContentRequest{
			Number:   test.changeNum,
			Project:  test.project,
			FilePath: test.filepath,
			Content:  []byte(test.contents),
		}
		// Client returns an error.
		mockGerritClient.EXPECT().ChangeEditFileContent(gomock.Any(), &req).Return(nil, fmt.Errorf("failed to edit file"))
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.editFile(ctx, test.changeNum, test.filepath, test.contents)
		if err == nil {
			t.Fatalf("expected error, got nil")
		}
	}
}

func TestPublishEdits(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.ChangeEditPublishRequest{
			Number:  test.changeNum,
			Project: test.project,
		}
		// Client returns an empty, non-error response after publishing eidts.
		mockGerritClient.EXPECT().ChangeEditPublish(gomock.Any(), &req).Return(&empty.Empty{}, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.publishEdits(ctx, test.changeNum)
		if err != nil {
			t.Fatalf("got unexpected err: %v", err)
		}
	}
}

func TestSetCQLabel(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		changeReq := gerritpb.GetChangeRequest{
			Number:  test.changeNum,
			Options: []gerritpb.QueryOption{gerritpb.QueryOption_CURRENT_REVISION},
		}
		changeResp := gerritpb.ChangeInfo{CurrentRevision: "foobar"}
		mockGerritClient.EXPECT().GetChange(gomock.Any(), &changeReq).Return(&changeResp, nil)
		reviewReq := gerritpb.SetReviewRequest{
			Number:     test.changeNum,
			Project:    test.project,
			RevisionId: "foobar",
			Labels:     map[string]int32{commitQueueLabel: int32(1)},
		}
		reviewResp := gerritpb.ReviewResult{Labels: map[string]int32{commitQueueLabel: int32(1)}}
		// Client returns a ReviewResult which has CQ+1.
		mockGerritClient.EXPECT().SetReview(gomock.Any(), &reviewReq).Return(&reviewResp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.setCQLabel(ctx, test.changeNum, true)
		if err != nil {
			t.Fatalf("got unexpected err: %v", err)
		}
	}
}

func TestRejectedSetCQLabel(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		changeReq := gerritpb.GetChangeRequest{
			Number:  test.changeNum,
			Options: []gerritpb.QueryOption{gerritpb.QueryOption_CURRENT_REVISION},
		}
		changeResp := gerritpb.ChangeInfo{CurrentRevision: "foobar"}
		mockGerritClient.EXPECT().GetChange(gomock.Any(), &changeReq).Return(&changeResp, nil)
		reviewReq := gerritpb.SetReviewRequest{
			Number:     test.changeNum,
			Project:    test.project,
			RevisionId: "foobar",
			Labels:     map[string]int32{commitQueueLabel: int32(1)},
		}
		reviewResp := gerritpb.ReviewResult{Labels: map[string]int32{}}
		// Client returns a ReviewResult which has no labels.
		mockGerritClient.EXPECT().SetReview(gomock.Any(), &reviewReq).Return(&reviewResp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.setCQLabel(ctx, test.changeNum, true)
		if err == nil {
			t.Fatalf("expected error, got nil")
		}
	}
}

func TestInvalidSetCQLabel(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		changeReq := gerritpb.GetChangeRequest{
			Number:  test.changeNum,
			Options: []gerritpb.QueryOption{gerritpb.QueryOption_CURRENT_REVISION},
		}
		changeResp := gerritpb.ChangeInfo{CurrentRevision: "foobar"}
		mockGerritClient.EXPECT().GetChange(gomock.Any(), &changeReq).Return(&changeResp, nil)
		reviewReq := gerritpb.SetReviewRequest{
			Number:     test.changeNum,
			Project:    test.project,
			RevisionId: "foobar",
			Labels:     map[string]int32{commitQueueLabel: int32(1)},
		}
		reviewResp := gerritpb.ReviewResult{Labels: map[string]int32{commitQueueLabel: int32(0)}}
		// Client returns a ReviewResult which has the wrong label value.
		mockGerritClient.EXPECT().SetReview(gomock.Any(), &reviewReq).Return(&reviewResp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.setCQLabel(ctx, test.changeNum, true)
		if err == nil {
			t.Fatalf("expected error, got nil")
		}
	}
}

func TestCheckCQCompletion(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.GetChangeRequest{
			Number:  test.changeNum,
			Options: []gerritpb.QueryOption{gerritpb.QueryOption_LABELS},
		}
		resp := gerritpb.ChangeInfo{
			Labels: map[string]*gerritpb.LabelInfo{
				commitQueueLabel: {Value: int32(0)},
			},
		}
		// Client returns an finished CQ response.
		mockGerritClient.EXPECT().GetChange(gomock.Any(), &req).Return(&resp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.checkCQCompletion(ctx, test.changeNum)
		if err != nil {
			t.Fatalf("got unexpected err: %v", err)
		}
	}
}

func TestUnfinishedCheckCQCompletion(t *testing.T) {
	t.Parallel()
	var tests = []struct {
		project   string
		changeNum int64
	}{
		{
			project:   "test-project",
			changeNum: int64(123456),
		},
	}
	for _, test := range tests {
		ctrl := gomock.NewController(t)
		defer ctrl.Finish()
		mockGerritClient := gerritpb.NewMockGerritClient(ctrl)
		req := gerritpb.GetChangeRequest{
			Number:  test.changeNum,
			Options: []gerritpb.QueryOption{gerritpb.QueryOption_LABELS},
		}
		resp := gerritpb.ChangeInfo{
			Labels: map[string]*gerritpb.LabelInfo{
				commitQueueLabel: {Value: int32(1)},
			},
		}
		// Client returns an unfinished CQ response.
		mockGerritClient.EXPECT().GetChange(gomock.Any(), &req).Return(&resp, nil)
		mockGerritClientWrapper := gerritClientWrapper{
			client:  mockGerritClient,
			project: test.project,
		}
		ctx := context.Background()
		err := mockGerritClientWrapper.checkCQCompletion(ctx, test.changeNum)
		if err == nil {
			t.Fatalf("expected error, got nil")
		}
	}
}