Fix existing unit tests

pkg/reconciler/v1alpha1/pipelinerun/pipelinerun.go

@@ -309,7 +309,6 @@ func (c *Reconciler) reconcile(ctx context.Context, pr *v1alpha1.PipelineRun) er
 			return c.conditionLister.Conditions(pr.Namespace).Get(name)
 		},
 		p.Spec.Tasks, providedResources,
-		c.Logger,
 	)
 	if err != nil {
 		// This Run has failed, so we need to mark it as failed and stop reconciling it
@@ -436,11 +435,13 @@ func updateTaskRunsStatus(pr *v1alpha1.PipelineRun, pipelineState []*resources.R
 			prtrs = &v1alpha1.PipelineRunTaskRunStatus{
 				PipelineTaskName: rprt.PipelineTask.Name,
 			}
-		} else {
+		}
+
+		if rprt.TaskRun != nil  {
 			prtrs.Status = &rprt.TaskRun.Status
 		}
 
-		if rprt.ResolvedConditionChecks != nil {
+		if len(rprt.ResolvedConditionChecks) > 0 {
 			cStatus := make(map[string]*v1alpha1.PipelineRunConditionCheckStatus)
 			for _, c := range rprt.ResolvedConditionChecks {
 				cStatus[c.ConditionCheckName] = &v1alpha1.PipelineRunConditionCheckStatus{

pkg/reconciler/v1alpha1/pipelinerun/pipelinerun_test.go

@@ -71,6 +71,7 @@ func getPipelineRunController(t *testing.T, d test.Data, recorder record.EventRe
 			i.ClusterTask,
 			i.TaskRun,
 			i.PipelineResource,
+			i.Condition,
 			th,
 		),
 		Logs:      logs,

pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution.go

@@ -220,7 +220,6 @@ func ResolvePipelineRun(
 	getCondition GetCondition,
 	tasks []v1alpha1.PipelineTask,
 	providedResources map[string]v1alpha1.PipelineResourceRef,
-	logger *zap.SugaredLogger,
 ) (PipelineRunState, error) {
 
 	state := []*ResolvedPipelineRunTask{}

pkg/reconciler/v1alpha1/pipelinerun/resources/pipelinerunresolution_test.go

@@ -898,8 +898,9 @@ func TestResolvePipelineRun(t *testing.T) {
 	getTaskRun := func(name string) (*v1alpha1.TaskRun, error) { return nil, nil }
 	getClusterTask := func(name string) (v1alpha1.TaskInterface, error) { return nil, nil }
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) { return r, nil }
+	getCondition := func(name string)(*v1alpha1.Condition, error) { return nil, nil}
 
-	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, p.Spec.Tasks, providedResources)
+	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, p.Spec.Tasks, providedResources)
 	if err != nil {
 		t.Fatalf("Error getting tasks for fake pipeline %s: %s", p.ObjectMeta.Name, err)
 	}
@@ -965,12 +966,13 @@ func TestResolvePipelineRun_PipelineTaskHasNoResources(t *testing.T) {
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) {
 		return nil, xerrors.New("should not get called")
 	}
+	getCondition := func(name string) (*v1alpha1.Condition, error) {return nil, nil}
 	pr := v1alpha1.PipelineRun{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "pipelinerun",
 		},
 	}
-	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, pts, providedResources)
+	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, pts, providedResources)
 	if err != nil {
 		t.Fatalf("Did not expect error when resolving PipelineRun without Resources: %v", err)
 	}
@@ -1012,12 +1014,15 @@ func TestResolvePipelineRun_TaskDoesntExist(t *testing.T) {
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) {
 		return nil, xerrors.New("should not get called")
 	}
+	getCondition := func(name string) (*v1alpha1.Condition, error) {
+		return nil, nil
+	}
 	pr := v1alpha1.PipelineRun{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "pipelinerun",
 		},
 	}
-	_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, pts, providedResources)
+	_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, pts, providedResources)
 	switch err := err.(type) {
 	case nil:
 		t.Fatalf("Expected error getting non-existent Tasks for Pipeline %s but got none", p.Name)
@@ -1058,6 +1063,9 @@ func TestResolvePipelineRun_ResourceBindingsDontExist(t *testing.T) {
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) {
 		return nil, xerrors.New("shouldnt be called")
 	}
+	getCondition := func(name string) (*v1alpha1.Condition, error) {
+		return nil, nil
+	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1066,7 +1074,7 @@ func TestResolvePipelineRun_ResourceBindingsDontExist(t *testing.T) {
 					Name: "pipelinerun",
 				},
 			}
-			_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, tt.p.Spec.Tasks, providedResources)
+			_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, tt.p.Spec.Tasks, providedResources)
 			if err == nil {
 				t.Fatalf("Expected error when bindings are in incorrect state for Pipeline %s but got none", p.Name)
 			}
@@ -1108,6 +1116,9 @@ func TestResolvePipelineRun_ResourcesDontExist(t *testing.T) {
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) {
 		return nil, errors.NewNotFound(v1alpha1.Resource("pipelineresource"), name)
 	}
+	getCondition := func(name string) (*v1alpha1.Condition, error) {
+		return nil, nil
+	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -1116,7 +1127,7 @@ func TestResolvePipelineRun_ResourcesDontExist(t *testing.T) {
 					Name: "pipelinerun",
 				},
 			}
-			_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, tt.p.Spec.Tasks, providedResources)
+			_, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, tt.p.Spec.Tasks, providedResources)
 			switch err := err.(type) {
 			case nil:
 				t.Fatalf("Expected error getting non-existent Resources for Pipeline %s but got none", p.Name)
@@ -1348,8 +1359,8 @@ func TestResolvePipelineRun_withExistingTaskRuns(t *testing.T) {
 	getClusterTask := func(name string) (v1alpha1.TaskInterface, error) { return nil, nil }
 	getTaskRun := func(name string) (*v1alpha1.TaskRun, error) { return nil, nil }
 	getResource := func(name string) (*v1alpha1.PipelineResource, error) { return r, nil }
-
-	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, p.Spec.Tasks, providedResources)
+	getCondition := func(name string)(*v1alpha1.Condition, error) {return nil, nil}
+	pipelineState, err := ResolvePipelineRun(pr, getTask, getTaskRun, getClusterTask, getResource, getCondition, p.Spec.Tasks, providedResources)
 	if err != nil {
 		t.Fatalf("Error getting tasks for fake pipeline %s: %s", p.ObjectMeta.Name, err)
 	}

test/controller.go

@@ -47,6 +47,7 @@ type Data struct {
 	Tasks             []*v1alpha1.Task
 	ClusterTasks      []*v1alpha1.ClusterTask
 	PipelineResources []*v1alpha1.PipelineResource
+	Conditions        []*v1alpha1.Condition
 	Pods              []*corev1.Pod
 	Namespaces        []*corev1.Namespace
 }
@@ -65,6 +66,7 @@ type Informers struct {
 	Task             informersv1alpha1.TaskInformer
 	ClusterTask      informersv1alpha1.ClusterTaskInformer
 	PipelineResource informersv1alpha1.PipelineResourceInformer
+	Condition				 informersv1alpha1.ConditionInformer
 	Pod              coreinformers.PodInformer
 }
 
@@ -120,6 +122,7 @@ func SeedTestData(t *testing.T, d Data) (Clients, Informers) {
 		Task:             sharedInformer.Tekton().V1alpha1().Tasks(),
 		ClusterTask:      sharedInformer.Tekton().V1alpha1().ClusterTasks(),
 		PipelineResource: sharedInformer.Tekton().V1alpha1().PipelineResources(),
+		Condition:				sharedInformer.Tekton().V1alpha1().Conditions(),
 		Pod:              kubeInformer.Core().V1().Pods(),
 	}
 
@@ -153,6 +156,11 @@ func SeedTestData(t *testing.T, d Data) (Clients, Informers) {
 			t.Fatal(err)
 		}
 	}
+	for _, r := range d.Conditions {
+		if err := i.Condition.Informer().GetIndexer().Add(r); err != nil {
+			t.Fatal(err)
+		}
+	}
 	for _, p := range d.Pods {
 		if err := i.Pod.Informer().GetIndexer().Add(p); err != nil {
 			t.Fatal(err)