github.com/zppinho/prow@v0.0.0-20240510014325-1738badeb017/pkg/pjutil/pjutil_test.go

/*
Copyright 2017 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package pjutil

import (
	"errors"
	"fmt"
	"reflect"
	"testing"
	"text/template"
	"time"

	"github.com/google/go-cmp/cmp"
	"github.com/sirupsen/logrus"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/diff"
	"k8s.io/apimachinery/pkg/util/sets"

	prowapi "sigs.k8s.io/prow/pkg/apis/prowjobs/v1"
	"sigs.k8s.io/prow/pkg/config"
	"sigs.k8s.io/prow/pkg/github"
	"sigs.k8s.io/prow/pkg/kube"
)

func TestPostsubmitSpec(t *testing.T) {
	tests := []struct {
		name     string
		p        config.Postsubmit
		refs     prowapi.Refs
		expected prowapi.ProwJobSpec
	}{
		{
			name: "can override fields",
			p: config.Postsubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias:      "foo",
						CloneURI:       "bar",
						SkipSubmodules: true,
						CloneDepth:     7,
						SkipFetchHead:  true,
					},
				},
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PostsubmitJob,
				Refs: &prowapi.Refs{
					PathAlias:      "foo",
					CloneURI:       "bar",
					SkipSubmodules: true,
					CloneDepth:     7,
					SkipFetchHead:  true,
				},
				Report: true,
			},
		},
		{
			name: "controller can default fields",
			refs: prowapi.Refs{
				PathAlias:      "fancy",
				CloneURI:       "cats",
				SkipSubmodules: true,
				CloneDepth:     8,
				SkipFetchHead:  true,
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PostsubmitJob,
				Refs: &prowapi.Refs{
					PathAlias:      "fancy",
					CloneURI:       "cats",
					SkipSubmodules: true,
					CloneDepth:     8,
					SkipFetchHead:  true,
				},
				Report: true,
			},
		},
		{
			name: "job overrides take precedence over controller defaults",
			p: config.Postsubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias:  "foo",
						CloneDepth: 3,
						CloneURI:   "bar",
					},
				},
			},
			refs: prowapi.Refs{
				PathAlias:  "fancy",
				CloneDepth: 1,
				CloneURI:   "cats",
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PostsubmitJob,
				Refs: &prowapi.Refs{
					PathAlias:  "foo",
					CloneDepth: 3,
					CloneURI:   "bar",
				},
				Report: true,
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			actual := PostsubmitSpec(tc.p, tc.refs)
			if diff := cmp.Diff(actual, tc.expected); diff != "" {
				t.Errorf("PostsubmitSpec() got unexpected diff (-have, +want):\n%s", diff)
			}
		})
	}
}

func TestPresubmitSpec(t *testing.T) {
	tests := []struct {
		name     string
		p        config.Presubmit
		refs     prowapi.Refs
		expected prowapi.ProwJobSpec
	}{
		{
			name: "can override path alias and cloneuri",
			p: config.Presubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias: "foo",
						CloneURI:  "bar",
					},
				},
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					PathAlias: "foo",
					CloneURI:  "bar",
				},
				Report: true,
			},
		},
		{
			name: "controller can default path alias and cloneuri",
			refs: prowapi.Refs{
				PathAlias: "fancy",
				CloneURI:  "cats",
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					PathAlias: "fancy",
					CloneURI:  "cats",
				},
				Report: true,
			},
		},
		{
			name: "job overrides take precedence over controller defaults",
			p: config.Presubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias: "foo",
						CloneURI:  "bar",
					},
				},
			},
			refs: prowapi.Refs{
				PathAlias: "fancy",
				CloneURI:  "cats",
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					PathAlias: "foo",
					CloneURI:  "bar",
				},
				Report: true,
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			actual := PresubmitSpec(tc.p, tc.refs)
			if diff := cmp.Diff(actual, tc.expected); diff != "" {
				t.Errorf("PresubmitSpec() got unexpected diff (-have, +want):\n%s", diff)
			}
		})
	}
}

func TestBatchSpec(t *testing.T) {
	tests := []struct {
		name     string
		p        config.Presubmit
		refs     prowapi.Refs
		expected prowapi.ProwJobSpec
	}{
		{
			name: "can override path alias and cloneuri",
			p: config.Presubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias: "foo",
						CloneURI:  "bar",
					},
				},
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.BatchJob,
				Refs: &prowapi.Refs{
					PathAlias: "foo",
					CloneURI:  "bar",
				},
			},
		},
		{
			name: "controller can default path alias and cloneuri",
			refs: prowapi.Refs{
				PathAlias: "fancy",
				CloneURI:  "cats",
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.BatchJob,
				Refs: &prowapi.Refs{
					PathAlias: "fancy",
					CloneURI:  "cats",
				},
			},
		},
		{
			name: "job overrides take precedence over controller defaults",
			p: config.Presubmit{
				JobBase: config.JobBase{
					UtilityConfig: config.UtilityConfig{
						PathAlias: "foo",
						CloneURI:  "bar",
					},
				},
			},
			refs: prowapi.Refs{
				PathAlias: "fancy",
				CloneURI:  "cats",
			},
			expected: prowapi.ProwJobSpec{
				Type: prowapi.BatchJob,
				Refs: &prowapi.Refs{
					PathAlias: "foo",
					CloneURI:  "bar",
				},
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			actual := BatchSpec(tc.p, tc.refs)
			if diff := cmp.Diff(actual, tc.expected); diff != "" {
				t.Errorf("BatchSpec() got unexpected diff (-have, +want):\n%s", diff)
			}
		})
	}
}

func TestCompletePrimaryRefs(t *testing.T) {
	cases := []struct {
		name     string
		refs     prowapi.Refs
		jobBase  config.JobBase
		expected prowapi.Refs
	}{
		{
			name: "basically works",
		},
		{
			name: "use values from refs",
			refs: prowapi.Refs{
				PathAlias:      "this",
				CloneURI:       "that",
				SkipSubmodules: true,
				CloneDepth:     1,
				SkipFetchHead:  true,
			},
			expected: prowapi.Refs{
				PathAlias:      "this",
				CloneURI:       "that",
				SkipSubmodules: true,
				CloneDepth:     1,
				SkipFetchHead:  true,
			},
		},
		{
			name: "use values from job base",
			jobBase: config.JobBase{
				UtilityConfig: config.UtilityConfig{
					PathAlias:      "more",
					CloneURI:       "fun",
					SkipSubmodules: true,
					CloneDepth:     2,
					SkipFetchHead:  true,
					DecorationConfig: &prowapi.DecorationConfig{
						BloblessFetch: boolPtr(true),
					},
				},
			},
			expected: prowapi.Refs{
				PathAlias:      "more",
				CloneURI:       "fun",
				SkipSubmodules: true,
				CloneDepth:     2,
				SkipFetchHead:  true,
				BloblessFetch:  boolPtr(true),
			},
		},
		{
			name: "prefer job base values",
			refs: prowapi.Refs{
				PathAlias:  "this",
				CloneURI:   "that",
				CloneDepth: 1,
			},
			jobBase: config.JobBase{
				UtilityConfig: config.UtilityConfig{
					PathAlias:  "more",
					CloneURI:   "fun",
					CloneDepth: 2,
				},
			},
			expected: prowapi.Refs{
				PathAlias:  "more",
				CloneURI:   "fun",
				CloneDepth: 2,
			},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			actual := CompletePrimaryRefs(tc.refs, tc.jobBase)
			if diff := cmp.Diff(actual, &tc.expected); diff != "" {
				t.Errorf("CompletePrimaryRefs() got unexpected diff (-have, +want):\n%s", diff)
			}
		})
	}
}

func TestPartitionActive(t *testing.T) {
	tests := []struct {
		pjs []prowapi.ProwJob

		pending   sets.Set[string]
		triggered sets.Set[string]
		aborted   sets.Set[string]
	}{
		{
			pjs: []prowapi.ProwJob{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "foo",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.TriggeredState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "bar",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.PendingState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "baz",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.SuccessState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "error",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.ErrorState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "bak",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.PendingState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "aborted",
					},
					Status: prowapi.ProwJobStatus{
						State: prowapi.AbortedState,
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "aborted-and-completed",
					},
					Status: prowapi.ProwJobStatus{
						State:          prowapi.AbortedState,
						CompletionTime: &[]metav1.Time{metav1.Now()}[0],
					},
				},
			},
			pending:   sets.New[string]("bar", "bak"),
			triggered: sets.New[string]("foo"),
			aborted:   sets.New[string]("aborted"),
		},
	}

	for i, test := range tests {
		t.Logf("test run #%d", i)
		pendingCh, triggeredCh, abortedCh := PartitionActive(test.pjs)
		for job := range pendingCh {
			if !test.pending.Has(job.Name) {
				t.Errorf("didn't find pending job %#v", job)
			}
		}
		for job := range triggeredCh {
			if !test.triggered.Has(job.Name) {
				t.Errorf("didn't find triggered job %#v", job)
			}
		}
		for job := range abortedCh {
			if !test.aborted.Has(job.Name) {
				t.Errorf("didn't find aborted job %#v", job)
			}
		}
	}
}

func TestGetLatestProwJobs(t *testing.T) {
	tests := []struct {
		name string

		pjs     []prowapi.ProwJob
		jobType string

		expected map[string]struct{}
	}{
		{
			pjs: []prowapi.ProwJob{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "831c7df0-baa4-11e7-a1a4-0a58ac10134a",
					},
					Spec: prowapi.ProwJobSpec{
						Type:  prowapi.PresubmitJob,
						Agent: prowapi.JenkinsAgent,
						Job:   "test_pull_request_origin_extended_networking_minimal",
						Refs: &prowapi.Refs{
							Org:     "openshift",
							Repo:    "origin",
							BaseRef: "master",
							BaseSHA: "e92d5c525795eafb82cf16e3ab151b567b47e333",
							Pulls: []prowapi.Pull{
								{
									Number:  17061,
									Author:  "enj",
									SHA:     "f94a3a51f59a693642e39084f03efa83af9442d3",
									HeadRef: "fixes-123",
								},
							},
						},
						Report:       true,
						Context:      "ci/openshift-jenkins/extended_networking_minimal",
						RerunCommand: "/test extended_networking_minimal",
					},
					Status: prowapi.ProwJobStatus{
						StartTime:   metav1.Date(2017, time.October, 26, 23, 22, 19, 0, time.UTC),
						State:       prowapi.FailureState,
						Description: "Jenkins job failed.",
						URL:         "https://openshift-gce-devel.appspot.com/build/origin-ci-test/pr-logs/pull/17061/test_pull_request_origin_extended_networking_minimal/9756/",
						PodName:     "test_pull_request_origin_extended_networking_minimal-9756",
						BuildID:     "9756",
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: "0079d4d3-ba25-11e7-ae3f-0a58ac10123b",
					},
					Spec: prowapi.ProwJobSpec{
						Type:  prowapi.PresubmitJob,
						Agent: prowapi.JenkinsAgent,
						Job:   "test_pull_request_origin_extended_networking_minimal",
						Refs: &prowapi.Refs{
							Org:     "openshift",
							Repo:    "origin",
							BaseRef: "master",
							BaseSHA: "e92d5c525795eafb82cf16e3ab151b567b47e333",
							Pulls: []prowapi.Pull{
								{
									Number:  17061,
									Author:  "enj",
									SHA:     "f94a3a51f59a693642e39084f03efa83af9442d3",
									HeadRef: "fixes-123",
								},
							},
						},
						Report:       true,
						Context:      "ci/openshift-jenkins/extended_networking_minimal",
						RerunCommand: "/test extended_networking_minimal",
					},
					Status: prowapi.ProwJobStatus{
						StartTime:   metav1.Date(2017, time.October, 26, 22, 22, 19, 0, time.UTC),
						State:       prowapi.FailureState,
						Description: "Jenkins job failed.",
						URL:         "https://openshift-gce-devel.appspot.com/build/origin-ci-test/pr-logs/pull/17061/test_pull_request_origin_extended_networking_minimal/9755/",
						PodName:     "test_pull_request_origin_extended_networking_minimal-9755",
						BuildID:     "9755",
					},
				},
			},
			jobType:  "presubmit",
			expected: map[string]struct{}{"831c7df0-baa4-11e7-a1a4-0a58ac10134a": {}},
		},
	}

	for _, test := range tests {
		got := GetLatestProwJobs(test.pjs, prowapi.ProwJobType(test.jobType))
		if len(got) != len(test.expected) {
			t.Errorf("expected jobs:\n%+v\ngot jobs:\n%+v", test.expected, got)
			continue
		}
		for name := range test.expected {
			if _, ok := got[name]; ok {
				t.Errorf("expected job: %s", name)
			}
		}
	}
}

func TestNewProwJob(t *testing.T) {
	var testCases = []struct {
		name                string
		spec                prowapi.ProwJobSpec
		labels              map[string]string
		expectedLabels      map[string]string
		annotations         map[string]string
		expectedAnnotations map[string]string
	}{
		{
			name: "periodic job, no extra labels",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "periodic",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
		{
			name: "periodic job, extra labels",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			labels: map[string]string{
				"extra": "stuff",
			},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "periodic",
				"extra":                "stuff",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
		{
			name: "periodic job with extra refs",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
				ExtraRefs: []prowapi.Refs{{
					Org:     "org",
					Repo:    "repo",
					BaseRef: "main",
				}},
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "periodic",
				kube.OrgLabel:          "org",
				kube.RepoLabel:         "repo",
				kube.BaseRefLabel:      "main",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
		{
			name: "presubmit job",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:     "org",
					Repo:    "repo",
					BaseRef: "main",
					Pulls: []prowapi.Pull{
						{Number: 1},
					},
				},
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "presubmit",
				kube.OrgLabel:          "org",
				kube.RepoLabel:         "repo",
				kube.BaseRefLabel:      "main",
				kube.PullLabel:         "1",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
		{
			name: "non-github presubmit job",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:     "https://some-gerrit-instance.foo.com",
					Repo:    "some/invalid/repo",
					BaseRef: "main",
					Pulls: []prowapi.Pull{
						{Number: 1},
					},
				},
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "presubmit",
				kube.OrgLabel:          "some-gerrit-instance.foo.com",
				kube.RepoLabel:         "repo",
				kube.BaseRefLabel:      "main",
				kube.PullLabel:         "1",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		}, {
			name: "job with name too long to fit in a label",
			spec: prowapi.ProwJobSpec{
				Job:     "job-created-by-someone-who-loves-very-very-very-long-names-so-long-that-it-does-not-fit-into-the-Kubernetes-label-so-it-needs-to-be-truncated-to-63-characters",
				Context: "job-context",
				Type:    prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:     "org",
					Repo:    "repo",
					BaseRef: "main",
					Pulls: []prowapi.Pull{
						{Number: 1},
					},
				},
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job-created-by-someone-who-loves-very-very-very-long-names-so-l",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "presubmit",
				kube.OrgLabel:          "org",
				kube.RepoLabel:         "repo",
				kube.BaseRefLabel:      "main",
				kube.PullLabel:         "1",
			},
			expectedAnnotations: map[string]string{
				kube.ContextAnnotation: "job-context",
				kube.ProwJobAnnotation: "job-created-by-someone-who-loves-very-very-very-long-names-so-long-that-it-does-not-fit-into-the-Kubernetes-label-so-it-needs-to-be-truncated-to-63-characters",
			},
		},
		{
			name: "job with context too long to fit in a label",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "context-created-by-someone-who-loves-very-very-very-long-names-so-long-that-it-does-not-fit-into-the-Kubernetes-label-so-it-needs-to-be-truncated-to-63-characters",
				Type:    prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:     "org",
					Repo:    "repo",
					BaseRef: "main",
					Pulls: []prowapi.Pull{
						{Number: 1},
					},
				},
			},
			labels: map[string]string{},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "context-created-by-someone-who-loves-very-very-very-long-names",
				kube.ProwJobTypeLabel:  "presubmit",
				kube.OrgLabel:          "org",
				kube.RepoLabel:         "repo",
				kube.BaseRefLabel:      "main",
				kube.PullLabel:         "1",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "context-created-by-someone-who-loves-very-very-very-long-names-so-long-that-it-does-not-fit-into-the-Kubernetes-label-so-it-needs-to-be-truncated-to-63-characters",
			},
		},
		{
			name: "periodic job, extra labels, extra annotations",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			labels: map[string]string{
				"extra": "stuff",
			},
			annotations: map[string]string{
				"extraannotation": "foo",
			},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "periodic",
				"extra":                "stuff",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				"extraannotation":      "foo",
			},
		},
		{
			name: "job with podspec",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
				PodSpec: &corev1.PodSpec{}, // Needed to catch race
			},
			expectedLabels: map[string]string{
				kube.CreatedByProw:     "true",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
				kube.ProwJobTypeLabel:  "periodic",
			},
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
	}
	for _, testCase := range testCases {
		pj := NewProwJob(testCase.spec, testCase.labels, testCase.annotations)
		if actual, expected := pj.Spec, testCase.spec; !equality.Semantic.DeepEqual(actual, expected) {
			t.Errorf("%s: incorrect ProwJobSpec created: %s", testCase.name, diff.ObjectReflectDiff(actual, expected))
		}
		if actual, expected := pj.Labels, testCase.expectedLabels; !reflect.DeepEqual(actual, expected) {
			t.Errorf("%s: incorrect ProwJob labels created: %s", testCase.name, diff.ObjectReflectDiff(actual, expected))
		}
		if actual, expected := pj.Annotations, testCase.expectedAnnotations; !reflect.DeepEqual(actual, expected) {
			t.Errorf("%s: incorrect ProwJob annotations created: %s", testCase.name, diff.ObjectReflectDiff(actual, expected))
		}
		if pj.Spec.PodSpec != nil {
			futzWithPodSpec := func(spec *corev1.PodSpec, val string) {
				if spec == nil {
					return
				}
				if spec.NodeSelector == nil {
					spec.NodeSelector = map[string]string{}
				}
				spec.NodeSelector["foo"] = val
				for i := range spec.Containers {
					c := &spec.Containers[i]
					if c.Resources.Limits == nil {
						c.Resources.Limits = corev1.ResourceList{}
					}
					if c.Resources.Requests == nil {
						c.Resources.Requests = corev1.ResourceList{}
					}
					c.Resources.Limits[corev1.ResourceCPU] = resource.MustParse(val)
					c.Resources.Requests[corev1.ResourceCPU] = resource.MustParse(val)
				}
			}
			go futzWithPodSpec(pj.Spec.PodSpec, "12M")
			futzWithPodSpec(testCase.spec.PodSpec, "34M")
		}
	}
}

func TestNewProwJobWithAnnotations(t *testing.T) {
	var testCases = []struct {
		name                string
		spec                prowapi.ProwJobSpec
		annotations         map[string]string
		expectedAnnotations map[string]string
	}{
		{
			name: "job without annotation",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			annotations: nil,
			expectedAnnotations: map[string]string{
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
		{
			name: "job with annotation",
			spec: prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			annotations: map[string]string{
				"annotation": "foo",
			},
			expectedAnnotations: map[string]string{
				"annotation":           "foo",
				kube.ProwJobAnnotation: "job",
				kube.ContextAnnotation: "job-context",
			},
		},
	}

	for _, testCase := range testCases {
		pj := NewProwJob(testCase.spec, nil, testCase.annotations)
		if actual, expected := pj.Spec, testCase.spec; !equality.Semantic.DeepEqual(actual, expected) {
			t.Errorf("%s: incorrect ProwJobSpec created: %s", testCase.name, diff.ObjectReflectDiff(actual, expected))
		}
		if actual, expected := pj.Annotations, testCase.expectedAnnotations; !reflect.DeepEqual(actual, expected) {
			t.Errorf("%s: incorrect ProwJob labels created: %s", testCase.name, diff.ObjectReflectDiff(actual, expected))
		}
	}
}

func TestNewProwJobWithModifiers(t *testing.T) {
	stime, _ := time.Parse(time.DateOnly, "2024-02-27")
	fakeStartTime := metav1.NewTime(stime)
	fakeName := "foo"

	for _, testCase := range []struct {
		name        string
		spec        *prowapi.ProwJobSpec
		labels      map[string]string
		annotations map[string]string
		options     []Modifier
		wantProwJob prowapi.ProwJob
	}{
		{
			name: "no options",
			spec: &prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			labels:      map[string]string{"extra-label": "foo"},
			annotations: map[string]string{"extra-annotation": "bar"},
			wantProwJob: prowapi.ProwJob{
				TypeMeta: metav1.TypeMeta{
					APIVersion: "prow.k8s.io/v1",
					Kind:       "ProwJob",
				},
				ObjectMeta: metav1.ObjectMeta{
					Name: fakeName,
					Labels: map[string]string{
						kube.CreatedByProw:     "true",
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						kube.ProwJobTypeLabel:  string(prowapi.PeriodicJob),
						"extra-label":          "foo",
					},
					Annotations: map[string]string{
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						"extra-annotation":     "bar",
					},
				},
				Spec: prowapi.ProwJobSpec{
					Job:     "job",
					Context: "job-context",
					Type:    prowapi.PeriodicJob,
				},
				Status: prowapi.ProwJobStatus{
					StartTime: fakeStartTime,
					State:     prowapi.TriggeredState,
				},
			},
		},
		{
			name: "require scheduling",
			spec: &prowapi.ProwJobSpec{
				Job:     "job",
				Context: "job-context",
				Type:    prowapi.PeriodicJob,
			},
			labels:      map[string]string{"extra-label": "foo"},
			annotations: map[string]string{"extra-annotation": "bar"},
			options:     []Modifier{RequireScheduling(true)},
			wantProwJob: prowapi.ProwJob{
				TypeMeta: metav1.TypeMeta{
					APIVersion: "prow.k8s.io/v1",
					Kind:       "ProwJob",
				},
				ObjectMeta: metav1.ObjectMeta{
					Name: fakeName,
					Labels: map[string]string{
						kube.CreatedByProw:     "true",
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						kube.ProwJobTypeLabel:  string(prowapi.PeriodicJob),
						"extra-label":          "foo",
					},
					Annotations: map[string]string{
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						"extra-annotation":     "bar",
					},
				},
				Spec: prowapi.ProwJobSpec{
					Job:     "job",
					Context: "job-context",
					Type:    prowapi.PeriodicJob,
				},
				Status: prowapi.ProwJobStatus{
					StartTime: fakeStartTime,
					State:     prowapi.SchedulingState,
				},
			},
		},
	} {
		t.Run(testCase.name, func(t *testing.T) {
			pj := NewProwJob(*testCase.spec, testCase.labels, testCase.annotations, testCase.options...)
			pj.Name = fakeName
			pj.Status.StartTime = fakeStartTime

			if diff := cmp.Diff(&testCase.wantProwJob, &pj); diff != "" {
				t.Errorf("prowjob doesn't match: %s", diff)
			}
		})
	}
}

func TestNewPresubmitWithModifiers(t *testing.T) {
	stime, _ := time.Parse(time.DateOnly, "2024-02-27")
	fakeStartTime := metav1.NewTime(stime)
	fakeName := "foo"
	pr := github.PullRequest{
		Number:  42,
		Title:   "pr-title",
		HTMLURL: "https://github.example.com/kubernetes/test-infra/pull/42",
		Head: github.PullRequestBranch{
			SHA: "123456",
			Ref: "head-ref",
		},
		Base: github.PullRequestBranch{
			Ref: "base-ref",
			Repo: github.Repo{
				Name:    "repo-name",
				HTMLURL: "https://github.example.com/kubernetes/test-infra",
				Owner: github.User{
					Login: "kubernetes",
				},
			},
		},
		User: github.User{
			Login:   "user-login",
			HTMLURL: "https://github.example.com/user-login",
		},
	}

	for _, testCase := range []struct {
		name        string
		spec        *prowapi.ProwJobSpec
		labels      map[string]string
		pr          *github.PullRequest
		baseSHA     string
		job         *config.Presubmit
		eventGUID   string
		options     []Modifier
		wantProwJob prowapi.ProwJob
	}{
		{
			name:    "no options",
			labels:  map[string]string{"extra-label": "foo"},
			pr:      &pr,
			baseSHA: "987654",
			job: &config.Presubmit{
				JobBase:  config.JobBase{Name: "job"},
				Reporter: config.Reporter{Context: "job-context"},
			},
			eventGUID: "0001",
			wantProwJob: prowapi.ProwJob{
				TypeMeta: metav1.TypeMeta{
					APIVersion: "prow.k8s.io/v1",
					Kind:       "ProwJob",
				},
				ObjectMeta: metav1.ObjectMeta{
					Name: fakeName,
					Labels: map[string]string{
						kube.CreatedByProw:     "true",
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						kube.ProwJobTypeLabel:  string(prowapi.PresubmitJob),
						github.EventGUID:       "0001",
						kube.IsOptionalLabel:   "false",
						kube.OrgLabel:          "kubernetes",
						kube.RepoLabel:         "repo-name",
						kube.BaseRefLabel:      "base-ref",
						kube.PullLabel:         "42",
						"extra-label":          "foo",
					},
					Annotations: map[string]string{
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
					},
				},
				Spec: prowapi.ProwJobSpec{
					Job:     "job",
					Context: "job-context",
					Type:    prowapi.PresubmitJob,
					Report:  true,
					Refs: &prowapi.Refs{
						Org:      "kubernetes",
						Repo:     "repo-name",
						BaseSHA:  "987654",
						RepoLink: "https://github.example.com/kubernetes/test-infra",
						BaseRef:  "base-ref",
						BaseLink: "https://github.example.com/kubernetes/test-infra/commit/987654",
						Pulls: []prowapi.Pull{{
							Number:     42,
							Author:     "user-login",
							SHA:        "123456",
							Title:      "pr-title",
							HeadRef:    "head-ref",
							Link:       "https://github.example.com/kubernetes/test-infra/pull/42",
							CommitLink: "https://github.example.com/kubernetes/test-infra/pull/42/commits/123456",
							AuthorLink: "https://github.example.com/user-login",
						}},
					},
				},
				Status: prowapi.ProwJobStatus{
					StartTime: fakeStartTime,
					State:     prowapi.TriggeredState,
				},
			},
		},
		{
			name:    "require scheduling",
			labels:  map[string]string{"extra-label": "foo"},
			pr:      &pr,
			baseSHA: "987654",
			job: &config.Presubmit{
				JobBase:  config.JobBase{Name: "job"},
				Reporter: config.Reporter{Context: "job-context"},
			},
			eventGUID: "0001",
			options:   []Modifier{RequireScheduling(true)},
			wantProwJob: prowapi.ProwJob{
				TypeMeta: metav1.TypeMeta{
					APIVersion: "prow.k8s.io/v1",
					Kind:       "ProwJob",
				},
				ObjectMeta: metav1.ObjectMeta{
					Name: fakeName,
					Labels: map[string]string{
						kube.CreatedByProw:     "true",
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
						kube.ProwJobTypeLabel:  string(prowapi.PresubmitJob),
						github.EventGUID:       "0001",
						kube.IsOptionalLabel:   "false",
						kube.OrgLabel:          "kubernetes",
						kube.RepoLabel:         "repo-name",
						kube.BaseRefLabel:      "base-ref",
						kube.PullLabel:         "42",
						"extra-label":          "foo",
					},
					Annotations: map[string]string{
						kube.ProwJobAnnotation: "job",
						kube.ContextAnnotation: "job-context",
					},
				},
				Spec: prowapi.ProwJobSpec{
					Job:     "job",
					Context: "job-context",
					Type:    prowapi.PresubmitJob,
					Report:  true,
					Refs: &prowapi.Refs{
						Org:      "kubernetes",
						Repo:     "repo-name",
						BaseSHA:  "987654",
						RepoLink: "https://github.example.com/kubernetes/test-infra",
						BaseRef:  "base-ref",
						BaseLink: "https://github.example.com/kubernetes/test-infra/commit/987654",
						Pulls: []prowapi.Pull{{
							Number:     42,
							Author:     "user-login",
							SHA:        "123456",
							Title:      "pr-title",
							HeadRef:    "head-ref",
							Link:       "https://github.example.com/kubernetes/test-infra/pull/42",
							CommitLink: "https://github.example.com/kubernetes/test-infra/pull/42/commits/123456",
							AuthorLink: "https://github.example.com/user-login",
						}},
					},
				},
				Status: prowapi.ProwJobStatus{
					StartTime: fakeStartTime,
					State:     prowapi.SchedulingState,
				},
			},
		},
	} {
		t.Run(testCase.name, func(t *testing.T) {
			pj := NewPresubmit(*testCase.pr, testCase.baseSHA, *testCase.job, testCase.eventGUID, testCase.labels, testCase.options...)
			pj.Name = fakeName
			pj.Status.StartTime = fakeStartTime

			if diff := cmp.Diff(&testCase.wantProwJob, &pj); diff != "" {
				t.Errorf("prowjob doesn't match: %s", diff)
			}
		})
	}
}

func TestJobURL(t *testing.T) {
	var testCases = []struct {
		name        string
		plank       config.Plank
		pj          prowapi.ProwJob
		expected    string
		expectedErr string
	}{
		{
			name: "non-decorated job uses template",
			plank: config.Plank{
				Controller: config.Controller{
					JobURLTemplate: template.Must(template.New("test").Parse("{{.Spec.Type}}")),
				},
			},
			pj:       prowapi.ProwJob{Spec: prowapi.ProwJobSpec{Type: prowapi.PeriodicJob}},
			expected: "periodic",
		},
		{
			name: "non-decorated job with broken template gives empty string",
			plank: config.Plank{
				Controller: config.Controller{
					JobURLTemplate: template.Must(template.New("test").Parse("{{.Garbage}}")),
				},
			},
			pj:       prowapi.ProwJob{},
			expected: "",
		},
		{
			name: "decorated job without prefix uses template",
			plank: config.Plank{
				Controller: config.Controller{
					JobURLTemplate: template.Must(template.New("test").Parse("{{.Spec.Type}}")),
				},
			},
			pj:       prowapi.ProwJob{Spec: prowapi.ProwJobSpec{Type: prowapi.PeriodicJob}},
			expected: "periodic",
		},
		{
			name: "decorated job with prefix uses gcsupload",
			plank: config.Plank{
				JobURLPrefixConfig:                       map[string]string{"*": "https://gubernator.com/build"},
				JobURLPrefixDisableAppendStorageProvider: true,
			},
			pj: prowapi.ProwJob{Spec: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:   "org",
					Repo:  "repo",
					Pulls: []prowapi.Pull{{Number: 1}},
				},
				DecorationConfig: &prowapi.DecorationConfig{GCSConfiguration: &prowapi.GCSConfiguration{
					Bucket:       "bucket",
					PathStrategy: prowapi.PathStrategyExplicit,
				}},
			}},
			expected: "https://gubernator.com/build/bucket/pr-logs/pull/org_repo/1",
		},
		{
			name: "decorated job with prefix uses gcsupload and new bucket format with gcs (new job url format)",
			plank: config.Plank{
				JobURLPrefixConfig: map[string]string{"*": "https://prow.k8s.io/view/"},
			},
			pj: prowapi.ProwJob{Spec: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:   "org",
					Repo:  "repo",
					Pulls: []prowapi.Pull{{Number: 1}},
				},
				DecorationConfig: &prowapi.DecorationConfig{GCSConfiguration: &prowapi.GCSConfiguration{
					Bucket:       "gs://bucket",
					PathStrategy: prowapi.PathStrategyExplicit,
				}},
			}},
			expected: "https://prow.k8s.io/view/gs/bucket/pr-logs/pull/org_repo/1",
		},
		{
			name: "decorated job with prefix uses gcsupload and new bucket format with s3",
			plank: config.Plank{
				JobURLPrefixConfig: map[string]string{"*": "https://prow.k8s.io/view/"},
			},
			pj: prowapi.ProwJob{Spec: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:   "org",
					Repo:  "repo",
					Pulls: []prowapi.Pull{{Number: 1}},
				},
				DecorationConfig: &prowapi.DecorationConfig{GCSConfiguration: &prowapi.GCSConfiguration{
					Bucket:       "s3://bucket",
					PathStrategy: prowapi.PathStrategyExplicit,
				}},
			}},
			expected: "https://prow.k8s.io/view/s3/bucket/pr-logs/pull/org_repo/1",
		},
		{
			name: "decorated job with prefix uses gcsupload with valid bucket with multiple separators",
			plank: config.Plank{
				JobURLPrefixConfig: map[string]string{"*": "https://prow.k8s.io/view/"},
			},
			pj: prowapi.ProwJob{Spec: prowapi.ProwJobSpec{
				Type: prowapi.PresubmitJob,
				Refs: &prowapi.Refs{
					Org:   "org",
					Repo:  "repo",
					Pulls: []prowapi.Pull{{Number: 1}},
				},
				DecorationConfig: &prowapi.DecorationConfig{GCSConfiguration: &prowapi.GCSConfiguration{
					Bucket:       "gs://my-floppy-backup/a://doom2.wad.006",
					PathStrategy: prowapi.PathStrategyExplicit,
				}},
			}},
			expected: "https://prow.k8s.io/view/gs/my-floppy-backup/a:/doom2.wad.006/pr-logs/pull/org_repo/1",
		},
	}

	logger := logrus.New()
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			actual, actualErr := JobURL(testCase.plank, testCase.pj, logger.WithField("name", testCase.name))
			var actualErrStr string
			if actualErr != nil {
				actualErrStr = actualErr.Error()
			}

			if actualErrStr != testCase.expectedErr {
				t.Errorf("%s: expectedErr = %v, but got %v", testCase.name, testCase.expectedErr, actualErrStr)
			}
			if actual != testCase.expected {
				t.Errorf("%s: expected URL to be %q but got %q", testCase.name, testCase.expected, actual)
			}
		})
	}
}

func TestSetReportDefault(t *testing.T) {
	tests := []struct {
		name     string
		spec     *prowapi.ProwJobSpec
		wantSpec *prowapi.ProwJobSpec
	}{
		{
			name: "base-case",
			spec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{
					Slack: &prowapi.SlackReporterConfig{
						JobStatesToReport: []prowapi.ProwJobState{},
					},
				},
			},
			wantSpec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{
					Slack: &prowapi.SlackReporterConfig{
						JobStatesToReport: []prowapi.ProwJobState{},
						Report:            boolPtr(false),
					},
				},
			},
		},
		{
			name: "to-report",
			spec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{
					Slack: &prowapi.SlackReporterConfig{
						JobStatesToReport: []prowapi.ProwJobState{prowapi.AbortedState},
					},
				},
			},
			wantSpec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{
					Slack: &prowapi.SlackReporterConfig{
						JobStatesToReport: []prowapi.ProwJobState{prowapi.AbortedState},
						Report:            boolPtr(true),
					},
				},
			},
		},
		{
			name: "no-slack-report",
			spec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{},
			},
			wantSpec: &prowapi.ProwJobSpec{
				ReporterConfig: &prowapi.ReporterConfig{},
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			setReportDefault(tc.spec)
			if diff := cmp.Diff(tc.wantSpec, tc.spec); diff != "" {
				t.Fatalf("Spec mismatch. Want(-), got(+):\n%s", diff)
			}
		})
	}
}

func TestCreateRefs(t *testing.T) {
	pr := github.PullRequest{
		Number:  42,
		Title:   "hello world",
		HTMLURL: "https://github.example.com/kubernetes/Hello-World/pull/42",
		Head: github.PullRequestBranch{
			SHA: "123456",
			Ref: "my-great-change",
		},
		Base: github.PullRequestBranch{
			Ref: "master",
			Repo: github.Repo{
				Name:    "Hello-World",
				HTMLURL: "https://github.example.com/kubernetes/Hello-World",
				Owner: github.User{
					Login: "kubernetes",
				},
			},
		},
		User: github.User{
			Login:   "ibzib",
			HTMLURL: "https://github.example.com/ibzib",
		},
	}
	expected := prowapi.Refs{
		Org:      "kubernetes",
		Repo:     "Hello-World",
		RepoLink: "https://github.example.com/kubernetes/Hello-World",
		BaseRef:  "master",
		BaseSHA:  "abcdef",
		BaseLink: "https://github.example.com/kubernetes/Hello-World/commit/abcdef",
		Pulls: []prowapi.Pull{
			{
				Number:     42,
				Author:     "ibzib",
				SHA:        "123456",
				HeadRef:    "my-great-change",
				Title:      "hello world",
				Link:       "https://github.example.com/kubernetes/Hello-World/pull/42",
				AuthorLink: "https://github.example.com/ibzib",
				CommitLink: "https://github.example.com/kubernetes/Hello-World/pull/42/commits/123456",
			},
		},
	}
	if actual := createRefs(pr, "abcdef"); !reflect.DeepEqual(expected, actual) {
		t.Errorf("diff between expected and actual refs:%s", diff.ObjectReflectDiff(expected, actual))
	}
}

func TestSpecFromJobBase(t *testing.T) {
	permittedGroups := []int{1234, 5678}
	permittedUsers := []string{"authorized_user", "another_authorized_user"}
	permittedOrgs := []string{"kubernetes", "kubernetes-sigs"}
	rerunAuthConfig := prowapi.RerunAuthConfig{
		AllowAnyone:   false,
		GitHubTeamIDs: permittedGroups,
		GitHubUsers:   permittedUsers,
		GitHubOrgs:    permittedOrgs,
	}
	testCases := []struct {
		name    string
		jobBase config.JobBase
		verify  func(prowapi.ProwJobSpec) error
	}{
		{
			name: "Verify reporter config gets copied",
			jobBase: config.JobBase{
				ReporterConfig: &prowapi.ReporterConfig{
					Slack: &prowapi.SlackReporterConfig{
						Channel: "my-channel",
					},
				},
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				if pj.ReporterConfig == nil {
					return errors.New("Expected ReporterConfig to be non-nil")
				}
				if pj.ReporterConfig.Slack == nil {
					return errors.New("Expected ReporterConfig.Slack to be non-nil")
				}
				if pj.ReporterConfig.Slack.Channel != "my-channel" {
					return fmt.Errorf("Expected pj.ReporterConfig.Slack.Channel to be \"my-channel\", was %q",
						pj.ReporterConfig.Slack.Channel)
				}
				return nil
			},
		},
		{
			name: "Verify rerun permissions gets copied",
			jobBase: config.JobBase{
				RerunAuthConfig: &rerunAuthConfig,
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				if pj.RerunAuthConfig.AllowAnyone {
					return errors.New("Expected RerunAuthConfig.AllowAnyone to be false")
				}
				if pj.RerunAuthConfig.GitHubTeamIDs == nil {
					return errors.New("Expected RerunAuthConfig.GitHubTeamIDs to be non-nil")
				}
				if pj.RerunAuthConfig.GitHubUsers == nil {
					return errors.New("Expected RerunAuthConfig.GitHubUsers to be non-nil")
				}
				if pj.RerunAuthConfig.GitHubOrgs == nil {
					return errors.New("Expected RerunAuthConfig.GitHubOrgs to be non-nil")
				}
				return nil
			},
		},
		{
			name: "Verify hidden property gets copied",
			jobBase: config.JobBase{
				Hidden: true,
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				if !pj.Hidden {
					return errors.New("hidden property didnt get copied")
				}
				return nil
			},
		},
		{
			name: "Verify DecorateExtraRefs default true",
			jobBase: config.JobBase{
				UtilityConfig: config.UtilityConfig{
					DecorationConfig: &prowapi.DecorationConfig{
						BloblessFetch: boolPtr(true),
					},
					ExtraRefs: []prowapi.Refs{
						{
							Org:           "true-org",
							BloblessFetch: boolPtr(true),
						},
						{
							Org:           "false-org",
							BloblessFetch: boolPtr(false),
						},
						{
							Org:           "default-org",
							BloblessFetch: nil,
						},
					},
				},
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				for _, r := range pj.ExtraRefs {
					got := r.BloblessFetch
					want := boolPtr(r.Org != "false-org")
					if diff := cmp.Diff(want, got); diff != "" {
						return fmt.Errorf("ExtraRefs BloblessFetch for %s differs (-want +got)\n%s", r.Org, diff)
					}
				}
				return nil
			},
		},
		{
			name: "Verify DecorateExtraRefs default false",
			jobBase: config.JobBase{
				UtilityConfig: config.UtilityConfig{
					DecorationConfig: &prowapi.DecorationConfig{
						BloblessFetch: boolPtr(false),
					},
					ExtraRefs: []prowapi.Refs{
						{
							Org:           "true-org",
							BloblessFetch: boolPtr(true),
						},
						{
							Org:           "false-org",
							BloblessFetch: boolPtr(false),
						},
						{
							Org:           "default-org",
							BloblessFetch: nil,
						},
					},
				},
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				for _, r := range pj.ExtraRefs {
					got := r.BloblessFetch
					want := boolPtr(r.Org == "true-org")
					if diff := cmp.Diff(want, got); diff != "" {
						return fmt.Errorf("ExtraRefs BloblessFetch for %s differs (-want +got)\n%s", r.Org, diff)
					}
				}
				return nil
			},
		},
		{
			name: "Verify DecorateExtraRefs no decoration preserves existing",
			jobBase: config.JobBase{
				UtilityConfig: config.UtilityConfig{
					ExtraRefs: []prowapi.Refs{
						{
							Org:           "true-org",
							BloblessFetch: boolPtr(true),
						},
						{
							Org:           "false-org",
							BloblessFetch: boolPtr(false),
						},
						{
							Org:           "default-org",
							BloblessFetch: nil,
						},
					},
				},
			},
			verify: func(pj prowapi.ProwJobSpec) error {
				for _, r := range pj.ExtraRefs {
					got := r.BloblessFetch
					var want *bool
					switch r.Org {
					case "true-org":
						want = boolPtr(true)
					case "false-org":
						want = boolPtr(false)
					case "default-org":
						// Keep the unset default value.
						want = nil
					}
					if diff := cmp.Diff(want, got); diff != "" {
						return fmt.Errorf("ExtraRefs BloblessFetch for %s differs (-want +got)\n%s", r.Org, diff)
					}
				}
				return nil
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			pj := specFromJobBase(tc.jobBase)
			if err := tc.verify(pj); err != nil {
				t.Fatalf("Verification failed: %v", err)
			}
		})
	}
}

func TestPeriodicSpec(t *testing.T) {
	testCases := []struct {
		name   string
		config config.Periodic
		verify func(prowapi.ProwJobSpec) error
	}{
		{
			name:   "Report gets set to true",
			config: config.Periodic{},
			verify: func(p prowapi.ProwJobSpec) error {
				if !p.Report {
					return errors.New("report is not true")
				}
				return nil
			},
		},
	}

	for _, tc := range testCases {
		if err := tc.verify(PeriodicSpec(tc.config)); err != nil {
			t.Error(err)
		}
	}
}