[TEP-0076]Valide Taskrun Results in reconciler

This is part of work in TEP-0076.
This commit provides the validation of results in reconciler after we
get the emitted results. It covers the validation of mismatched types
between the results emitted and specified, the results object
properties.
Previous this commit these validations are missing and errors are
ignored.

pkg/apis/pipeline/v1beta1/result_types.go

@@ -23,6 +23,10 @@ type TaskResult struct {
 	// +optional
 	Type ResultsType `json:"type,omitempty"`
 
+	// Properties is the JSON Schema properties to support key-value pairs results.
+	// +optional
+	Properties map[string]PropertySpec `json:"properties,omitempty"`
+
 	// Description is a human-readable description of the result
 	// +optional
 	Description string `json:"description"`

pkg/apis/pipeline/v1beta1/swagger.json

@@ -2255,6 +2255,14 @@
           "type": "string",
           "default": ""
         },
+        "properties": {
+          "description": "Properties is the JSON Schema properties to support key-value pairs results.",
+          "type": "object",
+          "additionalProperties": {
+            "default": {},
+            "$ref": "#/definitions/v1beta1.PropertySpec"
+          }
+        },
         "type": {
           "description": "Type is the user-specified type of the result. The possible type is currently \"string\" and will support \"array\" in following work.",
           "type": "string"

pkg/reconciler/taskrun/taskrun.go

@@ -496,6 +496,10 @@ func (c *Reconciler) reconcile(ctx context.Context, tr *v1beta1.TaskRun, rtr *re
 		return err
 	}
 
+	if err := validateTaskRunResults(tr, rtr.TaskSpec); err != nil {
+		return err
+	}
+
 	logger.Infof("Successfully reconciled taskrun %s/%s with status: %#v", tr.Name, tr.Namespace, tr.Status.GetCondition(apis.ConditionSucceeded))
 	return nil
 }

pkg/reconciler/taskrun/validate_resources.go

@@ -180,18 +180,18 @@ func MissingKeysObjectParamNames(paramSpecs []v1beta1.ParamSpec, params []v1beta
 		}
 	}
 
-	return validateObjectKeys(neededKeys, providedKeys)
+	return findMissingKeys(neededKeys, providedKeys)
 }
 
-// validateObjectKeys checks if objects have missing keys in its provider (either taskrun value or result value)
-func validateObjectKeys(neededObjectKeys, providedObjectKeys map[string][]string) map[string][]string {
+// findMissingKeys checks if objects have missing keys in its provider (either taskrun value or result value)
+func findMissingKeys(neededKeys, providedKeys map[string][]string) map[string][]string {
 	missings := map[string][]string{}
-	for p, keys := range providedObjectKeys {
-		if _, ok := neededObjectKeys[p]; !ok {
+	for p, keys := range providedKeys {
+		if _, ok := neededKeys[p]; !ok {
 			// Ignore any missing objects - this happens when object param is provided with default
 			continue
 		}
-		missedKeys := list.DiffLeft(neededObjectKeys[p], keys)
+		missedKeys := list.DiffLeft(neededKeys[p], keys)
 		if len(missedKeys) != 0 {
 			missings[p] = missedKeys
 		}
@@ -281,3 +281,66 @@ func validateSidecarOverrides(ts *v1beta1.TaskSpec, trs *v1beta1.TaskRunSpec) er
 	}
 	return err
 }
+
+// validateResults checks the emitted results type and object properties against the ones defined in spec.
+func validateTaskRunResults(tr *v1beta1.TaskRun, resolvedTaskSpec *v1beta1.TaskSpec) error {
+	specResults := []v1beta1.TaskResult{}
+	if tr.Spec.TaskSpec != nil {
+		specResults = append(specResults, tr.Spec.TaskSpec.Results...)
+	}
+
+	if resolvedTaskSpec != nil {
+		specResults = append(specResults, resolvedTaskSpec.Results...)
+	}
+
+	// When get the results, check if the type of result is the expected one
+	if missmatchedTypes := mismatchedTypesResults(tr, specResults); len(missmatchedTypes) != 0 {
+		return fmt.Errorf("missmatched Types for these results, %v", missmatchedTypes)
+	}
+
+	// When get the results, for object value need to check if they have missing keys.
+	if missingKeysObjectNames := missingKeysofObjectResults(tr, specResults); len(missingKeysObjectNames) != 0 {
+		return fmt.Errorf("missing keys for these results which are required in TaskResult's properties %v", missingKeysObjectNames)
+	}
+	return nil
+}
+
+// mismatchedTypesResults checks and returns all the mismatched types of emitted results against specified results.
+func mismatchedTypesResults(tr *v1beta1.TaskRun, specResults []v1beta1.TaskResult) map[string][]string {
+	neededTypes := make(map[string][]string)
+	providedTypes := make(map[string][]string)
+	// collect needed keys for object results
+	for _, r := range specResults {
+		neededTypes[r.Name] = append(neededTypes[r.Name], string(r.Type))
+	}
+
+	// collect provided keys for object results
+	for _, trr := range tr.Status.TaskRunResults {
+		providedTypes[trr.Name] = append(providedTypes[trr.Name], string(trr.Type))
+	}
+	return findMissingKeys(neededTypes, providedTypes)
+}
+
+// missingKeysofObjectResults checks and returns the missing keys of object results.
+func missingKeysofObjectResults(tr *v1beta1.TaskRun, specResults []v1beta1.TaskResult) map[string][]string {
+	neededKeys := make(map[string][]string)
+	providedKeys := make(map[string][]string)
+	// collect needed keys for object results
+	for _, r := range specResults {
+		if string(r.Type) == string(v1beta1.ParamTypeObject) {
+			for key := range r.Properties {
+				neededKeys[r.Name] = append(neededKeys[r.Name], key)
+			}
+		}
+	}
+
+	// collect provided keys for object results
+	for _, trr := range tr.Status.TaskRunResults {
+		if trr.Value.Type == v1beta1.ParamTypeObject {
+			for key := range trr.Value.ObjectVal {
+				providedKeys[trr.Name] = append(providedKeys[trr.Name], key)
+			}
+		}
+	}
+	return findMissingKeys(neededKeys, providedKeys)
+}