Skip to content

Commit

Permalink
refactore taskRunStatus and runStatus
Browse files Browse the repository at this point in the history 
pipelinerun_test.go has these three tests:

* TestUpdateTaskRunsState
* TestUpdateRunsState
* TestUpdateTaskRunStateWithConditionChecks

These tests are validating func (state PipelineRunState) GetTaskRunsStatus()
which is part of the pipelinerunstate.go. Moving these tests to
pipelinerunstate_test.go after replacing task/run/pipeline/pipelinerun
initializations with YAMLParser.
  • Loading branch information
@pritidesai @tekton-robot
pritidesai authored and tekton-robot committed Mar 8, 2022
1 parent 14eb3d8 commit 38d98f0
Show file tree
Hide file tree
Showing 3 changed files with 351 additions and 366 deletions.
367 changes: 1 addition & 366 deletions pkg/reconciler/pipelinerun/pipelinerun_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,6 @@ import (
resourcev1alpha1 "github.com/tektoncd/pipeline/pkg/apis/resource/v1alpha1"
"github.com/tektoncd/pipeline/pkg/reconciler/events/cloudevent"
"github.com/tektoncd/pipeline/pkg/reconciler/pipelinerun/resources"
taskrunresources "github.com/tektoncd/pipeline/pkg/reconciler/taskrun/resources"
ttesting "github.com/tektoncd/pipeline/pkg/reconciler/testing"
"github.com/tektoncd/pipeline/pkg/reconciler/volumeclaim"
"github.com/tektoncd/pipeline/test"
Expand Down Expand Up @@ -71,8 +70,7 @@ import (
)

var (
ignoreLastTransitionTime = cmpopts.IgnoreFields(apis.Condition{}, "LastTransitionTime.Inner.Time")
images = pipeline.Images{
images = pipeline.Images{
EntrypointImage: "override-with-entrypoint:latest",
NopImage: "override-with-nop:latest",
GitImage: "override-with-git:latest",
Expand Down Expand Up @@ -197,12 +195,6 @@ func initializePipelineRunControllerAssets(t *testing.T, d test.Data, opts pipel
}, cancel
}

// conditionCheckFromTaskRun converts takes a pointer to a TaskRun and wraps it into a ConditionCheck
func conditionCheckFromTaskRun(tr *v1beta1.TaskRun) *v1beta1.ConditionCheck {
cc := v1beta1.ConditionCheck(*tr)
return &cc
}

// getTaskRunCreations will look through a set of actions to find all task run creation actions and return the set of
// them. It will fatal the test if none are found.
func getTaskRunCreations(t *testing.T, actions []ktesting.Action) []*v1beta1.TaskRun {
Expand Down Expand Up @@ -1523,363 +1515,6 @@ func TestReconcile_InvalidPipelineRunNames(t *testing.T) {
}
}

func TestUpdateTaskRunsState(t *testing.T) {
// TestUpdateTaskRunsState runs "getTaskRunsStatus" and verifies how it updates a PipelineRun status
// from a TaskRun associated to the PipelineRun
pr := &v1beta1.PipelineRun{
ObjectMeta: baseObjectMeta("test-pipeline-run", "foo"),
Spec: v1beta1.PipelineRunSpec{
PipelineRef: &v1beta1.PipelineRef{Name: "test-pipeline"},
},
}
pipelineTask := v1beta1.PipelineTask{
Name: "unit-test-1",
WhenExpressions: []v1beta1.WhenExpression{{
Input: "foo",
Operator: selection.In,
Values: []string{"foo", "bar"},
}},
TaskRef: &v1beta1.TaskRef{Name: "unit-test-task"},
}
task := &v1beta1.Task{
ObjectMeta: baseObjectMeta("unit-test-task", "foo"),
Spec: v1beta1.TaskSpec{
Resources: &v1beta1.TaskResources{
Inputs: []v1beta1.TaskResource{{
ResourceDeclaration: v1beta1.ResourceDeclaration{
Name: "workspace",
Type: resourcev1alpha1.PipelineResourceTypeGit,
},
}},
},
},
}
taskrun := &v1beta1.TaskRun{
ObjectMeta: baseObjectMeta("test-pipeline-run-success-unit-test-1", "foo"),
Spec: v1beta1.TaskRunSpec{
TaskRef: &v1beta1.TaskRef{Name: "unit-test-task"},
ServiceAccountName: "test-sa",
Resources: &v1beta1.TaskRunResources{},
Timeout: &metav1.Duration{Duration: config.DefaultTimeoutMinutes * time.Minute},
},
Status: v1beta1.TaskRunStatus{
Status: duckv1beta1.Status{
Conditions: duckv1beta1.Conditions{
apis.Condition{
Type: apis.ConditionSucceeded,
},
},
},
TaskRunStatusFields: v1beta1.TaskRunStatusFields{
Steps: []v1beta1.StepState{{
ContainerState: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: int32(0)},
},
}},
},
},
}

expectedTaskRunsStatus := make(map[string]*v1beta1.PipelineRunTaskRunStatus)
expectedTaskRunsStatus["test-pipeline-run-success-unit-test-1"] = &v1beta1.PipelineRunTaskRunStatus{
PipelineTaskName: "unit-test-1",
Status: &v1beta1.TaskRunStatus{
TaskRunStatusFields: v1beta1.TaskRunStatusFields{
Steps: []v1beta1.StepState{{
ContainerState: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: 0},
},
}}},
Status: duckv1beta1.Status{
Conditions: []apis.Condition{{Type: apis.ConditionSucceeded}},
},
},
WhenExpressions: []v1beta1.WhenExpression{{
Input: "foo",
Operator: selection.In,
Values: []string{"foo", "bar"},
}},
}
expectedPipelineRunStatus := v1beta1.PipelineRunStatus{
PipelineRunStatusFields: v1beta1.PipelineRunStatusFields{
TaskRuns: expectedTaskRunsStatus,
},
}

state := resources.PipelineRunState{{
PipelineTask: &pipelineTask,
TaskRunName: "test-pipeline-run-success-unit-test-1",
TaskRun: taskrun,
ResolvedTaskResources: &taskrunresources.ResolvedTaskResources{
TaskSpec: &task.Spec,
},
}}
pr.Status.InitializeConditions(testClock)
status := state.GetTaskRunsStatus(pr)
if d := cmp.Diff(expectedPipelineRunStatus.TaskRuns, status); d != "" {
t.Fatalf("Expected PipelineRun status to match TaskRun(s) status, but got a mismatch: %s", diff.PrintWantGot(d))
}

}

func TestUpdateRunsState(t *testing.T) {
// TestUpdateRunsState runs "getRunsStatus" and verifies how it updates a PipelineRun status
// from a Run associated to the PipelineRun
pr := &v1beta1.PipelineRun{
ObjectMeta: baseObjectMeta("test-pipeline-run", "foo"),
Spec: v1beta1.PipelineRunSpec{
PipelineRef: &v1beta1.PipelineRef{Name: "test-pipeline"},
},
}
pipelineTask := v1beta1.PipelineTask{
Name: "unit-test-1",
WhenExpressions: []v1beta1.WhenExpression{{
Input: "foo",
Operator: selection.In,
Values: []string{"foo", "bar"},
}},
TaskRef: &v1beta1.TaskRef{
APIVersion: "example.dev/v0",
Kind: "Example",
Name: "unit-test-run",
},
}
run := v1alpha1.Run{
TypeMeta: metav1.TypeMeta{
APIVersion: "example.dev/v0",
Kind: "Example",
},
ObjectMeta: metav1.ObjectMeta{
Name: "unit-test-run",
Namespace: "foo",
},
Spec: v1alpha1.RunSpec{},
Status: v1alpha1.RunStatus{
Status: duckv1.Status{
Conditions: duckv1.Conditions{{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionTrue,
}},
},
},
}
expectedRunsStatus := make(map[string]*v1beta1.PipelineRunRunStatus)
expectedRunsStatus["test-pipeline-run-success-unit-test-1"] = &v1beta1.PipelineRunRunStatus{
PipelineTaskName: "unit-test-1",
Status: &v1alpha1.RunStatus{
Status: duckv1.Status{
Conditions: duckv1.Conditions{{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionTrue,
}},
},
},
WhenExpressions: []v1beta1.WhenExpression{{
Input: "foo",
Operator: selection.In,
Values: []string{"foo", "bar"},
}},
}
expectedPipelineRunStatus := v1beta1.PipelineRunStatus{
PipelineRunStatusFields: v1beta1.PipelineRunStatusFields{
Runs: expectedRunsStatus,
},
}

state := resources.PipelineRunState{{
PipelineTask: &pipelineTask,
CustomTask: true,
RunName: "test-pipeline-run-success-unit-test-1",
Run: &run,
}}
pr.Status.InitializeConditions(testClock)
status := state.GetRunsStatus(pr)
if d := cmp.Diff(expectedPipelineRunStatus.Runs, status); d != "" {
t.Fatalf("Expected PipelineRun status to match Run(s) status, but got a mismatch: %s", diff.PrintWantGot(d))
}

}

func TestUpdateTaskRunStateWithConditionChecks(t *testing.T) {
// TestUpdateTaskRunsState runs "getTaskRunsStatus" and verifies how it updates a PipelineRun status
// from several different TaskRun with Conditions associated to the PipelineRun
taskrunName := "task-run"
successConditionCheckName := "success-condition"
failingConditionCheckName := "fail-condition"

successCondition := &v1alpha1.Condition{
ObjectMeta: metav1.ObjectMeta{
Name: "cond-1",
Namespace: "foo",
},
}
failingCondition := &v1alpha1.Condition{
ObjectMeta: metav1.ObjectMeta{
Name: "cond-2",
Namespace: "foo",
},
}

pipelineTask := v1beta1.PipelineTask{
TaskRef: &v1beta1.TaskRef{Name: "unit-test-task"},
Conditions: []v1beta1.PipelineTaskCondition{{
ConditionRef: successCondition.Name,
}, {
ConditionRef: failingCondition.Name,
}},
}

successConditionCheck := conditionCheckFromTaskRun(&v1beta1.TaskRun{
ObjectMeta: baseObjectMeta(successConditionCheckName, "foo"),
Status: v1beta1.TaskRunStatus{
Status: duckv1beta1.Status{
Conditions: duckv1beta1.Conditions{
apis.Condition{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionTrue,
},
},
},
TaskRunStatusFields: v1beta1.TaskRunStatusFields{
Steps: []v1beta1.StepState{{
ContainerState: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: int32(0)},
},
}},
},
},
})
failingConditionCheck := conditionCheckFromTaskRun(&v1beta1.TaskRun{
ObjectMeta: baseObjectMeta(failingConditionCheckName, "foo"),
Status: v1beta1.TaskRunStatus{
Status: duckv1beta1.Status{
Conditions: duckv1beta1.Conditions{
apis.Condition{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionFalse,
},
},
},
TaskRunStatusFields: v1beta1.TaskRunStatusFields{
Steps: []v1beta1.StepState{{
ContainerState: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: int32(127)},
},
}},
},
},
})

successrcc := resources.ResolvedConditionCheck{
ConditionRegisterName: successCondition.Name + "-0",
ConditionCheckName: successConditionCheckName,
Condition: successCondition,
ConditionCheck: successConditionCheck,
}
failingrcc := resources.ResolvedConditionCheck{
ConditionRegisterName: failingCondition.Name + "-0",
ConditionCheckName: failingConditionCheckName,
Condition: failingCondition,
ConditionCheck: failingConditionCheck,
}

successConditionCheckStatus := &v1beta1.PipelineRunConditionCheckStatus{
ConditionName: successrcc.ConditionRegisterName,
Status: &v1beta1.ConditionCheckStatus{
ConditionCheckStatusFields: v1beta1.ConditionCheckStatusFields{
Check: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: 0},
},
},
Status: duckv1beta1.Status{
Conditions: []apis.Condition{{Type: apis.ConditionSucceeded, Status: corev1.ConditionTrue}},
},
},
}
failingConditionCheckStatus := &v1beta1.PipelineRunConditionCheckStatus{
ConditionName: failingrcc.ConditionRegisterName,
Status: &v1beta1.ConditionCheckStatus{
ConditionCheckStatusFields: v1beta1.ConditionCheckStatusFields{
Check: corev1.ContainerState{
Terminated: &corev1.ContainerStateTerminated{ExitCode: 127},
},
},
Status: duckv1beta1.Status{
Conditions: []apis.Condition{{Type: apis.ConditionSucceeded, Status: corev1.ConditionFalse}},
},
},
}

failedTaskRunStatus := v1beta1.TaskRunStatus{
Status: duckv1beta1.Status{
Conditions: []apis.Condition{{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionFalse,
Reason: resources.ReasonConditionCheckFailed,
Message: fmt.Sprintf("ConditionChecks failed for Task %s in PipelineRun %s", taskrunName, "test-pipeline-run"),
}},
},
}

tcs := []struct {
name string
rcc resources.TaskConditionCheckState
expectedStatus v1beta1.PipelineRunTaskRunStatus
}{{
name: "success-condition-checks",
rcc: resources.TaskConditionCheckState{&successrcc},
expectedStatus: v1beta1.PipelineRunTaskRunStatus{
ConditionChecks: map[string]*v1beta1.PipelineRunConditionCheckStatus{
successrcc.ConditionCheck.Name: successConditionCheckStatus,
},
},
}, {
name: "failing-condition-checks",
rcc: resources.TaskConditionCheckState{&failingrcc},
expectedStatus: v1beta1.PipelineRunTaskRunStatus{
Status: &failedTaskRunStatus,
ConditionChecks: map[string]*v1beta1.PipelineRunConditionCheckStatus{
failingrcc.ConditionCheck.Name: failingConditionCheckStatus,
},
},
}, {
name: "multiple-condition-checks",
rcc: resources.TaskConditionCheckState{&successrcc, &failingrcc},
expectedStatus: v1beta1.PipelineRunTaskRunStatus{
Status: &failedTaskRunStatus,
ConditionChecks: map[string]*v1beta1.PipelineRunConditionCheckStatus{
successrcc.ConditionCheck.Name: successConditionCheckStatus,
failingrcc.ConditionCheck.Name: failingConditionCheckStatus,
},
},
}}

for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
pr := &v1beta1.PipelineRun{
ObjectMeta: baseObjectMeta("test-pipeline-run", "foo"),
Spec: v1beta1.PipelineRunSpec{
PipelineRef: &v1beta1.PipelineRef{Name: "test-pipeline"},
},
}

state := resources.PipelineRunState{{
PipelineTask: &pipelineTask,
TaskRunName: taskrunName,
ResolvedConditionChecks: tc.rcc,
}}
pr.Status.InitializeConditions(testClock)
status := state.GetTaskRunsStatus(pr)
expected := map[string]*v1beta1.PipelineRunTaskRunStatus{
taskrunName: &tc.expectedStatus,
}
if d := cmp.Diff(status, expected, ignoreLastTransitionTime); d != "" {
t.Fatalf("Did not get expected status for %s %s", tc.name, diff.PrintWantGot(d))
}
})
}
}

func TestReconcileOnCompletedPipelineRun(t *testing.T) {
// TestReconcileOnCompletedPipelineRun runs "Reconcile" on a PipelineRun that already reached completion
// and that does not have the latest status from TaskRuns yet. It checks that the TaskRun status is updated
Expand Down
Loading

0 comments on commit 38d98f0

Please sign in to comment.