Implement ReadMany for CheckRequiredFieldsMissingFromShape (#155)

Issue #, if available: [#890](aws-controllers-k8s/community#890)

Description of changes:
* Adds checkRequiredFieldsMissingFromShapeReadMany to `check.go` to handle ReadMany operations without a corresponding ReadOne. 
* The new method will **require resource identifier field** should there exist an *identifier* or *identifierS* field in the ReadMany operation. 
  * Eventually `newListRequestPayload` will use this identifier field to populate its request in order to guarantee the ReadMany operation returns the desired resource.
  * ex: DescribeVpcs has a VpcIds field. Therefore, Vpc shape should require VpcId, which is part of its status field.
* Updated tests and templates

Testing:
* `make test` ✅
* `make build-controller`  ✅

```
func (rm *resourceManager) sdkFind(
	ctx context.Context,
	r *resource,
) (latest *resource, err error) {
	rlog := ackrtlog.FromContext(ctx)
	exit := rlog.Trace("rm.sdkFind")
	defer exit(err)
	// If any required fields in the input shape are missing, AWS resource is
	// not created yet. Return NotFound here to indicate to callers that the
	// resource isn't yet created.
	if rm.requiredFieldsMissingFromReadManyInput(r) {
		return nil, ackerr.NotFound
	}

	input, err := rm.newListRequestPayload(r)

...


// requiredFieldsMissingFromReadManyInput returns true if there are any fields
// for the ReadMany Input shape that are required but not present in the
// resource's Spec or Status
func (rm *resourceManager) requiredFieldsMissingFromReadManyInput(
	r *resource,
) bool {
	return r.ko.Status.VPCID == nil

}
```

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

Author: brycahta

pkg/generate/ack/controller.go

@@ -110,6 +110,9 @@ var (
 		"GoCodeRequiredFieldsMissingFromReadOneInput": func(r *ackmodel.CRD, koVarName string, indentLevel int) string {
 			return code.CheckRequiredFieldsMissingFromShape(r, ackmodel.OpTypeGet, koVarName, indentLevel)
 		},
+		"GoCodeRequiredFieldsMissingFromReadManyInput": func(r *ackmodel.CRD, koVarName string, indentLevel int) string {
+			return code.CheckRequiredFieldsMissingFromShape(r, ackmodel.OpTypeList, koVarName, indentLevel)
+		},
 		"GoCodeRequiredFieldsMissingFromGetAttributesInput": func(r *ackmodel.CRD, koVarName string, indentLevel int) string {
 			return code.CheckRequiredFieldsMissingFromShape(r, ackmodel.OpTypeGetAttributes, koVarName, indentLevel)
 		},

pkg/generate/code/check.go

@@ -18,6 +18,7 @@ import (
 	"strings"
 
 	awssdkmodel "github.com/aws/aws-sdk-go/private/model/api"
+	"github.com/gertd/go-pluralize"
 
 	ackgenconfig "github.com/aws-controllers-k8s/code-generator/pkg/generate/config"
 	"github.com/aws-controllers-k8s/code-generator/pkg/model"
@@ -74,6 +75,10 @@ func CheckRequiredFieldsMissingFromShape(
 	switch opType {
 	case model.OpTypeGet:
 		op = r.Ops.ReadOne
+	case model.OpTypeList:
+		op = r.Ops.ReadMany
+		return checkRequiredFieldsMissingFromShapeReadMany(
+			r, koVarName, indentLevel, op, op.InputRef.Shape)
 	case model.OpTypeGetAttributes:
 		op = r.Ops.GetAttributes
 	case model.OpTypeSetAttributes:
@@ -152,6 +157,74 @@ func checkRequiredFieldsMissingFromShape(
 	return fmt.Sprintf("%sreturn %s\n", indent, missingCondition)
 }
 
+// checkRequiredFieldsMissingFromShapeReadMany is a special-case handling
+// of those APIs where there is no ReadOne operation and instead the only way to
+// grab information for a single object is to call the ReadMany/List operation
+// with one of more filtering fields-- specifically identifier(s). This method
+// locates an identifier field in the shape that can be populated with an
+// identifier value from the CR.
+//
+//
+// As an example, DescribeVpcs EC2 API call doesn't have a ReadOne operation or
+// required fields. However, the input shape has a VpcIds field which can be
+// populated using a VpcId, a field in the VPC CR's Status. Therefore, require
+// the VpcId field to be present to ensure the returned array from the API call
+// consists only of the desired Vpc.
+//
+// Sample Output:
+//
+// return r.ko.Status.VPCID == nil
+func checkRequiredFieldsMissingFromShapeReadMany(
+	r *model.CRD,
+	koVarName string,
+	indentLevel int,
+	op *awssdkmodel.Operation,
+	shape *awssdkmodel.Shape,
+) string {
+	indent := strings.Repeat("\t", indentLevel)
+	result := fmt.Sprintf("%sreturn false", indent)
+
+	shapeIdentifiers := FindIdentifiersInShape(r, shape)
+	crIdentifiers := FindIdentifiersInCRD(r)
+	if len(shapeIdentifiers) == 0 || len(crIdentifiers) == 0 {
+		return result
+	}
+
+	pluralize := pluralize.NewClient()
+	reqIdentifier := ""
+	for _, si := range shapeIdentifiers {
+		for _, ci := range crIdentifiers {
+			if strings.EqualFold(pluralize.Singular(si),
+				pluralize.Singular(ci)) {
+				// The CRD identifiers being used for comparison reflect the
+				// *original* field names in the API model shape.
+				// Field renames are handled below in the call to
+				// getSanitizedMemberPath.
+				if reqIdentifier == "" {
+					reqIdentifier = ci
+				} else {
+					// If there are multiple identifiers, then prioritize the
+					// 'Id' identifier. Checking 'Id' to determine resource
+					// creation should be safe as the field is usually
+					// present in CR.Status.
+					if !strings.HasSuffix(reqIdentifier, "Id") ||
+						!strings.HasSuffix(reqIdentifier, "Ids") {
+						reqIdentifier = ci
+					}
+				}
+			}
+		}
+	}
+
+	resVarPath, err := getSanitizedMemberPath(reqIdentifier, r, op, koVarName)
+	if err != nil {
+		return result
+	}
+
+	result = fmt.Sprintf("%s == nil", resVarPath)
+	return fmt.Sprintf("%sreturn %s\n", indent, result)
+}
+
 // getSanitizedMemberPath takes a shape member field, checks for renames, checks
 // for existence in Spec and Status, then constructs and returns the var path.
 // Returns error if memberName is not present in either Spec or Status.

pkg/generate/code/check_test.go

@@ -115,3 +115,24 @@ func TestCheckRequiredFields_RenamedSpecField(t *testing.T) {
 		strings.TrimSpace(gotCode),
 	)
 }
+
+func TestCheckRequiredFields_StatusField_ReadMany(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	g := testutil.NewModelForService(t, "ec2")
+
+	crd := testutil.GetCRDByName(t, g, "Vpc")
+	require.NotNil(crd)
+
+	expRequiredFieldsCode := `
+	return r.ko.Status.VPCID == nil
+`
+	gotCode := code.CheckRequiredFieldsMissingFromShape(
+		crd, model.OpTypeList, "r.ko", 1,
+	)
+	assert.Equal(
+		strings.TrimSpace(expRequiredFieldsCode),
+		strings.TrimSpace(gotCode),
+	)
+}

pkg/generate/code/common.go

@@ -21,22 +21,24 @@ import (
 )
 
 // FindIdentifiersInShape returns the identifier fields of a given shape which
-// can be singular or plural. Errors iff multiple identifier fields detected
-// in the shape.
+// can be singular or plural.
 func FindIdentifiersInShape(
 	r *model.CRD,
 	shape *awssdkmodel.Shape) []string {
+	var identifiers []string
+	if r == nil || shape == nil {
+		return identifiers
+	}
 	identifierLookup := []string{
 		"Id",
 		"Ids",
+		r.Names.Original + "Id",
+		r.Names.Original + "Ids",
 		"Name",
 		"Names",
 		r.Names.Original + "Name",
 		r.Names.Original + "Names",
-		r.Names.Original + "Id",
-		r.Names.Original + "Ids",
 	}
-	var identifiers []string
 
 	for _, memberName := range shape.MemberNames() {
 		if util.InStrings(memberName, identifierLookup) {
@@ -47,22 +49,25 @@ func FindIdentifiersInShape(
 	return identifiers
 }
 
-// FindIdentifiersInCRD returns the identifier field of a given CRD which
-// can be singular or plural. Errors iff multiple identifier fields detected
-// in the CRD.
+// FindIdentifiersInCRD returns the identifier fields of a given CRD which
+// can be singular or plural. Note, these fields will be the *original* field
+// names from the API model shape, not renamed field names.
 func FindIdentifiersInCRD(
 	r *model.CRD) []string {
+	var identifiers []string
+	if r == nil {
+		return identifiers
+	}
 	identifierLookup := []string{
 		"Id",
 		"Ids",
+		r.Names.Original + "Id",
+		r.Names.Original + "Ids",
 		"Name",
 		"Names",
 		r.Names.Original + "Name",
 		r.Names.Original + "Names",
-		r.Names.Original + "Id",
-		r.Names.Original + "Ids",
 	}
-	var identifiers []string
 
 	for _, id := range identifierLookup {
 		_, found := r.SpecFields[id]

templates/pkg/resource/sdk_find_read_many.go.tpl

@@ -10,6 +10,13 @@ func (rm *resourceManager) sdkFind(
 {{- if $hookCode := Hook .CRD "sdk_read_many_pre_build_request" }}
 {{ $hookCode }}
 {{- end }}
+	// If any required fields in the input shape are missing, AWS resource is
+	// not created yet. Return NotFound here to indicate to callers that the
+	// resource isn't yet created.
+	if rm.requiredFieldsMissingFromReadManyInput(r) {
+		return nil, ackerr.NotFound
+	}
+
 	input, err := rm.newListRequestPayload(r)
 	if err != nil {
 		return nil, err
@@ -51,6 +58,19 @@ func (rm *resourceManager) sdkFind(
 	return &resource{ko}, nil
 }
 
+// requiredFieldsMissingFromReadManyInput returns true if there are any fields
+// for the ReadMany Input shape that are required but not present in the
+// resource's Spec or Status
+func (rm *resourceManager) requiredFieldsMissingFromReadManyInput(
+	r *resource,
+) bool {
+{{- if $customCheckMethod := .CRD.GetCustomCheckRequiredFieldsMissingMethod .CRD.Ops.ReadMany }}
+    return rm.{{ $customCheckMethod }}(r)
+{{- else }}
+{{ GoCodeRequiredFieldsMissingFromReadManyInput .CRD "r.ko" 1 }}
+{{- end }}
+}
+
 // newListRequestPayload returns SDK-specific struct for the HTTP request
 // payload of the List API call for the resource
 func (rm *resourceManager) newListRequestPayload(