package rpc

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

	"github.com/stretchr/testify/require"
	swarming_api "go.chromium.org/luci/common/api/swarming/swarming/v1"
	"go.skia.org/infra/go/allowed"
	"go.skia.org/infra/go/deepequal/assertdeep"
	"go.skia.org/infra/go/firestore"
	"go.skia.org/infra/go/git"
	"go.skia.org/infra/go/git/repograph"
	"go.skia.org/infra/go/git/testutils/mem_git"
	"go.skia.org/infra/go/gitstore"
	"go.skia.org/infra/go/gitstore/mem_gitstore"
	"go.skia.org/infra/go/swarming"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/task_scheduler/go/db/memory"
	"go.skia.org/infra/task_scheduler/go/skip_tasks"
	"go.skia.org/infra/task_scheduler/go/specs"
	"go.skia.org/infra/task_scheduler/go/task_cfg_cache"
	tcc_testutils "go.skia.org/infra/task_scheduler/go/task_cfg_cache/testutils"
	"go.skia.org/infra/task_scheduler/go/types"
	"google.golang.org/protobuf/types/known/timestamppb"
)

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

	fakeRepo = "fake.git"
)

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

func setup(t *testing.T) (context.Context, *taskSchedulerServiceImpl, *types.Task, *types.Job, *skip_tasks.Rule, *swarming.MockApiClient, func()) {
	ctx := context.Background()

	// Git repo.
	d := memory.NewInMemoryDB()
	gs := mem_gitstore.New()
	gb := mem_git.New(t, gs)
	hashes := gb.CommitN(ctx, 2)
	ri, err := gitstore.NewGitStoreRepoImpl(ctx, gs)
	require.NoError(t, err)
	repo, err := repograph.NewWithRepoImpl(ctx, ri)
	require.NoError(t, err)
	repos := repograph.Map{
		fakeRepo: repo,
	}

	// Skip tasks DB.
	fsClient, cleanupFS := firestore.NewClientForTesting(context.Background(), t)
	skipDB, err := skip_tasks.New(context.Background(), fsClient)
	require.NoError(t, err)
	skipRule := &skip_tasks.Rule{
		AddedBy:          "test@google.com",
		TaskSpecPatterns: []string{"task"},
		Commits:          []string{hashes[0]},
		Description:      "Skip this!",
		Name:             "Skipper",
	}
	require.NoError(t, skipDB.AddRule(skipRule, repos))

	// Task config cache.
	btProject, btInstance, btCleanup := tcc_testutils.SetupBigTable(t)
	tcc, err := task_cfg_cache.NewTaskCfgCache(ctx, repos, btProject, btInstance, nil)
	require.NoError(t, err)
	for _, hash := range hashes {
		rs := types.RepoState{
			Repo:     fakeRepo,
			Revision: hash,
		}
		cfg := &specs.TasksCfg{
			Jobs: map[string]*specs.JobSpec{
				"job": {
					TaskSpecs: []string{"task"},
				},
			},
			Tasks: map[string]*specs.TaskSpec{
				"task": {
					Dimensions: []string{
						"os:linux",
					},
				},
			},
		}
		require.NoError(t, tcc.Set(ctx, rs, cfg, nil))
	}

	// Create a task and job.
	job := &types.Job{
		Created: time.Now(),
		Dependencies: map[string][]string{
			"task": {},
		},
		Name: "my-job",
		RepoState: types.RepoState{
			Repo:     fakeRepo,
			Revision: hashes[1],
		},
	}
	require.NoError(t, d.PutJob(job))

	task := &types.Task{
		Commits: hashes,
		Created: time.Now(),
		TaskKey: types.TaskKey{
			Name: "task",
			RepoState: types.RepoState{
				Repo:     fakeRepo,
				Revision: hashes[1],
			},
		},
	}
	require.NoError(t, d.PutTask(task))

	swarm := swarming.NewMockApiClient()

	// Create the service.
	srv := newTaskSchedulerServiceImpl(ctx, d, repos, skipDB, tcc, swarm, viewers, editors, admins)
	return ctx, srv, task, job, skipRule, swarm, func() {
		btCleanup()
		cleanupFS()
	}
}

func TestTriggerJobs(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, _, _, _, cleanup := setup(t)
	defer cleanup()

	commit := srv.repos[fakeRepo].Get(git.DefaultBranch).Hash
	req := &TriggerJobsRequest{
		Jobs: []*TriggerJob{
			{
				JobName:    "job",
				CommitHash: commit,
			},
			{
				JobName:    "job",
				CommitHash: commit,
			},
		},
	}

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

	// Check results.
	mockUser = editor
	res, err = srv.TriggerJobs(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 2, len(res.JobIds))
	for _, id := range res.JobIds {
		require.NotEqual(t, "", id)
	}
}

func TestGetJob(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, job, _, _, cleanup := setup(t)
	defer cleanup()

	req := &GetJobRequest{
		Id: job.Id,
	}

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

	// Check results.
	mockUser = viewer
	res, err = srv.GetJob(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, res.Job)
	require.Equal(t, job.Id, res.Job.Id)
	// Don't bother checking other fields, since we have a separate test for
	// convertJob.
	require.Equal(t, 1, len(res.Job.TaskDimensions))
	require.Equal(t, "task", res.Job.TaskDimensions[0].TaskName)
	assertdeep.Equal(t, []string{"os:linux"}, res.Job.TaskDimensions[0].Dimensions)
}

func TestCancelJob(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, job, _, _, cleanup := setup(t)
	defer cleanup()

	req := &CancelJobRequest{
		Id: job.Id,
	}

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

	// Check results.
	mockUser = editor
	res, err = srv.CancelJob(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, res.Job)
	require.Equal(t, job.Id, res.Job.Id)
	require.Equal(t, JobStatus_JOB_STATUS_CANCELED, res.Job.Status)
	// Don't bother checking other fields, since we have a separate test for
	// convertJob.
}

func TestSearchJobs(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, job, _, _, cleanup := setup(t)
	defer cleanup()

	req := &SearchJobsRequest{}

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

	// Check results.
	mockUser = viewer
	res, err = srv.SearchJobs(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 1, len(res.Jobs))
	require.Equal(t, job.Id, res.Jobs[0].Id)
	// Don't bother checking other fields, since we have a separate test for
	// convertJobs.
}

func TestGetTask(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, task, _, _, swarm, cleanup := setup(t)
	defer cleanup()

	req := &GetTaskRequest{
		Id: task.Id,
	}

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

	// Check results.
	mockUser = viewer
	res, err = srv.GetTask(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, res.Task)
	require.Equal(t, task.Id, res.Task.Id)
	require.Nil(t, res.Task.Stats)
	// Don't bother checking other fields, since we have a separate test for
	// convertTask.

	// Now, verify that we retrieve task stats when requested.
	swarm.On("GetTask", task.SwarmingTaskId, true).Return(&swarming_api.SwarmingRpcsTaskResult{
		PerformanceStats: &swarming_api.SwarmingRpcsPerformanceStats{
			BotOverhead: 10.0,
			IsolatedDownload: &swarming_api.SwarmingRpcsOperationStats{
				Duration: 6.0,
			},
			IsolatedUpload: &swarming_api.SwarmingRpcsOperationStats{
				Duration: 4.0,
			},
		},
	}, nil)
	req.IncludeStats = true
	res, err = srv.GetTask(ctx, req)
	require.NoError(t, err)
	require.NotNil(t, res.Task)
	require.Equal(t, task.Id, res.Task.Id)
	require.NotNil(t, res.Task.Stats)
	require.Equal(t, float32(10.0), res.Task.Stats.TotalOverheadS)
	require.Equal(t, float32(6.0), res.Task.Stats.DownloadOverheadS)
	require.Equal(t, float32(4.0), res.Task.Stats.UploadOverheadS)
}

func TestSearchTasks(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, task, _, _, _, cleanup := setup(t)
	defer cleanup()

	req := &SearchTasksRequest{}

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

	// Check results.
	mockUser = viewer
	res, err = srv.SearchTasks(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 1, len(res.Tasks))
	require.Equal(t, task.Id, res.Tasks[0].Id)
	// Don't bother checking other fields, since we have a separate test for
	// convertTasks.
}

func TestGetSkipTaskRules(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, _, skipRule, _, cleanup := setup(t)
	defer cleanup()

	req := &GetSkipTaskRulesRequest{}

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

	// Check results.
	mockUser = viewer
	res, err = srv.GetSkipTaskRules(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 1, len(res.Rules))
	require.Equal(t, skipRule.AddedBy, res.Rules[0].AddedBy)
	require.Equal(t, skipRule.Name, res.Rules[0].Name)
	require.Equal(t, skipRule.TaskSpecPatterns, res.Rules[0].TaskSpecPatterns)
	require.Equal(t, skipRule.Commits, res.Rules[0].Commits)
	require.Equal(t, skipRule.Description, res.Rules[0].Description)
}

func TestAddSkipTaskRule(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, _, skipRule, _, cleanup := setup(t)
	defer cleanup()

	req := &AddSkipTaskRuleRequest{
		TaskSpecPatterns: []string{"*"},
		Name:             "StAaaaahp",
		Description:      "Skip everything!",
	}

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

	// Check results.
	mockUser = editor
	res, err = srv.AddSkipTaskRule(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 2, len(res.Rules))
	require.Equal(t, skipRule.AddedBy, res.Rules[0].AddedBy)
	require.Equal(t, skipRule.Name, res.Rules[0].Name)
	require.Equal(t, skipRule.TaskSpecPatterns, res.Rules[0].TaskSpecPatterns)
	require.Equal(t, skipRule.Commits, res.Rules[0].Commits)
	require.Equal(t, skipRule.Description, res.Rules[0].Description)

	require.Equal(t, editor, res.Rules[1].AddedBy)
	require.Equal(t, req.Name, res.Rules[1].Name)
	require.Equal(t, req.TaskSpecPatterns, res.Rules[1].TaskSpecPatterns)
	require.Equal(t, req.Commits, res.Rules[1].Commits)
	require.Equal(t, req.Description, res.Rules[1].Description)
}

func TestDeleteSkipTaskRule(t *testing.T) {
	unittest.LargeTest(t)

	ctx, srv, _, _, skipRule, _, cleanup := setup(t)
	defer cleanup()

	req := &DeleteSkipTaskRuleRequest{
		Id: skipRule.Name,
	}

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

	// Check results.
	mockUser = editor
	res, err = srv.DeleteSkipTaskRule(ctx, req)
	require.NoError(t, err)
	require.Equal(t, 0, len(res.Rules))
}

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

	actual := convertRepoState(types.RepoState{
		Repo:     fakeRepo,
		Revision: "abc123",
		Patch: types.Patch{
			Issue:     "9999",
			PatchRepo: "patch.git",
			Patchset:  "2",
			Server:    "https://patch.com",
		},
	})
	assertdeep.Copy(t, &RepoState{
		Repo:     fakeRepo,
		Revision: "abc123",
		Patch: &RepoState_Patch{
			Issue:     "9999",
			PatchRepo: "patch.git",
			Patchset:  "2",
			Server:    "https://patch.com",
		},
	}, actual)
}

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

	test := func(input types.TaskStatus, expect TaskStatus) {
		actual, err := convertTaskStatus(input)
		require.NoError(t, err)
		require.Equal(t, expect, actual)
	}

	test(types.TASK_STATUS_PENDING, TaskStatus_TASK_STATUS_PENDING)
	test(types.TASK_STATUS_RUNNING, TaskStatus_TASK_STATUS_RUNNING)
	test(types.TASK_STATUS_SUCCESS, TaskStatus_TASK_STATUS_SUCCESS)
	test(types.TASK_STATUS_FAILURE, TaskStatus_TASK_STATUS_FAILURE)
	test(types.TASK_STATUS_MISHAP, TaskStatus_TASK_STATUS_MISHAP)

	_, err := convertTaskStatus(types.TaskStatus("bogus"))
	require.EqualError(t, err, "twirp error internal: Invalid task status.")
}

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

	actual, err := convertTask(&types.Task{
		Attempt:        1,
		Commits:        []string{"abc123"},
		Created:        time.Unix(1600181000, 0),
		DbModified:     time.Unix(1600182000, 0),
		Finished:       time.Unix(1600183000, 0),
		Id:             "my-task-id",
		IsolatedOutput: "outputhash",
		Jobs:           []string{"my-job"},
		MaxAttempts:    2,
		ParentTaskIds:  []string{"parent-task"},
		Properties: map[string]string{
			"key": "value",
		},
		RetryOf:        "previously-failed-task",
		Started:        time.Unix(1600181500, 0),
		Status:         types.TASK_STATUS_SUCCESS,
		SwarmingBotId:  "swarmbot",
		SwarmingTaskId: "swarmtask",
		TaskKey: types.TaskKey{
			RepoState: types.RepoState{
				Repo:     fakeRepo,
				Revision: "abc123",
				Patch: types.Patch{
					Issue:     "9999",
					PatchRepo: "patch.git",
					Patchset:  "2",
					Server:    "https://patch.com",
				},
			},
			Name:        "my-task",
			ForcedJobId: "forced-job",
		},
	})
	require.NoError(t, err)

	// Fake the Stats to appease assertdeep.Copy; Stats aren't set in
	// convertTask.
	actual.Stats = &TaskStats{
		DownloadOverheadS: 5,
		UploadOverheadS:   4,
		TotalOverheadS:    9,
	}

	assertdeep.Copy(t, &Task{
		Attempt:        1,
		Commits:        []string{"abc123"},
		CreatedAt:      timestamppb.New(time.Unix(1600181000, 0)),
		DbModifiedAt:   timestamppb.New(time.Unix(1600182000, 0)),
		FinishedAt:     timestamppb.New(time.Unix(1600183000, 0)),
		Id:             "my-task-id",
		IsolatedOutput: "outputhash",
		Jobs:           []string{"my-job"},
		MaxAttempts:    2,
		ParentTaskIds:  []string{"parent-task"},
		Properties: map[string]string{
			"key": "value",
		},
		RetryOf:        "previously-failed-task",
		StartedAt:      timestamppb.New(time.Unix(1600181500, 0)),
		Status:         TaskStatus_TASK_STATUS_SUCCESS,
		SwarmingBotId:  "swarmbot",
		SwarmingTaskId: "swarmtask",
		TaskKey: &TaskKey{
			RepoState: &RepoState{
				Repo:     fakeRepo,
				Revision: "abc123",
				Patch: &RepoState_Patch{
					Issue:     "9999",
					PatchRepo: "patch.git",
					Patchset:  "2",
					Server:    "https://patch.com",
				},
			},
			Name:        "my-task",
			ForcedJobId: "forced-job",
		},
		// Not set in convertTask.
		Stats: &TaskStats{
			DownloadOverheadS: 5,
			UploadOverheadS:   4,
			TotalOverheadS:    9,
		},
	}, actual)
}

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

	test := func(input types.JobStatus, expect JobStatus) {
		actual, err := convertJobStatus(input)
		require.NoError(t, err)
		require.Equal(t, expect, actual)
	}

	test(types.JOB_STATUS_IN_PROGRESS, JobStatus_JOB_STATUS_IN_PROGRESS)
	test(types.JOB_STATUS_SUCCESS, JobStatus_JOB_STATUS_SUCCESS)
	test(types.JOB_STATUS_FAILURE, JobStatus_JOB_STATUS_FAILURE)
	test(types.JOB_STATUS_MISHAP, JobStatus_JOB_STATUS_MISHAP)
	test(types.JOB_STATUS_CANCELED, JobStatus_JOB_STATUS_CANCELED)

	_, err := convertJobStatus(types.JobStatus("bogus"))
	require.EqualError(t, err, "twirp error internal: Invalid job status.")
}

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

	actual, err := convertJob(&types.Job{
		BuildbucketBuildId:  12345,
		BuildbucketLeaseKey: 67890,
		Created:             time.Unix(1600181000, 0),
		DbModified:          time.Unix(1600182000, 0),
		Dependencies: map[string][]string{
			"taskA": {},
			"taskB": {},
			"taskC": {"taskB", "taskA"},
			"taskD": {"taskC"},
		},
		Finished: time.Unix(1600183000, 0),
		Id:       "fake-job-id",
		IsForce:  true,
		Name:     "My Job",
		Priority: 0.8,
		RepoState: types.RepoState{
			Repo:     fakeRepo,
			Revision: "abc123",
			Patch: types.Patch{
				Issue:     "9999",
				PatchRepo: "patch.git",
				Patchset:  "2",
				Server:    "https://patch.com",
			},
		},
		Requested: time.Unix(1600180000, 0),
		Status:    types.JOB_STATUS_FAILURE,
		Tasks: map[string][]*types.TaskSummary{
			"taskA": {
				{
					Attempt:        0,
					Id:             "taskA-id-0",
					MaxAttempts:    2,
					Status:         types.TASK_STATUS_FAILURE,
					SwarmingTaskId: "swarm0",
				},
				{
					Attempt:        1,
					Id:             "taskA-id-1",
					MaxAttempts:    2,
					Status:         types.TASK_STATUS_FAILURE,
					SwarmingTaskId: "swarm1",
				},
			},
		},
	})
	// Use a placeholder value for TaskDimensions since it isn't filled in by
	// convertJob.
	actual.TaskDimensions = []*TaskDimensions{
		{
			TaskName:   "taskA",
			Dimensions: []string{"os:OS-A"},
		},
	}

	require.NoError(t, err)
	assertdeep.Copy(t, &Job{
		BuildbucketBuildId:  12345,
		BuildbucketLeaseKey: 67890,
		CreatedAt:           timestamppb.New(time.Unix(1600181000, 0)),
		DbModifiedAt:        timestamppb.New(time.Unix(1600182000, 0)),
		Dependencies: []*TaskDependencies{
			{
				Task:         "taskA",
				Dependencies: []string{},
			},
			{
				Task:         "taskB",
				Dependencies: []string{},
			},
			{
				Task:         "taskC",
				Dependencies: []string{"taskB", "taskA"},
			},
			{
				Task:         "taskD",
				Dependencies: []string{"taskC"},
			},
		},
		FinishedAt: timestamppb.New(time.Unix(1600183000, 0)),
		Id:         "fake-job-id",
		IsForce:    true,
		Name:       "My Job",
		Priority:   0.8,
		RepoState: &RepoState{
			Repo:     fakeRepo,
			Revision: "abc123",
			Patch: &RepoState_Patch{
				Issue:     "9999",
				PatchRepo: "patch.git",
				Patchset:  "2",
				Server:    "https://patch.com",
			},
		},
		RequestedAt: timestamppb.New(time.Unix(1600180000, 0)),
		Status:      JobStatus_JOB_STATUS_FAILURE,
		Tasks: []*TaskSummaries{
			{
				Name: "taskA",
				Tasks: []*TaskSummary{
					{
						Attempt:        0,
						Id:             "taskA-id-0",
						MaxAttempts:    2,
						Status:         TaskStatus_TASK_STATUS_FAILURE,
						SwarmingTaskId: "swarm0",
					},
					{
						Attempt:        1,
						Id:             "taskA-id-1",
						MaxAttempts:    2,
						Status:         TaskStatus_TASK_STATUS_FAILURE,
						SwarmingTaskId: "swarm1",
					},
				},
			},
		},
		// Just use a placeholder value for TaskDimensions; it isn't filled in
		// by convertJob.
		TaskDimensions: []*TaskDimensions{
			{
				TaskName:   "taskA",
				Dimensions: []string{"os:OS-A"},
			},
		},
	}, actual)
}