Handler hostcatalogs sdk (#103)

* Created host catalog service.

* Fixing uri generation for create.

* Use newly submitted static host catalog.

* Copying over tests from projects.

* Fix UpdateHostCatalogRequest merging proto.

* Properly use static host catalog prefixes in tests.

* Correct test to verify the expected uri and id prefix is set.

* Add test for unsetting descriptions.

* Correct bad spelling in comment.

* Tweaking variable names.

* Adding Stringer to the catalog type and setting the type on the response.

* Setting up the catalogType to contain more info regarding its type.

* Validate the type field in requests.

* Remove unused method.

* Comment describing invariants around types.

* Wiring in the repo into the static catalog handler.

* feature:  Add CRUD operations for host catalogs to the go api library.

* Updated comments to the exported methods.

* fix: return the result of handlers.NotFoundError instead of just calling it.

* Fixing typos referencing just hosts instead of host catlogs.

* Update NewService returns an error and a non pointer type.

* Pull "org_id" and "project_id" into constants and the validation of them into the ValidateAncestors.

* Check errors for all Register*HandlerServer calls.

* fix: Remove left over reference that could cause a panic.

* fix: Changing "x := []string{}" to "var x []string"

* fix: Log errors in test cleanup.

* Changing the code to use google.golang.org/protobuf instead of the older github based protobuf library.

* Changing all t.Fatal checks to require.NoError calls.

* Changing unrecognized prefixes to Invalid Argument instead of Not Found.

* fix: toDbUpdateMask now returns error if it was unable to find any valid paths.

* Define CreatedTime, UpdatedTime, and Type at initialization time in toProto.

* Adding sdk test for unsetting a value.

* Require that project is created correctly before testing the catalog.

* Remove unused host catalog from test.

* Change a t.Fatal to a require.NoError that I missed earlier.

* Change shutdown error logging to t.Errorfs.

* Shorten validateX function names.

* Inline API responses.

* Add todo to make a new repo per request.

* Inline regex check for invalid id.

* Change stored repos into repo creating functions which satisfies ICU-223.

* Wrap proto comments to be under 80 characters long.

* Remove the exception on the read only fields that can be set in an Update request.

* Removing out of date comment.

* Use iam.TestScopes instead of making the project myself.

* Renaming files to be consistant with go test standards and resource naming standards.

* Remove TODO related to a task completed in an earlier commit.

* Fix the previous commit which removed the wrong TODO.

api/internal/genapi/delete.go

@@ -20,7 +20,12 @@ var deleteFuncs = map[string][]*deleteInfo{
 		{
 			"Organization",
 			"Project",
-			"projects/%s",
+			"projects",
+		},
+		{
+			"Project",
+			"hosts.HostCatalog",
+			"host-catalogs",
 		},
 	},
 }
@@ -34,15 +39,15 @@ package %s
 `, outPkg)))
 		for _, deleteInfo := range funcs {
 			deleteFuncTemplate.Execute(outBuf, struct {
-				BaseType        string
-				TargetType      string
-				LowerTargetType string
-				Path            string
+				BaseType   string
+				TargetType string
+				TargetName string
+				Path       string
 			}{
-				BaseType:        deleteInfo.baseType,
-				TargetType:      deleteInfo.targetType,
-				LowerTargetType: strings.ToLower(deleteInfo.targetType),
-				Path:            deleteInfo.path,
+				BaseType:   deleteInfo.baseType,
+				TargetType: deleteInfo.targetType,
+				TargetName: strings.Split(deleteInfo.targetType, ".")[strings.Count(deleteInfo.targetType, ".")],
+				Path:       deleteInfo.path,
 			})
 		}
 		if err := ioutil.WriteFile(outFile, outBuf.Bytes(), 0644); err != nil {
@@ -54,10 +59,10 @@ package %s
 
 var deleteFuncTemplate = template.Must(template.New("").Parse(
 	`
-// Delete{{ .TargetType }} returns true iff the {{ .LowerTargetType }} existed when the delete attempt was made. 
-func (s {{ .BaseType }}) Delete{{ .TargetType }}(ctx context.Context, {{ .LowerTargetType }} *{{ .TargetType }}) (bool, *api.Error, error) {
+// Delete{{ .TargetName }} returns true iff the {{ .TargetType }} existed when the delete attempt was made. 
+func (s {{ .BaseType }}) Delete{{ .TargetName }}(ctx context.Context, r *{{ .TargetType }}) (bool, *api.Error, error) {
 	if s.Client == nil {
-		return false, nil, fmt.Errorf("nil client in Delete{{ .TargetType }} request")
+		return false, nil, fmt.Errorf("nil client in Delete{{ .TargetName }} request")
 	}
 	if s.Id == "" {
 		{{ if (eq .BaseType "Organization") }}
@@ -67,7 +72,7 @@ func (s {{ .BaseType }}) Delete{{ .TargetType }}(ctx context.Context, {{ .LowerT
 		// Assume the client has been configured with project already and move
 		// on
 		{{ else }}
-		return nil, nil, fmt.Errorf("missing {{ .BaseType }} ID in Delete{{ .TargetType }} request")
+		return nil, nil, fmt.Errorf("missing {{ .BaseType }} ID in Delete{{ .TargetName }} request")
 		{{ end }}
 	} else {
 		// If it's explicitly set here, override anything that might be in the
@@ -78,18 +83,18 @@ func (s {{ .BaseType }}) Delete{{ .TargetType }}(ctx context.Context, {{ .LowerT
 		ctx = context.WithValue(ctx, "project", s.Id)
 		{{ end }}
 	}
-	if {{ .LowerTargetType }}.Id == "" {
-		return false, nil, fmt.Errorf("empty {{ .LowerTargetType }} ID field in Delete{{ .TargetType }} request")
+	if r.Id == "" {
+		return false, nil, fmt.Errorf("empty {{ .TargetType }} ID field in Delete{{ .TargetName }} request")
 	}
 
-	req, err := s.Client.NewRequest(ctx, "DELETE", fmt.Sprintf("{{ .Path }}", {{ .LowerTargetType }}.Id), nil)
+	req, err := s.Client.NewRequest(ctx, "DELETE", fmt.Sprintf("%s/%s", "{{ .Path }}", r.Id), nil)
 	if err != nil {
-		return false, nil, fmt.Errorf("error creating Delete{{ .TargetType }} request: %w", err)
+		return false, nil, fmt.Errorf("error creating Delete{{ .TargetName }} request: %w", err)
 	}
 
 	resp, err := s.Client.Do(req)
 	if err != nil {
-		return false, nil, fmt.Errorf("error performing client request during Delete{{ .TargetType }} call: %w", err)
+		return false, nil, fmt.Errorf("error performing client request during Delete{{ .TargetName }} call: %w", err)
 	}
 
 	type deleteResponse struct {
@@ -99,7 +104,7 @@ func (s {{ .BaseType }}) Delete{{ .TargetType }}(ctx context.Context, {{ .LowerT
 
 	apiErr, err := resp.Decode(target)
 	if err != nil {
-		return false, nil, fmt.Errorf("error decoding Delete{{ .TargetType }} repsonse: %w", err)
+		return false, nil, fmt.Errorf("error decoding Delete{{ .TargetName }} repsonse: %w", err)
 	}
 
 	return target.Existed, apiErr, nil