From 010918fcff6d4b0ee7ea308ad6829f2a8713997a Mon Sep 17 00:00:00 2001
From: Phil Adams <phil_adams@us.ibm.com>
Date: Wed, 17 Jun 2020 13:39:08 -0500
Subject: [PATCH] feat(IAM Policy Management): add service to project (#13)

Co-authored-by: Carlos Gomez <cfgomez@us.ibm.com>
---
 .travis.yml                                   |    1 +
 README.md                                     |    1 +
 iam_policy_management.env.enc                 |  Bin 0 -> 320 bytes
 .../iam_policy_management_v1.go               | 1701 +++++++++++++++
 ...m_policy_management_v1_integration_test.go |  377 ++++
 .../iam_policy_management_v1_suite_test.go    |   28 +
 .../iam_policy_management_v1_test.go          | 1857 +++++++++++++++++
 7 files changed, 3965 insertions(+)
 create mode 100644 iam_policy_management.env.enc
 create mode 100644 iampolicymanagementv1/iam_policy_management_v1.go
 create mode 100644 iampolicymanagementv1/iam_policy_management_v1_integration_test.go
 create mode 100644 iampolicymanagementv1/iam_policy_management_v1_suite_test.go
 create mode 100644 iampolicymanagementv1/iam_policy_management_v1_test.go

diff --git a/.travis.yml b/.travis.yml
index 6d29361a..7dc4b868 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -22,6 +22,7 @@ before_install:
       && openssl aes-256-cbc -K $encrypted_3058bc69cb40_key -iv $encrypted_3058bc69cb40_iv -in ghost.env.enc -out ghost.env -d
       && openssl aes-256-cbc -K $encrypted_66f264007c0d_key -iv $encrypted_66f264007c0d_iv -in iam_access_groups.env.enc -out iam_access_groups.env -d
       && openssl aes-256-cbc -K $encrypted_94fa7fdf4df9_key -iv $encrypted_94fa7fdf4df9_iv -in global_catalog.env.enc -out global_catalog.env -d
+      && openssl aes-256-cbc -K $encrypted_a72454cfb42f_key -iv $encrypted_a72454cfb42f_iv -in iam_policy_management.env.enc -out iam_policy_management.env -d
       || true
 
 #     && openssl aes-256-cbc -K $encrypted_dac53b985913_key -iv $encrypted_dac53b985913_iv -in case_management.env.enc -out case_management.env -d
diff --git a/README.md b/README.md
index a2179444..1f1adfb8 100644
--- a/README.md
+++ b/README.md
@@ -53,6 +53,7 @@ Service Name | Package name
 [Global Search](https://cloud.ibm.com/apidocs/search) | globalsearchv2
 [Global Tagging](https://cloud.ibm.com/apidocs/tagging) | globaltaggingv1
 [IAM Access Groups](https://cloud.ibm.com/apidocs/iam-access-groups) | iamaccessgroupsv2
+[IAM Policy Managemenet](https://cloud.ibm.com/apidocs/iam-policy-management) | iampolicymanagementv1
 [Resource Manager](https://cloud.ibm.com/apidocs/resource-controller/resource-manager) | resourcemanagerv2
 
 ## Prerequisites
diff --git a/iam_policy_management.env.enc b/iam_policy_management.env.enc
new file mode 100644
index 0000000000000000000000000000000000000000..9e1840ed681f44cf57e16978182546bc7c609a8d
GIT binary patch
literal 320
zcmV-G0l)r=yp<Y@JWPk8y~;6p_%paxO<vZ9EB-@zmp)5H;p~-1k|Vg#k+#9JvyBnv
zOCdQLot_%D>Jj^O>88mDDp5GN0Qb&WdiAB*pHcS&SyRwJlOYC+FRqM!RxK^PyY8OV
zk%!@k37Cz(O#K&hpF;F1jO|eX(4>MCCST5JU@MJNZ95k~E~bFh#f}(l1{K1-8jTy8
zL1g)5nOifI^&Jcbof=Bl52UuBTPmaL53a{bYo?-gU@RQN8Flj@o?lxg09ns=Iexbh
z{WV(G)a6{L;5moFATfIgeJBXsP0Xz#y51eoT;c{P1^WI{2yX(rmY+!+9uOQb$<Q2o
z10kWA^zgRHV4)2oJfHX=nUt#j5?2<+tSDWklmiT`Q(l}}RZBAQ2=rD%<bdhGnQ^w;
SwgZLThvlf93Pwr@zPf}&;g^U2

literal 0
HcmV?d00001

diff --git a/iampolicymanagementv1/iam_policy_management_v1.go b/iampolicymanagementv1/iam_policy_management_v1.go
new file mode 100644
index 00000000..0ca70bd3
--- /dev/null
+++ b/iampolicymanagementv1/iam_policy_management_v1.go
@@ -0,0 +1,1701 @@
+/**
+ * (C) Copyright IBM Corp. 2020.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package iampolicymanagementv1 : Operations and models for the IamPolicyManagementV1 service
+package iampolicymanagementv1
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/IBM/go-sdk-core/v4/core"
+	common "github.com/IBM/platform-services-go-sdk/common"
+	"github.com/go-openapi/strfmt"
+	"reflect"
+)
+
+// IamPolicyManagementV1 : IAM Policy Management API
+//
+// Version: 1.0.1
+type IamPolicyManagementV1 struct {
+	Service *core.BaseService
+}
+
+// DefaultServiceURL is the default URL to make service requests to.
+const DefaultServiceURL = "https://iam.cloud.ibm.com"
+
+// DefaultServiceName is the default key used to find external configuration information.
+const DefaultServiceName = "iam_policy_management"
+
+// IamPolicyManagementV1Options : Service options
+type IamPolicyManagementV1Options struct {
+	ServiceName   string
+	URL           string
+	Authenticator core.Authenticator
+}
+
+// NewIamPolicyManagementV1UsingExternalConfig : constructs an instance of IamPolicyManagementV1 with passed in options and external configuration.
+func NewIamPolicyManagementV1UsingExternalConfig(options *IamPolicyManagementV1Options) (iamPolicyManagement *IamPolicyManagementV1, err error) {
+	if options.ServiceName == "" {
+		options.ServiceName = DefaultServiceName
+	}
+
+	if options.Authenticator == nil {
+		options.Authenticator, err = core.GetAuthenticatorFromEnvironment(options.ServiceName)
+		if err != nil {
+			return
+		}
+	}
+
+	iamPolicyManagement, err = NewIamPolicyManagementV1(options)
+	if err != nil {
+		return
+	}
+
+	err = iamPolicyManagement.Service.ConfigureService(options.ServiceName)
+	if err != nil {
+		return
+	}
+
+	if options.URL != "" {
+		err = iamPolicyManagement.Service.SetServiceURL(options.URL)
+	}
+	return
+}
+
+// NewIamPolicyManagementV1 : constructs an instance of IamPolicyManagementV1 with passed in options.
+func NewIamPolicyManagementV1(options *IamPolicyManagementV1Options) (service *IamPolicyManagementV1, err error) {
+	serviceOptions := &core.ServiceOptions{
+		URL:           DefaultServiceURL,
+		Authenticator: options.Authenticator,
+	}
+
+	baseService, err := core.NewBaseService(serviceOptions)
+	if err != nil {
+		return
+	}
+
+	if options.URL != "" {
+		err = baseService.SetServiceURL(options.URL)
+		if err != nil {
+			return
+		}
+	}
+
+	service = &IamPolicyManagementV1{
+		Service: baseService,
+	}
+
+	return
+}
+
+// SetServiceURL sets the service URL
+func (iamPolicyManagement *IamPolicyManagementV1) SetServiceURL(url string) error {
+	return iamPolicyManagement.Service.SetServiceURL(url)
+}
+
+// ListPolicies : Get policies by attributes
+// Get policies and filter by attributes. While managing policies, you may want to retrieve policies in the account and
+// filter by attribute values. This can be done through query parameters. Currently, we only support the following
+// attributes: account_id, iam_id, access_group_id, type, and service_type. account_id is a required query parameter.
+// Only policies that have the specified attributes and that the caller has read access to are returned. If the caller
+// does not have read access to any policies an empty array is returned.
+func (iamPolicyManagement *IamPolicyManagementV1) ListPolicies(listPoliciesOptions *ListPoliciesOptions) (result *PolicyList, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(listPoliciesOptions, "listPoliciesOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(listPoliciesOptions, "listPoliciesOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v1/policies"}
+	pathParameters := []string{}
+
+	builder := core.NewRequestBuilder(core.GET)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range listPoliciesOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "ListPolicies")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	if listPoliciesOptions.AcceptLanguage != nil {
+		builder.AddHeader("Accept-Language", fmt.Sprint(*listPoliciesOptions.AcceptLanguage))
+	}
+
+	builder.AddQuery("account_id", fmt.Sprint(*listPoliciesOptions.AccountID))
+	if listPoliciesOptions.IamID != nil {
+		builder.AddQuery("iam_id", fmt.Sprint(*listPoliciesOptions.IamID))
+	}
+	if listPoliciesOptions.AccessGroupID != nil {
+		builder.AddQuery("access_group_id", fmt.Sprint(*listPoliciesOptions.AccessGroupID))
+	}
+	if listPoliciesOptions.Type != nil {
+		builder.AddQuery("type", fmt.Sprint(*listPoliciesOptions.Type))
+	}
+	if listPoliciesOptions.ServiceType != nil {
+		builder.AddQuery("service_type", fmt.Sprint(*listPoliciesOptions.ServiceType))
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalPolicyList)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// CreatePolicy : Create a policy
+// Creates a policy to grant access between a subject and a resource. There are two types of policies: **access** and
+// **authorization**. A policy administrator might want to create an access policy which grants access to a user,
+// service-id, or an access group. They might also want to create an authorization policy and setup access between
+// services.
+// ### Access To create an access policy, use **`"type": "access"`** in the body. The possible subject attributes are
+// **`iam_id`** and **`access_group_id`**. Use the **`iam_id`** subject attribute for assigning access for a user or
+// service-id. Use the **`access_group_id`** subject attribute for assigning access for an access group. The roles must
+// be a subset of a service's or the platform's supported roles. The resource attributes must be a subset of a service's
+// or the platform's supported attributes. The policy resource must include either the **`serviceType`**,
+// **`serviceName`**,  or **`resourceGroupId`** attribute and the **`accountId`** attribute.` If the subject is a locked
+// service-id, the request will fail.
+// ### Authorization Authorization policies are supported by services on a case by case basis. Refer to service
+// documentation to verify their support of authorization policies. To create an authorization policy, use **`"type":
+// "authorization"`** in the body. The subject attributes must match the supported authorization subjects of the
+// resource. Multiple subject attributes might be provided. The following attributes are supported:
+//   serviceName, serviceInstance, region, resourceType, resource, accountId The policy roles must be a subset of the
+// supported authorization roles supported by the target service. The user must also have the same level of access or
+// greater to the target resource in order to grant the role. The resource attributes must be a subset of a service's or
+// the platform's supported attributes. Both the policy subject and the policy resource must include the
+// **`serviceName`** and **`accountId`** attributes.
+func (iamPolicyManagement *IamPolicyManagementV1) CreatePolicy(createPolicyOptions *CreatePolicyOptions) (result *Policy, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(createPolicyOptions, "createPolicyOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(createPolicyOptions, "createPolicyOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v1/policies"}
+	pathParameters := []string{}
+
+	builder := core.NewRequestBuilder(core.POST)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range createPolicyOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "CreatePolicy")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	builder.AddHeader("Content-Type", "application/json")
+	if createPolicyOptions.AcceptLanguage != nil {
+		builder.AddHeader("Accept-Language", fmt.Sprint(*createPolicyOptions.AcceptLanguage))
+	}
+
+	body := make(map[string]interface{})
+	if createPolicyOptions.Type != nil {
+		body["type"] = createPolicyOptions.Type
+	}
+	if createPolicyOptions.Subjects != nil {
+		body["subjects"] = createPolicyOptions.Subjects
+	}
+	if createPolicyOptions.Roles != nil {
+		body["roles"] = createPolicyOptions.Roles
+	}
+	if createPolicyOptions.Resources != nil {
+		body["resources"] = createPolicyOptions.Resources
+	}
+	_, err = builder.SetBodyContentJSON(body)
+	if err != nil {
+		return
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalPolicy)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// UpdatePolicy : Update a policy
+// Update a policy to grant access between a subject and a resource. A policy administrator might want to update an
+// existing policy. The policy type cannot be changed (You cannot change an access policy to an authorization policy).
+// ### Access To update an access policy, use **`"type": "access"`** in the body. The possible subject attributes are
+// **`iam_id`** and **`access_group_id`**. Use the **`iam_id`** subject attribute for assigning access for a user or
+// service-id. Use the **`access_group_id`** subject attribute for assigning access for an access group. The roles must
+// be a subset of a service's or the platform's supported roles. The resource attributes must be a subset of a service's
+// or the platform's supported attributes. The policy resource must include either the **`serviceType`**,
+// **`serviceName`**,  or **`resourceGroupId`** attribute and the **`accountId`** attribute.` If the subject is a locked
+// service-id, the request will fail.
+// ### Authorization To update an authorization policy, use **`"type": "authorization"`** in the body. The subject
+// attributes must match the supported authorization subjects of the resource. Multiple subject attributes might be
+// provided. The following attributes are supported:
+//   serviceName, serviceInstance, region, resourceType, resource, accountId The policy roles must be a subset of the
+// supported authorization roles supported by the target service. The user must also have the same level of access or
+// greater to the target resource in order to grant the role. The resource attributes must be a subset of a service's or
+// the platform's supported attributes. Both the policy subject and the policy resource must include the
+// **`serviceName`** and **`accountId`** attributes.
+func (iamPolicyManagement *IamPolicyManagementV1) UpdatePolicy(updatePolicyOptions *UpdatePolicyOptions) (result *Policy, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(updatePolicyOptions, "updatePolicyOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(updatePolicyOptions, "updatePolicyOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v1/policies"}
+	pathParameters := []string{*updatePolicyOptions.PolicyID}
+
+	builder := core.NewRequestBuilder(core.PUT)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range updatePolicyOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "UpdatePolicy")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	builder.AddHeader("Content-Type", "application/json")
+	if updatePolicyOptions.IfMatch != nil {
+		builder.AddHeader("If-Match", fmt.Sprint(*updatePolicyOptions.IfMatch))
+	}
+
+	body := make(map[string]interface{})
+	if updatePolicyOptions.Type != nil {
+		body["type"] = updatePolicyOptions.Type
+	}
+	if updatePolicyOptions.Subjects != nil {
+		body["subjects"] = updatePolicyOptions.Subjects
+	}
+	if updatePolicyOptions.Roles != nil {
+		body["roles"] = updatePolicyOptions.Roles
+	}
+	if updatePolicyOptions.Resources != nil {
+		body["resources"] = updatePolicyOptions.Resources
+	}
+	_, err = builder.SetBodyContentJSON(body)
+	if err != nil {
+		return
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalPolicy)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// GetPolicy : Retrieve a policy by ID
+// Retrieve a policy by providing a policy ID.
+func (iamPolicyManagement *IamPolicyManagementV1) GetPolicy(getPolicyOptions *GetPolicyOptions) (result *Policy, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(getPolicyOptions, "getPolicyOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(getPolicyOptions, "getPolicyOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v1/policies"}
+	pathParameters := []string{*getPolicyOptions.PolicyID}
+
+	builder := core.NewRequestBuilder(core.GET)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range getPolicyOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "GetPolicy")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalPolicy)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// DeletePolicy : Delete a policy by ID
+// Delete a policy by providing a policy ID. A policy cannot be deleted if the subject ID contains a locked service ID.
+// If the subject of the policy is a locked service-id, the request will fail.
+func (iamPolicyManagement *IamPolicyManagementV1) DeletePolicy(deletePolicyOptions *DeletePolicyOptions) (response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(deletePolicyOptions, "deletePolicyOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(deletePolicyOptions, "deletePolicyOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v1/policies"}
+	pathParameters := []string{*deletePolicyOptions.PolicyID}
+
+	builder := core.NewRequestBuilder(core.DELETE)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range deletePolicyOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "DeletePolicy")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	response, err = iamPolicyManagement.Service.Request(request, nil)
+
+	return
+}
+
+// ListRoles : Get roles by filters
+// Get roles based on the filters. While managing roles, you may want to retrieve roles and filter by usages. This can
+// be done through query parameters. Currently, we only support the following attributes: account_id, and service_name.
+// Only roles that match the filter and that the caller has read access to are returned. If the caller does not have
+// read access to any roles an empty array is returned.
+func (iamPolicyManagement *IamPolicyManagementV1) ListRoles(listRolesOptions *ListRolesOptions) (result *RoleList, response *core.DetailedResponse, err error) {
+	err = core.ValidateStruct(listRolesOptions, "listRolesOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v2/roles"}
+	pathParameters := []string{}
+
+	builder := core.NewRequestBuilder(core.GET)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range listRolesOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "ListRoles")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	if listRolesOptions.AcceptLanguage != nil {
+		builder.AddHeader("Accept-Language", fmt.Sprint(*listRolesOptions.AcceptLanguage))
+	}
+
+	if listRolesOptions.AccountID != nil {
+		builder.AddQuery("account_id", fmt.Sprint(*listRolesOptions.AccountID))
+	}
+	if listRolesOptions.ServiceName != nil {
+		builder.AddQuery("service_name", fmt.Sprint(*listRolesOptions.ServiceName))
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalRoleList)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// CreateRole : Create a role
+// Creates a custom role for a specific service within the account. An account owner or a user assigned the
+// Administrator role on the Role management service can create a custom role. Any number of actions for a single
+// service can be mapped to the new role, but there must be at least one service-defined action to successfully create
+// the new role.
+func (iamPolicyManagement *IamPolicyManagementV1) CreateRole(createRoleOptions *CreateRoleOptions) (result *CustomRole, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(createRoleOptions, "createRoleOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(createRoleOptions, "createRoleOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v2/roles"}
+	pathParameters := []string{}
+
+	builder := core.NewRequestBuilder(core.POST)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range createRoleOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "CreateRole")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	builder.AddHeader("Content-Type", "application/json")
+	if createRoleOptions.AcceptLanguage != nil {
+		builder.AddHeader("Accept-Language", fmt.Sprint(*createRoleOptions.AcceptLanguage))
+	}
+
+	body := make(map[string]interface{})
+	if createRoleOptions.DisplayName != nil {
+		body["display_name"] = createRoleOptions.DisplayName
+	}
+	if createRoleOptions.Actions != nil {
+		body["actions"] = createRoleOptions.Actions
+	}
+	if createRoleOptions.Name != nil {
+		body["name"] = createRoleOptions.Name
+	}
+	if createRoleOptions.AccountID != nil {
+		body["account_id"] = createRoleOptions.AccountID
+	}
+	if createRoleOptions.ServiceName != nil {
+		body["service_name"] = createRoleOptions.ServiceName
+	}
+	if createRoleOptions.Description != nil {
+		body["description"] = createRoleOptions.Description
+	}
+	_, err = builder.SetBodyContentJSON(body)
+	if err != nil {
+		return
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCustomRole)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// UpdateRole : Update a role
+// Update a custom role. A role administrator might want to update an existing role by updating the display name,
+// description, or the actions that are mapped to the role. The name, account_id, and service_name can't be changed.
+func (iamPolicyManagement *IamPolicyManagementV1) UpdateRole(updateRoleOptions *UpdateRoleOptions) (result *CustomRole, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(updateRoleOptions, "updateRoleOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(updateRoleOptions, "updateRoleOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v2/roles"}
+	pathParameters := []string{*updateRoleOptions.RoleID}
+
+	builder := core.NewRequestBuilder(core.PUT)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range updateRoleOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "UpdateRole")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+	builder.AddHeader("Content-Type", "application/json")
+	if updateRoleOptions.IfMatch != nil {
+		builder.AddHeader("If-Match", fmt.Sprint(*updateRoleOptions.IfMatch))
+	}
+
+	body := make(map[string]interface{})
+	if updateRoleOptions.DisplayName != nil {
+		body["display_name"] = updateRoleOptions.DisplayName
+	}
+	if updateRoleOptions.Description != nil {
+		body["description"] = updateRoleOptions.Description
+	}
+	if updateRoleOptions.Actions != nil {
+		body["actions"] = updateRoleOptions.Actions
+	}
+	_, err = builder.SetBodyContentJSON(body)
+	if err != nil {
+		return
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCustomRole)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// GetRole : Retrieve a role by ID
+// Retrieve a role by providing a role ID.
+func (iamPolicyManagement *IamPolicyManagementV1) GetRole(getRoleOptions *GetRoleOptions) (result *CustomRole, response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(getRoleOptions, "getRoleOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(getRoleOptions, "getRoleOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v2/roles"}
+	pathParameters := []string{*getRoleOptions.RoleID}
+
+	builder := core.NewRequestBuilder(core.GET)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range getRoleOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "GetRole")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+	builder.AddHeader("Accept", "application/json")
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	var rawResponse map[string]json.RawMessage
+	response, err = iamPolicyManagement.Service.Request(request, &rawResponse)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCustomRole)
+	if err != nil {
+		return
+	}
+	response.Result = result
+
+	return
+}
+
+// DeleteRole : Delete a role by ID
+// Delete a role by providing a role ID.
+func (iamPolicyManagement *IamPolicyManagementV1) DeleteRole(deleteRoleOptions *DeleteRoleOptions) (response *core.DetailedResponse, err error) {
+	err = core.ValidateNotNil(deleteRoleOptions, "deleteRoleOptions cannot be nil")
+	if err != nil {
+		return
+	}
+	err = core.ValidateStruct(deleteRoleOptions, "deleteRoleOptions")
+	if err != nil {
+		return
+	}
+
+	pathSegments := []string{"v2/roles"}
+	pathParameters := []string{*deleteRoleOptions.RoleID}
+
+	builder := core.NewRequestBuilder(core.DELETE)
+	_, err = builder.ConstructHTTPURL(iamPolicyManagement.Service.Options.URL, pathSegments, pathParameters)
+	if err != nil {
+		return
+	}
+
+	for headerName, headerValue := range deleteRoleOptions.Headers {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	sdkHeaders := common.GetSdkHeaders("iam_policy_management", "V1", "DeleteRole")
+	for headerName, headerValue := range sdkHeaders {
+		builder.AddHeader(headerName, headerValue)
+	}
+
+	request, err := builder.Build()
+	if err != nil {
+		return
+	}
+
+	response, err = iamPolicyManagement.Service.Request(request, nil)
+
+	return
+}
+
+// CreatePolicyOptions : The CreatePolicy options.
+type CreatePolicyOptions struct {
+	// The policy type; either 'access' or 'authorization'.
+	Type *string `json:"type" validate:"required"`
+
+	// The subjects associated with a policy.
+	Subjects []PolicySubject `json:"subjects" validate:"required"`
+
+	// A set of role cloud resource names (CRNs) granted by the policy.
+	Roles []PolicyRole `json:"roles" validate:"required"`
+
+	// The resources associated with a policy.
+	Resources []PolicyResource `json:"resources" validate:"required"`
+
+	// Translation language code.
+	AcceptLanguage *string `json:"Accept-Language,omitempty"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewCreatePolicyOptions : Instantiate CreatePolicyOptions
+func (*IamPolicyManagementV1) NewCreatePolicyOptions(typeVar string, subjects []PolicySubject, roles []PolicyRole, resources []PolicyResource) *CreatePolicyOptions {
+	return &CreatePolicyOptions{
+		Type: core.StringPtr(typeVar),
+		Subjects: subjects,
+		Roles: roles,
+		Resources: resources,
+	}
+}
+
+// SetType : Allow user to set Type
+func (options *CreatePolicyOptions) SetType(typeVar string) *CreatePolicyOptions {
+	options.Type = core.StringPtr(typeVar)
+	return options
+}
+
+// SetSubjects : Allow user to set Subjects
+func (options *CreatePolicyOptions) SetSubjects(subjects []PolicySubject) *CreatePolicyOptions {
+	options.Subjects = subjects
+	return options
+}
+
+// SetRoles : Allow user to set Roles
+func (options *CreatePolicyOptions) SetRoles(roles []PolicyRole) *CreatePolicyOptions {
+	options.Roles = roles
+	return options
+}
+
+// SetResources : Allow user to set Resources
+func (options *CreatePolicyOptions) SetResources(resources []PolicyResource) *CreatePolicyOptions {
+	options.Resources = resources
+	return options
+}
+
+// SetAcceptLanguage : Allow user to set AcceptLanguage
+func (options *CreatePolicyOptions) SetAcceptLanguage(acceptLanguage string) *CreatePolicyOptions {
+	options.AcceptLanguage = core.StringPtr(acceptLanguage)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *CreatePolicyOptions) SetHeaders(param map[string]string) *CreatePolicyOptions {
+	options.Headers = param
+	return options
+}
+
+// CreateRoleOptions : The CreateRole options.
+type CreateRoleOptions struct {
+	// The display name of the role that is shown in the console.
+	DisplayName *string `json:"display_name" validate:"required"`
+
+	// The actions of the role.
+	Actions []string `json:"actions" validate:"required"`
+
+	// The name of the role that is used in the CRN. Can only be alphanumeric and has to be capitalized.
+	Name *string `json:"name" validate:"required"`
+
+	// The account GUID.
+	AccountID *string `json:"account_id" validate:"required"`
+
+	// The service name.
+	ServiceName *string `json:"service_name" validate:"required"`
+
+	// The description of the role.
+	Description *string `json:"description,omitempty"`
+
+	// Translation language code.
+	AcceptLanguage *string `json:"Accept-Language,omitempty"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewCreateRoleOptions : Instantiate CreateRoleOptions
+func (*IamPolicyManagementV1) NewCreateRoleOptions(displayName string, actions []string, name string, accountID string, serviceName string) *CreateRoleOptions {
+	return &CreateRoleOptions{
+		DisplayName: core.StringPtr(displayName),
+		Actions: actions,
+		Name: core.StringPtr(name),
+		AccountID: core.StringPtr(accountID),
+		ServiceName: core.StringPtr(serviceName),
+	}
+}
+
+// SetDisplayName : Allow user to set DisplayName
+func (options *CreateRoleOptions) SetDisplayName(displayName string) *CreateRoleOptions {
+	options.DisplayName = core.StringPtr(displayName)
+	return options
+}
+
+// SetActions : Allow user to set Actions
+func (options *CreateRoleOptions) SetActions(actions []string) *CreateRoleOptions {
+	options.Actions = actions
+	return options
+}
+
+// SetName : Allow user to set Name
+func (options *CreateRoleOptions) SetName(name string) *CreateRoleOptions {
+	options.Name = core.StringPtr(name)
+	return options
+}
+
+// SetAccountID : Allow user to set AccountID
+func (options *CreateRoleOptions) SetAccountID(accountID string) *CreateRoleOptions {
+	options.AccountID = core.StringPtr(accountID)
+	return options
+}
+
+// SetServiceName : Allow user to set ServiceName
+func (options *CreateRoleOptions) SetServiceName(serviceName string) *CreateRoleOptions {
+	options.ServiceName = core.StringPtr(serviceName)
+	return options
+}
+
+// SetDescription : Allow user to set Description
+func (options *CreateRoleOptions) SetDescription(description string) *CreateRoleOptions {
+	options.Description = core.StringPtr(description)
+	return options
+}
+
+// SetAcceptLanguage : Allow user to set AcceptLanguage
+func (options *CreateRoleOptions) SetAcceptLanguage(acceptLanguage string) *CreateRoleOptions {
+	options.AcceptLanguage = core.StringPtr(acceptLanguage)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *CreateRoleOptions) SetHeaders(param map[string]string) *CreateRoleOptions {
+	options.Headers = param
+	return options
+}
+
+// DeletePolicyOptions : The DeletePolicy options.
+type DeletePolicyOptions struct {
+	// The policy ID.
+	PolicyID *string `json:"policy_id" validate:"required"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewDeletePolicyOptions : Instantiate DeletePolicyOptions
+func (*IamPolicyManagementV1) NewDeletePolicyOptions(policyID string) *DeletePolicyOptions {
+	return &DeletePolicyOptions{
+		PolicyID: core.StringPtr(policyID),
+	}
+}
+
+// SetPolicyID : Allow user to set PolicyID
+func (options *DeletePolicyOptions) SetPolicyID(policyID string) *DeletePolicyOptions {
+	options.PolicyID = core.StringPtr(policyID)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *DeletePolicyOptions) SetHeaders(param map[string]string) *DeletePolicyOptions {
+	options.Headers = param
+	return options
+}
+
+// DeleteRoleOptions : The DeleteRole options.
+type DeleteRoleOptions struct {
+	// The role ID.
+	RoleID *string `json:"role_id" validate:"required"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewDeleteRoleOptions : Instantiate DeleteRoleOptions
+func (*IamPolicyManagementV1) NewDeleteRoleOptions(roleID string) *DeleteRoleOptions {
+	return &DeleteRoleOptions{
+		RoleID: core.StringPtr(roleID),
+	}
+}
+
+// SetRoleID : Allow user to set RoleID
+func (options *DeleteRoleOptions) SetRoleID(roleID string) *DeleteRoleOptions {
+	options.RoleID = core.StringPtr(roleID)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *DeleteRoleOptions) SetHeaders(param map[string]string) *DeleteRoleOptions {
+	options.Headers = param
+	return options
+}
+
+// GetPolicyOptions : The GetPolicy options.
+type GetPolicyOptions struct {
+	// The policy ID.
+	PolicyID *string `json:"policy_id" validate:"required"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewGetPolicyOptions : Instantiate GetPolicyOptions
+func (*IamPolicyManagementV1) NewGetPolicyOptions(policyID string) *GetPolicyOptions {
+	return &GetPolicyOptions{
+		PolicyID: core.StringPtr(policyID),
+	}
+}
+
+// SetPolicyID : Allow user to set PolicyID
+func (options *GetPolicyOptions) SetPolicyID(policyID string) *GetPolicyOptions {
+	options.PolicyID = core.StringPtr(policyID)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *GetPolicyOptions) SetHeaders(param map[string]string) *GetPolicyOptions {
+	options.Headers = param
+	return options
+}
+
+// GetRoleOptions : The GetRole options.
+type GetRoleOptions struct {
+	// The role ID.
+	RoleID *string `json:"role_id" validate:"required"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewGetRoleOptions : Instantiate GetRoleOptions
+func (*IamPolicyManagementV1) NewGetRoleOptions(roleID string) *GetRoleOptions {
+	return &GetRoleOptions{
+		RoleID: core.StringPtr(roleID),
+	}
+}
+
+// SetRoleID : Allow user to set RoleID
+func (options *GetRoleOptions) SetRoleID(roleID string) *GetRoleOptions {
+	options.RoleID = core.StringPtr(roleID)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *GetRoleOptions) SetHeaders(param map[string]string) *GetRoleOptions {
+	options.Headers = param
+	return options
+}
+
+// ListPoliciesOptions : The ListPolicies options.
+type ListPoliciesOptions struct {
+	// The account GUID in which the policies belong to.
+	AccountID *string `json:"account_id" validate:"required"`
+
+	// Translation language code.
+	AcceptLanguage *string `json:"Accept-Language,omitempty"`
+
+	// The IAM ID used to identify the subject.
+	IamID *string `json:"iam_id,omitempty"`
+
+	// The access group id.
+	AccessGroupID *string `json:"access_group_id,omitempty"`
+
+	// The type of policy (access or authorization).
+	Type *string `json:"type,omitempty"`
+
+	// The type of service.
+	ServiceType *string `json:"service_type,omitempty"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewListPoliciesOptions : Instantiate ListPoliciesOptions
+func (*IamPolicyManagementV1) NewListPoliciesOptions(accountID string) *ListPoliciesOptions {
+	return &ListPoliciesOptions{
+		AccountID: core.StringPtr(accountID),
+	}
+}
+
+// SetAccountID : Allow user to set AccountID
+func (options *ListPoliciesOptions) SetAccountID(accountID string) *ListPoliciesOptions {
+	options.AccountID = core.StringPtr(accountID)
+	return options
+}
+
+// SetAcceptLanguage : Allow user to set AcceptLanguage
+func (options *ListPoliciesOptions) SetAcceptLanguage(acceptLanguage string) *ListPoliciesOptions {
+	options.AcceptLanguage = core.StringPtr(acceptLanguage)
+	return options
+}
+
+// SetIamID : Allow user to set IamID
+func (options *ListPoliciesOptions) SetIamID(iamID string) *ListPoliciesOptions {
+	options.IamID = core.StringPtr(iamID)
+	return options
+}
+
+// SetAccessGroupID : Allow user to set AccessGroupID
+func (options *ListPoliciesOptions) SetAccessGroupID(accessGroupID string) *ListPoliciesOptions {
+	options.AccessGroupID = core.StringPtr(accessGroupID)
+	return options
+}
+
+// SetType : Allow user to set Type
+func (options *ListPoliciesOptions) SetType(typeVar string) *ListPoliciesOptions {
+	options.Type = core.StringPtr(typeVar)
+	return options
+}
+
+// SetServiceType : Allow user to set ServiceType
+func (options *ListPoliciesOptions) SetServiceType(serviceType string) *ListPoliciesOptions {
+	options.ServiceType = core.StringPtr(serviceType)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *ListPoliciesOptions) SetHeaders(param map[string]string) *ListPoliciesOptions {
+	options.Headers = param
+	return options
+}
+
+// ListRolesOptions : The ListRoles options.
+type ListRolesOptions struct {
+	// Translation language code.
+	AcceptLanguage *string `json:"Accept-Language,omitempty"`
+
+	// The account GUID in which the roles belong to.
+	AccountID *string `json:"account_id,omitempty"`
+
+	// The name of service.
+	ServiceName *string `json:"service_name,omitempty"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewListRolesOptions : Instantiate ListRolesOptions
+func (*IamPolicyManagementV1) NewListRolesOptions() *ListRolesOptions {
+	return &ListRolesOptions{}
+}
+
+// SetAcceptLanguage : Allow user to set AcceptLanguage
+func (options *ListRolesOptions) SetAcceptLanguage(acceptLanguage string) *ListRolesOptions {
+	options.AcceptLanguage = core.StringPtr(acceptLanguage)
+	return options
+}
+
+// SetAccountID : Allow user to set AccountID
+func (options *ListRolesOptions) SetAccountID(accountID string) *ListRolesOptions {
+	options.AccountID = core.StringPtr(accountID)
+	return options
+}
+
+// SetServiceName : Allow user to set ServiceName
+func (options *ListRolesOptions) SetServiceName(serviceName string) *ListRolesOptions {
+	options.ServiceName = core.StringPtr(serviceName)
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *ListRolesOptions) SetHeaders(param map[string]string) *ListRolesOptions {
+	options.Headers = param
+	return options
+}
+
+// UpdatePolicyOptions : The UpdatePolicy options.
+type UpdatePolicyOptions struct {
+	// The policy ID.
+	PolicyID *string `json:"policy_id" validate:"required"`
+
+	// The revision number for updating a policy and must match the ETag value of the existing policy. The Etag can be
+	// retrieved using the GET /v1/policies/{policy_id} API and looking at the ETag response header.
+	IfMatch *string `json:"If-Match" validate:"required"`
+
+	// The policy type; either 'access' or 'authorization'.
+	Type *string `json:"type" validate:"required"`
+
+	// The subjects associated with a policy.
+	Subjects []PolicySubject `json:"subjects" validate:"required"`
+
+	// A set of role cloud resource names (CRNs) granted by the policy.
+	Roles []PolicyRole `json:"roles" validate:"required"`
+
+	// The resources associated with a policy.
+	Resources []PolicyResource `json:"resources" validate:"required"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewUpdatePolicyOptions : Instantiate UpdatePolicyOptions
+func (*IamPolicyManagementV1) NewUpdatePolicyOptions(policyID string, ifMatch string, typeVar string, subjects []PolicySubject, roles []PolicyRole, resources []PolicyResource) *UpdatePolicyOptions {
+	return &UpdatePolicyOptions{
+		PolicyID: core.StringPtr(policyID),
+		IfMatch: core.StringPtr(ifMatch),
+		Type: core.StringPtr(typeVar),
+		Subjects: subjects,
+		Roles: roles,
+		Resources: resources,
+	}
+}
+
+// SetPolicyID : Allow user to set PolicyID
+func (options *UpdatePolicyOptions) SetPolicyID(policyID string) *UpdatePolicyOptions {
+	options.PolicyID = core.StringPtr(policyID)
+	return options
+}
+
+// SetIfMatch : Allow user to set IfMatch
+func (options *UpdatePolicyOptions) SetIfMatch(ifMatch string) *UpdatePolicyOptions {
+	options.IfMatch = core.StringPtr(ifMatch)
+	return options
+}
+
+// SetType : Allow user to set Type
+func (options *UpdatePolicyOptions) SetType(typeVar string) *UpdatePolicyOptions {
+	options.Type = core.StringPtr(typeVar)
+	return options
+}
+
+// SetSubjects : Allow user to set Subjects
+func (options *UpdatePolicyOptions) SetSubjects(subjects []PolicySubject) *UpdatePolicyOptions {
+	options.Subjects = subjects
+	return options
+}
+
+// SetRoles : Allow user to set Roles
+func (options *UpdatePolicyOptions) SetRoles(roles []PolicyRole) *UpdatePolicyOptions {
+	options.Roles = roles
+	return options
+}
+
+// SetResources : Allow user to set Resources
+func (options *UpdatePolicyOptions) SetResources(resources []PolicyResource) *UpdatePolicyOptions {
+	options.Resources = resources
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *UpdatePolicyOptions) SetHeaders(param map[string]string) *UpdatePolicyOptions {
+	options.Headers = param
+	return options
+}
+
+// UpdateRoleOptions : The UpdateRole options.
+type UpdateRoleOptions struct {
+	// The role ID.
+	RoleID *string `json:"role_id" validate:"required"`
+
+	// The revision number for updating a role and must match the ETag value of the existing role. The Etag can be
+	// retrieved using the GET /v2/roles/{role_id} API and looking at the ETag response header.
+	IfMatch *string `json:"If-Match" validate:"required"`
+
+	// The display name of the role that is shown in the console.
+	DisplayName *string `json:"display_name,omitempty"`
+
+	// The description of the role.
+	Description *string `json:"description,omitempty"`
+
+	// The actions of the role.
+	Actions []string `json:"actions,omitempty"`
+
+	// Allows users to set headers on API requests
+	Headers map[string]string
+}
+
+// NewUpdateRoleOptions : Instantiate UpdateRoleOptions
+func (*IamPolicyManagementV1) NewUpdateRoleOptions(roleID string, ifMatch string) *UpdateRoleOptions {
+	return &UpdateRoleOptions{
+		RoleID: core.StringPtr(roleID),
+		IfMatch: core.StringPtr(ifMatch),
+	}
+}
+
+// SetRoleID : Allow user to set RoleID
+func (options *UpdateRoleOptions) SetRoleID(roleID string) *UpdateRoleOptions {
+	options.RoleID = core.StringPtr(roleID)
+	return options
+}
+
+// SetIfMatch : Allow user to set IfMatch
+func (options *UpdateRoleOptions) SetIfMatch(ifMatch string) *UpdateRoleOptions {
+	options.IfMatch = core.StringPtr(ifMatch)
+	return options
+}
+
+// SetDisplayName : Allow user to set DisplayName
+func (options *UpdateRoleOptions) SetDisplayName(displayName string) *UpdateRoleOptions {
+	options.DisplayName = core.StringPtr(displayName)
+	return options
+}
+
+// SetDescription : Allow user to set Description
+func (options *UpdateRoleOptions) SetDescription(description string) *UpdateRoleOptions {
+	options.Description = core.StringPtr(description)
+	return options
+}
+
+// SetActions : Allow user to set Actions
+func (options *UpdateRoleOptions) SetActions(actions []string) *UpdateRoleOptions {
+	options.Actions = actions
+	return options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *UpdateRoleOptions) SetHeaders(param map[string]string) *UpdateRoleOptions {
+	options.Headers = param
+	return options
+}
+
+// CustomRole : An additional set of properties associated with a role.
+type CustomRole struct {
+	// The role ID.
+	ID *string `json:"id,omitempty"`
+
+	// The display name of the role that is shown in the console.
+	DisplayName *string `json:"display_name,omitempty"`
+
+	// The description of the role.
+	Description *string `json:"description,omitempty"`
+
+	// The actions of the role.
+	Actions []string `json:"actions,omitempty"`
+
+	// The role CRN.
+	Crn *string `json:"crn,omitempty"`
+
+	// The name of the role that is used in the CRN. Can only be alphanumeric and has to be capitalized.
+	Name *string `json:"name,omitempty"`
+
+	// The account GUID.
+	AccountID *string `json:"account_id,omitempty"`
+
+	// The service name.
+	ServiceName *string `json:"service_name,omitempty"`
+
+	// The UTC timestamp when the role was created.
+	CreatedAt *strfmt.DateTime `json:"created_at,omitempty"`
+
+	// The iam ID of the entity that created the role.
+	CreatedByID *string `json:"created_by_id,omitempty"`
+
+	// The UTC timestamp when the role was last modified.
+	LastModifiedAt *strfmt.DateTime `json:"last_modified_at,omitempty"`
+
+	// The iam ID of the entity that last modified the policy.
+	LastModifiedByID *string `json:"last_modified_by_id,omitempty"`
+
+	// The href link back to the role.
+	Href *string `json:"href,omitempty"`
+}
+
+
+// UnmarshalCustomRole unmarshals an instance of CustomRole from the specified map of raw messages.
+func UnmarshalCustomRole(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(CustomRole)
+	err = core.UnmarshalPrimitive(m, "id", &obj.ID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "display_name", &obj.DisplayName)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "description", &obj.Description)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "actions", &obj.Actions)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "crn", &obj.Crn)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "name", &obj.Name)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "account_id", &obj.AccountID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "service_name", &obj.ServiceName)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "created_at", &obj.CreatedAt)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "created_by_id", &obj.CreatedByID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "last_modified_at", &obj.LastModifiedAt)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "last_modified_by_id", &obj.LastModifiedByID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "href", &obj.Href)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// Policy : The core set of properties associated with a policy.
+type Policy struct {
+	// The policy ID.
+	ID *string `json:"id,omitempty"`
+
+	// The policy type; either 'access' or 'authorization'.
+	Type *string `json:"type,omitempty"`
+
+	// The subjects associated with a policy.
+	Subjects []PolicySubject `json:"subjects,omitempty"`
+
+	// A set of role cloud resource names (CRNs) granted by the policy.
+	Roles []PolicyRole `json:"roles,omitempty"`
+
+	// The resources associated with a policy.
+	Resources []PolicyResource `json:"resources,omitempty"`
+
+	// The href link back to the policy.
+	Href *string `json:"href,omitempty"`
+
+	// The UTC timestamp when the policy was created.
+	CreatedAt *strfmt.DateTime `json:"created_at,omitempty"`
+
+	// The iam ID of the entity that created the policy.
+	CreatedByID *string `json:"created_by_id,omitempty"`
+
+	// The UTC timestamp when the policy was last modified.
+	LastModifiedAt *strfmt.DateTime `json:"last_modified_at,omitempty"`
+
+	// The iam ID of the entity that last modified the policy.
+	LastModifiedByID *string `json:"last_modified_by_id,omitempty"`
+}
+
+
+// UnmarshalPolicy unmarshals an instance of Policy from the specified map of raw messages.
+func UnmarshalPolicy(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(Policy)
+	err = core.UnmarshalPrimitive(m, "id", &obj.ID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "type", &obj.Type)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(m, "subjects", &obj.Subjects, UnmarshalPolicySubject)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(m, "roles", &obj.Roles, UnmarshalPolicyRole)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalPolicyResource)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "href", &obj.Href)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "created_at", &obj.CreatedAt)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "created_by_id", &obj.CreatedByID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "last_modified_at", &obj.LastModifiedAt)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "last_modified_by_id", &obj.LastModifiedByID)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// PolicyList : A collection of policies.
+type PolicyList struct {
+	// List of policies.
+	Policies []Policy `json:"policies,omitempty"`
+}
+
+
+// UnmarshalPolicyList unmarshals an instance of PolicyList from the specified map of raw messages.
+func UnmarshalPolicyList(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(PolicyList)
+	err = core.UnmarshalModel(m, "policies", &obj.Policies, UnmarshalPolicy)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// PolicyResource : The attributes of the resource. Note that only one resource is allowed in a policy.
+type PolicyResource struct {
+	// List of resource attributes.
+	Attributes []ResourceAttribute `json:"attributes,omitempty"`
+}
+
+
+// UnmarshalPolicyResource unmarshals an instance of PolicyResource from the specified map of raw messages.
+func UnmarshalPolicyResource(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(PolicyResource)
+	err = core.UnmarshalModel(m, "attributes", &obj.Attributes, UnmarshalResourceAttribute)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// PolicyRole : A role associated with a policy.
+type PolicyRole struct {
+	// The role cloud resource name granted by the policy.
+	RoleID *string `json:"role_id" validate:"required"`
+
+	// The display name of the role.
+	DisplayName *string `json:"display_name,omitempty"`
+
+	// The description of the role.
+	Description *string `json:"description,omitempty"`
+}
+
+
+// NewPolicyRole : Instantiate PolicyRole (Generic Model Constructor)
+func (*IamPolicyManagementV1) NewPolicyRole(roleID string) (model *PolicyRole, err error) {
+	model = &PolicyRole{
+		RoleID: core.StringPtr(roleID),
+	}
+	err = core.ValidateStruct(model, "required parameters")
+	return
+}
+
+// UnmarshalPolicyRole unmarshals an instance of PolicyRole from the specified map of raw messages.
+func UnmarshalPolicyRole(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(PolicyRole)
+	err = core.UnmarshalPrimitive(m, "role_id", &obj.RoleID)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "display_name", &obj.DisplayName)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "description", &obj.Description)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// PolicySubject : The subject attribute values that must match in order for this policy to apply in a permission decision.
+type PolicySubject struct {
+	// List of subject attributes.
+	Attributes []SubjectAttribute `json:"attributes,omitempty"`
+}
+
+
+// UnmarshalPolicySubject unmarshals an instance of PolicySubject from the specified map of raw messages.
+func UnmarshalPolicySubject(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(PolicySubject)
+	err = core.UnmarshalModel(m, "attributes", &obj.Attributes, UnmarshalSubjectAttribute)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// ResourceAttribute : An attribute associated with a resource.
+type ResourceAttribute struct {
+	// The name of an attribute.
+	Name *string `json:"name" validate:"required"`
+
+	// The value of an attribute.
+	Value *string `json:"value" validate:"required"`
+
+	// The operator of an attribute.
+	Operator *string `json:"operator,omitempty"`
+}
+
+
+// NewResourceAttribute : Instantiate ResourceAttribute (Generic Model Constructor)
+func (*IamPolicyManagementV1) NewResourceAttribute(name string, value string) (model *ResourceAttribute, err error) {
+	model = &ResourceAttribute{
+		Name: core.StringPtr(name),
+		Value: core.StringPtr(value),
+	}
+	err = core.ValidateStruct(model, "required parameters")
+	return
+}
+
+// UnmarshalResourceAttribute unmarshals an instance of ResourceAttribute from the specified map of raw messages.
+func UnmarshalResourceAttribute(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(ResourceAttribute)
+	err = core.UnmarshalPrimitive(m, "name", &obj.Name)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "value", &obj.Value)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "operator", &obj.Operator)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// Role : A role resource.
+type Role struct {
+	// The display name of the role that is shown in the console.
+	DisplayName *string `json:"display_name,omitempty"`
+
+	// The description of the role.
+	Description *string `json:"description,omitempty"`
+
+	// The actions of the role.
+	Actions []string `json:"actions,omitempty"`
+
+	// The role CRN.
+	Crn *string `json:"crn,omitempty"`
+}
+
+
+// UnmarshalRole unmarshals an instance of Role from the specified map of raw messages.
+func UnmarshalRole(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(Role)
+	err = core.UnmarshalPrimitive(m, "display_name", &obj.DisplayName)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "description", &obj.Description)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "actions", &obj.Actions)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "crn", &obj.Crn)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// RoleList : A collection of roles returned by the 'list roles' operation.
+type RoleList struct {
+	// List of custom roles.
+	CustomRoles []CustomRole `json:"custom_roles,omitempty"`
+
+	// List of service roles.
+	ServiceRoles []Role `json:"service_roles,omitempty"`
+
+	// List of system roles.
+	SystemRoles []Role `json:"system_roles,omitempty"`
+}
+
+
+// UnmarshalRoleList unmarshals an instance of RoleList from the specified map of raw messages.
+func UnmarshalRoleList(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(RoleList)
+	err = core.UnmarshalModel(m, "custom_roles", &obj.CustomRoles, UnmarshalCustomRole)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(m, "service_roles", &obj.ServiceRoles, UnmarshalRole)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalModel(m, "system_roles", &obj.SystemRoles, UnmarshalRole)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
+
+// SubjectAttribute : An attribute associated with a subject.
+type SubjectAttribute struct {
+	// The name of an attribute.
+	Name *string `json:"name" validate:"required"`
+
+	// The value of an attribute.
+	Value *string `json:"value" validate:"required"`
+}
+
+
+// NewSubjectAttribute : Instantiate SubjectAttribute (Generic Model Constructor)
+func (*IamPolicyManagementV1) NewSubjectAttribute(name string, value string) (model *SubjectAttribute, err error) {
+	model = &SubjectAttribute{
+		Name: core.StringPtr(name),
+		Value: core.StringPtr(value),
+	}
+	err = core.ValidateStruct(model, "required parameters")
+	return
+}
+
+// UnmarshalSubjectAttribute unmarshals an instance of SubjectAttribute from the specified map of raw messages.
+func UnmarshalSubjectAttribute(m map[string]json.RawMessage, result interface{}) (err error) {
+	obj := new(SubjectAttribute)
+	err = core.UnmarshalPrimitive(m, "name", &obj.Name)
+	if err != nil {
+		return
+	}
+	err = core.UnmarshalPrimitive(m, "value", &obj.Value)
+	if err != nil {
+		return
+	}
+	reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+	return
+}
diff --git a/iampolicymanagementv1/iam_policy_management_v1_integration_test.go b/iampolicymanagementv1/iam_policy_management_v1_integration_test.go
new file mode 100644
index 00000000..7ee95f0f
--- /dev/null
+++ b/iampolicymanagementv1/iam_policy_management_v1_integration_test.go
@@ -0,0 +1,377 @@
+// +build integration
+
+/**
+ * (C) Copyright IBM Corp. 2020.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package iampolicymanagementv1_test
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"strconv"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/IBM/go-sdk-core/v4/core"
+	"github.com/IBM/platform-services-go-sdk/iampolicymanagementv1"
+)
+
+const externalConfigFile = "../iam_policy_management.env"
+
+var (
+	service      *iampolicymanagementv1.IamPolicyManagementV1
+	err          error
+	config       map[string]string
+	configLoaded bool = false
+
+	testAccountID     string
+	etagHeader        string = "ETag"
+	testPolicyETag    string = ""
+	testPolicyId      string = ""
+	testUserId        string = "IBMid-GoSDK" + strconv.Itoa(rand.Intn(100000))
+	testViewerRoleCrn string = "crn:v1:bluemix:public:iam::::role:Viewer"
+	testEditorRoleCrn string = "crn:v1:bluemix:public:iam::::role:Editor"
+	testServiceName   string = "iam-groups"
+
+	testCustomRoleId   string = ""
+	testCustomRoleETag string = ""
+	testCustomRoleName string = "TestGoRole" + strconv.Itoa(rand.Intn(100000))
+)
+
+func shouldSkipTest() {
+	if !configLoaded {
+		Skip("External configuration is not available, skipping...")
+	}
+}
+
+var _ = Describe("IAM Policy Management - Integration Tests", func() {
+	It("Successfully load the configuration", func() {
+		err = os.Setenv("IBM_CREDENTIALS_FILE", externalConfigFile)
+		if err != nil {
+			Skip("Could not set IBM_CREDENTIALS_FILE environment variable: " + err.Error())
+		}
+
+		config, err = core.GetServiceProperties(iampolicymanagementv1.DefaultServiceName)
+		if err == nil {
+			testAccountID = config["TEST_ACCOUNT_ID"]
+			if testAccountID != "" {
+				configLoaded = true
+			}
+		}
+		if !configLoaded {
+			Skip("External configuration could not be loaded, skipping...")
+		}
+	})
+
+	It(`Successfully created IamPolicyManagementV1 service instance`, func() {
+		shouldSkipTest()
+
+		service, err = iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(
+			&iampolicymanagementv1.IamPolicyManagementV1Options{},
+		)
+
+		Expect(err).To(BeNil())
+		Expect(service).ToNot(BeNil())
+	})
+
+	Describe("Create an access policy", func() {
+
+		It("Successfully created an access policy", func() {
+			shouldSkipTest()
+
+			// Construct an instance of the ResourceAttribute model
+			accountIdResourceAttribute := new(iampolicymanagementv1.ResourceAttribute)
+			accountIdResourceAttribute.Name = core.StringPtr("accountId")
+			accountIdResourceAttribute.Value = core.StringPtr(testAccountID)
+			accountIdResourceAttribute.Operator = core.StringPtr("stringEquals")
+
+			serviceNameResourceAttribute := new(iampolicymanagementv1.ResourceAttribute)
+			serviceNameResourceAttribute.Name = core.StringPtr("serviceName")
+			serviceNameResourceAttribute.Value = core.StringPtr(testServiceName)
+			serviceNameResourceAttribute.Operator = core.StringPtr("stringEquals")
+
+			// Construct an instance of the SubjectAttribute model
+			subjectAttribute := new(iampolicymanagementv1.SubjectAttribute)
+			subjectAttribute.Name = core.StringPtr("iam_id")
+			subjectAttribute.Value = core.StringPtr(testUserId)
+
+			// Construct an instance of the PolicyResource model
+			policyResource := new(iampolicymanagementv1.PolicyResource)
+			policyResource.Attributes = []iampolicymanagementv1.ResourceAttribute{*accountIdResourceAttribute, *serviceNameResourceAttribute}
+
+			// Construct an instance of the PolicyRole model
+			policyRole := new(iampolicymanagementv1.PolicyRole)
+			policyRole.RoleID = core.StringPtr(testViewerRoleCrn)
+
+			// Construct an instance of the PolicySubject model
+			policySubject := new(iampolicymanagementv1.PolicySubject)
+			policySubject.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttribute}
+
+			// Construct an instance of the CreatePolicyOptions model
+			options := new(iampolicymanagementv1.CreatePolicyOptions)
+			options.Type = core.StringPtr("access")
+			options.Subjects = []iampolicymanagementv1.PolicySubject{*policySubject}
+			options.Roles = []iampolicymanagementv1.PolicyRole{*policyRole}
+			options.Resources = []iampolicymanagementv1.PolicyResource{*policyResource}
+			options.AcceptLanguage = core.StringPtr("en")
+
+			policy, detailedResponse, err := service.CreatePolicy(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(201))
+			Expect(policy.Type).To(Equal(options.Type))
+			Expect(policy.Subjects).To(Equal(options.Subjects))
+			Expect(policy.Roles[0].RoleID).To(Equal(options.Roles[0].RoleID))
+			Expect(policy.Resources).To(Equal(options.Resources))
+
+			testPolicyId = *policy.ID
+		})
+	})
+
+	Describe("Get an access policy", func() {
+
+		It("Successfully retrieved an access policy", func() {
+			shouldSkipTest()
+			Expect(testPolicyId).To(Not(BeNil()))
+
+			options := service.NewGetPolicyOptions(testPolicyId)
+			result, detailedResponse, err := service.GetPolicy(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+			Expect(*result.ID).To(Equal(testPolicyId))
+
+			testPolicyETag = detailedResponse.GetHeaders().Get(etagHeader)
+		})
+	})
+
+	Describe("Update an access policy", func() {
+
+		It("Successfully updated an access policy", func() {
+			shouldSkipTest()
+			Expect(testPolicyId).To(Not(BeNil()))
+			Expect(testPolicyETag).To(Not(BeNil()))
+
+			// Construct an instance of the ResourceAttribute model
+			accountIdResourceAttribute := new(iampolicymanagementv1.ResourceAttribute)
+			accountIdResourceAttribute.Name = core.StringPtr("accountId")
+			accountIdResourceAttribute.Value = core.StringPtr(testAccountID)
+			accountIdResourceAttribute.Operator = core.StringPtr("stringEquals")
+
+			serviceNameResourceAttribute := new(iampolicymanagementv1.ResourceAttribute)
+			serviceNameResourceAttribute.Name = core.StringPtr("serviceName")
+			serviceNameResourceAttribute.Value = core.StringPtr(testServiceName)
+			serviceNameResourceAttribute.Operator = core.StringPtr("stringEquals")
+
+			// Construct an instance of the SubjectAttribute model
+			subjectAttribute := new(iampolicymanagementv1.SubjectAttribute)
+			subjectAttribute.Name = core.StringPtr("iam_id")
+			subjectAttribute.Value = core.StringPtr(testUserId)
+
+			// Construct an instance of the PolicyResource model
+			policyResource := new(iampolicymanagementv1.PolicyResource)
+			policyResource.Attributes = []iampolicymanagementv1.ResourceAttribute{*accountIdResourceAttribute, *serviceNameResourceAttribute}
+
+			// Construct an instance of the PolicyRole model
+			policyRole := new(iampolicymanagementv1.PolicyRole)
+			policyRole.RoleID = core.StringPtr(testEditorRoleCrn)
+
+			// Construct an instance of the PolicySubject model
+			policySubject := new(iampolicymanagementv1.PolicySubject)
+			policySubject.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttribute}
+
+			// Construct an instance of the CreatePolicyOptions model
+			options := new(iampolicymanagementv1.UpdatePolicyOptions)
+			options.PolicyID = core.StringPtr(testPolicyId)
+			options.IfMatch = core.StringPtr(testPolicyETag)
+			options.Type = core.StringPtr("access")
+			options.Subjects = []iampolicymanagementv1.PolicySubject{*policySubject}
+			options.Roles = []iampolicymanagementv1.PolicyRole{*policyRole}
+			options.Resources = []iampolicymanagementv1.PolicyResource{*policyResource}
+
+			policy, detailedResponse, err := service.UpdatePolicy(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+			Expect(*policy.ID).To(Equal(testPolicyId))
+			Expect(policy.Type).To(Equal(options.Type))
+			Expect(policy.Subjects).To(Equal(options.Subjects))
+			Expect(policy.Roles[0].RoleID).To(Equal(options.Roles[0].RoleID))
+			Expect(policy.Resources).To(Equal(options.Resources))
+
+		})
+	})
+
+	Describe("List access policies", func() {
+
+		It("Successfully listed the account's access policies", func() {
+			shouldSkipTest()
+			Expect(testPolicyId).To(Not(BeNil()))
+
+			options := service.NewListPoliciesOptions(testAccountID)
+			options.SetIamID(testUserId)
+			result, detailedResponse, err := service.ListPolicies(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+
+			// confirm the test policy is present
+			testPolicyPresent := false
+			for _, policy := range result.Policies {
+				if *policy.ID == testPolicyId {
+					testPolicyPresent = true
+				}
+			}
+			Expect(testPolicyPresent).To(BeTrue())
+		})
+	})
+
+	Describe("Create custom role", func() {
+		It("Successfully created custom role", func() {
+			shouldSkipTest()
+
+			actions := []string{"iam-groups.groups.read"}
+			options := service.NewCreateRoleOptions(
+				testCustomRoleName,
+				actions,
+				testCustomRoleName,
+				testAccountID,
+				testServiceName)
+			options.SetDescription("GO SDK test role")
+			result, detailedResponse, err := service.CreateRole(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(201))
+
+			testCustomRoleId = *result.ID
+		})
+	})
+
+	Describe("Get a custom role", func() {
+		It("Successfully retrieved a custom role", func() {
+			shouldSkipTest()
+			Expect(testCustomRoleId).To(Not(BeNil()))
+
+			options := service.NewGetRoleOptions(testCustomRoleId)
+			result, detailedResponse, err := service.GetRole(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+			Expect(*result.ID).To(Equal(testCustomRoleId))
+
+			testCustomRoleETag = detailedResponse.GetHeaders().Get(etagHeader)
+		})
+	})
+
+	Describe("Update custom roles", func() {
+		It("Successfully updated a custom role", func() {
+			shouldSkipTest()
+			Expect(testCustomRoleId).To(Not(BeNil()))
+			Expect(testPolicyETag).To(Not(BeNil()))
+
+			options := service.NewUpdateRoleOptions(
+				testCustomRoleId,
+				testCustomRoleETag)
+			options.SetDescription("GO SDK test role udpated")
+			options.SetDisplayName("GO SDK test role udpated")
+			result, detailedResponse, err := service.UpdateRole(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+			Expect(*result.ID).To(Equal(testCustomRoleId))
+
+		})
+	})
+
+	Describe("List custom roles", func() {
+		It("Successfully listed the account's custom roles", func() {
+			shouldSkipTest()
+			Expect(testCustomRoleId).To(Not(BeNil()))
+
+			options := service.NewListRolesOptions()
+			options.SetAccountID(testAccountID)
+			result, detailedResponse, err := service.ListRoles(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(200))
+
+			// confirm the test policy is present
+			testRolePresent := false
+			for _, role := range result.CustomRoles {
+				if *role.ID == testCustomRoleId {
+					testRolePresent = true
+				}
+			}
+			Expect(testRolePresent).To(BeTrue())
+		})
+	})
+
+})
+
+// clean up all test groups
+var _ = AfterSuite(func() {
+	if !configLoaded {
+		return
+	}
+
+	// list all policies in the account
+	policyOptions := service.NewListPoliciesOptions(testAccountID)
+	policyOptions.SetIamID(testUserId)
+	policyResult, policyDetailedResponse, err := service.ListPolicies(policyOptions)
+	Expect(err).To(BeNil())
+	Expect(policyDetailedResponse.StatusCode).To(Equal(200))
+
+	for _, policy := range policyResult.Policies {
+
+		// delete the test policy (or any test policy older than 5 minutes)
+		createdAt, err := time.Parse(time.RFC3339, policy.CreatedAt.String())
+		if err != nil {
+			fmt.Printf("time.Parse error occurred: %v", err)
+			fmt.Printf("Cleanup of policy (%v) failed", *policy.ID)
+			continue
+		}
+		fiveMinutesAgo := time.Now().Add(-(time.Duration(5) * time.Minute))
+
+		if *policy.ID == testPolicyId || createdAt.Before(fiveMinutesAgo) {
+			options := service.NewDeletePolicyOptions(*policy.ID)
+			detailedResponse, err := service.DeletePolicy(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(204))
+		}
+	}
+
+	// List all custom roles in the account
+	roleOptions := service.NewListRolesOptions()
+	roleOptions.SetAccountID(testAccountID)
+	roleResult, roleDetailedResponse, err := service.ListRoles(roleOptions)
+	Expect(err).To(BeNil())
+	Expect(roleDetailedResponse.StatusCode).To(Equal(200))
+
+	for _, role := range roleResult.CustomRoles {
+
+		// delete the role (or any test role older than 5 minutes)
+		createdAt, err := time.Parse(time.RFC3339, role.CreatedAt.String())
+		if err != nil {
+			fmt.Printf("time.Parse error occurred: %v", err)
+			fmt.Printf("Cleanup of role (%v) failed", *role.ID)
+			continue
+		}
+		fiveMinutesAgo := time.Now().Add(-(time.Duration(5) * time.Minute))
+
+		if *role.ID == testCustomRoleId || createdAt.Before(fiveMinutesAgo) {
+			options := service.NewDeleteRoleOptions(*role.ID)
+			detailedResponse, err := service.DeleteRole(options)
+			Expect(err).To(BeNil())
+			Expect(detailedResponse.StatusCode).To(Equal(204))
+		}
+	}
+
+})
diff --git a/iampolicymanagementv1/iam_policy_management_v1_suite_test.go b/iampolicymanagementv1/iam_policy_management_v1_suite_test.go
new file mode 100644
index 00000000..2f43fb0d
--- /dev/null
+++ b/iampolicymanagementv1/iam_policy_management_v1_suite_test.go
@@ -0,0 +1,28 @@
+/**
+ * (C) Copyright IBM Corp. 2020.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package iampolicymanagementv1_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"testing"
+)
+
+func TestIamPolicyManagementV1(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "IamPolicyManagementV1 Suite")
+}
diff --git a/iampolicymanagementv1/iam_policy_management_v1_test.go b/iampolicymanagementv1/iam_policy_management_v1_test.go
new file mode 100644
index 00000000..9c9f7f44
--- /dev/null
+++ b/iampolicymanagementv1/iam_policy_management_v1_test.go
@@ -0,0 +1,1857 @@
+/**
+ * (C) Copyright IBM Corp. 2020.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package iampolicymanagementv1_test
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/IBM/go-sdk-core/v4/core"
+	"github.com/IBM/platform-services-go-sdk/iampolicymanagementv1"
+	"github.com/go-openapi/strfmt"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"time"
+)
+
+var _ = Describe(`IamPolicyManagementV1`, func() {
+	var testServer *httptest.Server
+    Describe(`Service constructor tests`, func() {
+		It(`Instantiate service client`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				Authenticator: &core.NoAuthAuthenticator{},
+			})
+			Expect(testService).ToNot(BeNil())
+			Expect(testServiceErr).To(BeNil())
+		})
+		It(`Instantiate service client with error: Invalid URL`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "{BAD_URL_STRING",
+			})
+			Expect(testService).To(BeNil())
+			Expect(testServiceErr).ToNot(BeNil())
+		})
+		It(`Instantiate service client with error: Invalid Auth`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "https://iampolicymanagementv1/api",
+				Authenticator: &core.BasicAuthenticator{
+					Username: "",
+					Password: "",
+				},
+			})
+			Expect(testService).To(BeNil())
+			Expect(testServiceErr).ToNot(BeNil())
+		})
+	})
+	Describe(`Service constructor tests using external config`, func() {
+		Context(`Using external config, construct service client instances`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_URL": "https://iampolicymanagementv1/api",
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE": "noauth",
+			}
+
+			It(`Create service client using external config successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				})
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+			It(`Create service client using external config and set url from constructor successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL: "https://testService/api",
+				})
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService.Service.GetServiceURL()).To(Equal("https://testService/api"))
+				ClearTestEnvironment(testEnvironment)
+			})
+			It(`Create service client using external config and set url programatically successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				})
+				err := testService.SetServiceURL("https://testService/api")
+				Expect(err).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService.Service.GetServiceURL()).To(Equal("https://testService/api"))
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+		Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_URL": "https://iampolicymanagementv1/api",
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE": "someOtherAuth",
+			}
+
+			SetTestEnvironment(testEnvironment)
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+			})
+
+			It(`Instantiate service client with error`, func() {
+				Expect(testService).To(BeNil())
+				Expect(testServiceErr).ToNot(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+		Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE":   "NOAuth",
+			}
+
+			SetTestEnvironment(testEnvironment)
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "{BAD_URL_STRING",
+			})
+
+			It(`Instantiate service client with error`, func() {
+				Expect(testService).To(BeNil())
+				Expect(testServiceErr).ToNot(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+	})
+	Describe(`ListPolicies(listPoliciesOptions *ListPoliciesOptions) - Operation response error`, func() {
+		listPoliciesPath := "/v1/policies"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(listPoliciesPath))
+					Expect(req.Method).To(Equal("GET"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["iam_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["access_group_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["type"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["service_type"]).To(Equal([]string{"testString"}))
+
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke ListPolicies with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ListPoliciesOptions model
+				listPoliciesOptionsModel := new(iampolicymanagementv1.ListPoliciesOptions)
+				listPoliciesOptionsModel.AccountID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listPoliciesOptionsModel.IamID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AccessGroupID = core.StringPtr("testString")
+				listPoliciesOptionsModel.Type = core.StringPtr("testString")
+				listPoliciesOptionsModel.ServiceType = core.StringPtr("testString")
+				listPoliciesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.ListPolicies(listPoliciesOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`ListPolicies(listPoliciesOptions *ListPoliciesOptions)`, func() {
+		listPoliciesPath := "/v1/policies"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(listPoliciesPath))
+					Expect(req.Method).To(Equal("GET"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["iam_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["access_group_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["type"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["service_type"]).To(Equal([]string{"testString"}))
+
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"policies": [{"id": "ID", "type": "Type", "subjects": [{"attributes": [{"name": "Name", "value": "Value"}]}], "roles": [{"role_id": "RoleID", "display_name": "DisplayName", "description": "Description"}], "resources": [{"attributes": [{"name": "Name", "value": "Value", "operator": "Operator"}]}], "href": "Href", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID"}]}`)
+				}))
+			})
+			It(`Invoke ListPolicies successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.ListPolicies(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the ListPoliciesOptions model
+				listPoliciesOptionsModel := new(iampolicymanagementv1.ListPoliciesOptions)
+				listPoliciesOptionsModel.AccountID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listPoliciesOptionsModel.IamID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AccessGroupID = core.StringPtr("testString")
+				listPoliciesOptionsModel.Type = core.StringPtr("testString")
+				listPoliciesOptionsModel.ServiceType = core.StringPtr("testString")
+ 				listPoliciesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.ListPolicies(listPoliciesOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke ListPolicies with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ListPoliciesOptions model
+				listPoliciesOptionsModel := new(iampolicymanagementv1.ListPoliciesOptions)
+				listPoliciesOptionsModel.AccountID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listPoliciesOptionsModel.IamID = core.StringPtr("testString")
+				listPoliciesOptionsModel.AccessGroupID = core.StringPtr("testString")
+				listPoliciesOptionsModel.Type = core.StringPtr("testString")
+				listPoliciesOptionsModel.ServiceType = core.StringPtr("testString")
+				listPoliciesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.ListPolicies(listPoliciesOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the ListPoliciesOptions model with no property values
+				listPoliciesOptionsModelNew := new(iampolicymanagementv1.ListPoliciesOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.ListPolicies(listPoliciesOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`CreatePolicy(createPolicyOptions *CreatePolicyOptions) - Operation response error`, func() {
+		createPolicyPath := "/v1/policies"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(createPolicyPath))
+					Expect(req.Method).To(Equal("POST"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(201)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke CreatePolicy with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the CreatePolicyOptions model
+				createPolicyOptionsModel := new(iampolicymanagementv1.CreatePolicyOptions)
+				createPolicyOptionsModel.Type = core.StringPtr("testString")
+				createPolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				createPolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				createPolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+				createPolicyOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				createPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.CreatePolicy(createPolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`CreatePolicy(createPolicyOptions *CreatePolicyOptions)`, func() {
+		createPolicyPath := "/v1/policies"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(createPolicyPath))
+					Expect(req.Method).To(Equal("POST"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(201)
+					fmt.Fprintf(res, `{"id": "ID", "type": "Type", "subjects": [{"attributes": [{"name": "Name", "value": "Value"}]}], "roles": [{"role_id": "RoleID", "display_name": "DisplayName", "description": "Description"}], "resources": [{"attributes": [{"name": "Name", "value": "Value", "operator": "Operator"}]}], "href": "Href", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID"}`)
+				}))
+			})
+			It(`Invoke CreatePolicy successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.CreatePolicy(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the CreatePolicyOptions model
+				createPolicyOptionsModel := new(iampolicymanagementv1.CreatePolicyOptions)
+				createPolicyOptionsModel.Type = core.StringPtr("testString")
+				createPolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				createPolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				createPolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+				createPolicyOptionsModel.AcceptLanguage = core.StringPtr("testString")
+ 				createPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.CreatePolicy(createPolicyOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke CreatePolicy with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the CreatePolicyOptions model
+				createPolicyOptionsModel := new(iampolicymanagementv1.CreatePolicyOptions)
+				createPolicyOptionsModel.Type = core.StringPtr("testString")
+				createPolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				createPolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				createPolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+				createPolicyOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				createPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.CreatePolicy(createPolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the CreatePolicyOptions model with no property values
+				createPolicyOptionsModelNew := new(iampolicymanagementv1.CreatePolicyOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.CreatePolicy(createPolicyOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`UpdatePolicy(updatePolicyOptions *UpdatePolicyOptions) - Operation response error`, func() {
+		updatePolicyPath := "/v1/policies/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(updatePolicyPath))
+					Expect(req.Method).To(Equal("PUT"))
+					Expect(req.Header["If-Match"]).ToNot(BeNil())
+					Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke UpdatePolicy with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the UpdatePolicyOptions model
+				updatePolicyOptionsModel := new(iampolicymanagementv1.UpdatePolicyOptions)
+				updatePolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				updatePolicyOptionsModel.IfMatch = core.StringPtr("testString")
+				updatePolicyOptionsModel.Type = core.StringPtr("testString")
+				updatePolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				updatePolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				updatePolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+				updatePolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.UpdatePolicy(updatePolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`UpdatePolicy(updatePolicyOptions *UpdatePolicyOptions)`, func() {
+		updatePolicyPath := "/v1/policies/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(updatePolicyPath))
+					Expect(req.Method).To(Equal("PUT"))
+					Expect(req.Header["If-Match"]).ToNot(BeNil())
+					Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"id": "ID", "type": "Type", "subjects": [{"attributes": [{"name": "Name", "value": "Value"}]}], "roles": [{"role_id": "RoleID", "display_name": "DisplayName", "description": "Description"}], "resources": [{"attributes": [{"name": "Name", "value": "Value", "operator": "Operator"}]}], "href": "Href", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID"}`)
+				}))
+			})
+			It(`Invoke UpdatePolicy successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.UpdatePolicy(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the UpdatePolicyOptions model
+				updatePolicyOptionsModel := new(iampolicymanagementv1.UpdatePolicyOptions)
+				updatePolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				updatePolicyOptionsModel.IfMatch = core.StringPtr("testString")
+				updatePolicyOptionsModel.Type = core.StringPtr("testString")
+				updatePolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				updatePolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				updatePolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+ 				updatePolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.UpdatePolicy(updatePolicyOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke UpdatePolicy with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				policyRoleModel.RoleID = core.StringPtr("testString")
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+
+				// Construct an instance of the UpdatePolicyOptions model
+				updatePolicyOptionsModel := new(iampolicymanagementv1.UpdatePolicyOptions)
+				updatePolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				updatePolicyOptionsModel.IfMatch = core.StringPtr("testString")
+				updatePolicyOptionsModel.Type = core.StringPtr("testString")
+				updatePolicyOptionsModel.Subjects = []iampolicymanagementv1.PolicySubject{*policySubjectModel}
+				updatePolicyOptionsModel.Roles = []iampolicymanagementv1.PolicyRole{*policyRoleModel}
+				updatePolicyOptionsModel.Resources = []iampolicymanagementv1.PolicyResource{*policyResourceModel}
+				updatePolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.UpdatePolicy(updatePolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the UpdatePolicyOptions model with no property values
+				updatePolicyOptionsModelNew := new(iampolicymanagementv1.UpdatePolicyOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.UpdatePolicy(updatePolicyOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`GetPolicy(getPolicyOptions *GetPolicyOptions) - Operation response error`, func() {
+		getPolicyPath := "/v1/policies/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(getPolicyPath))
+					Expect(req.Method).To(Equal("GET"))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke GetPolicy with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the GetPolicyOptions model
+				getPolicyOptionsModel := new(iampolicymanagementv1.GetPolicyOptions)
+				getPolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				getPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.GetPolicy(getPolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`GetPolicy(getPolicyOptions *GetPolicyOptions)`, func() {
+		getPolicyPath := "/v1/policies/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(getPolicyPath))
+					Expect(req.Method).To(Equal("GET"))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"id": "ID", "type": "Type", "subjects": [{"attributes": [{"name": "Name", "value": "Value"}]}], "roles": [{"role_id": "RoleID", "display_name": "DisplayName", "description": "Description"}], "resources": [{"attributes": [{"name": "Name", "value": "Value", "operator": "Operator"}]}], "href": "Href", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID"}`)
+				}))
+			})
+			It(`Invoke GetPolicy successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.GetPolicy(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the GetPolicyOptions model
+				getPolicyOptionsModel := new(iampolicymanagementv1.GetPolicyOptions)
+				getPolicyOptionsModel.PolicyID = core.StringPtr("testString")
+ 				getPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.GetPolicy(getPolicyOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke GetPolicy with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the GetPolicyOptions model
+				getPolicyOptionsModel := new(iampolicymanagementv1.GetPolicyOptions)
+				getPolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				getPolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.GetPolicy(getPolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the GetPolicyOptions model with no property values
+				getPolicyOptionsModelNew := new(iampolicymanagementv1.GetPolicyOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.GetPolicy(getPolicyOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`DeletePolicy(deletePolicyOptions *DeletePolicyOptions)`, func() {
+		deletePolicyPath := "/v1/policies/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(deletePolicyPath))
+					Expect(req.Method).To(Equal("DELETE"))
+					res.WriteHeader(204)
+				}))
+			})
+			It(`Invoke DeletePolicy successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				response, operationErr := testService.DeletePolicy(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+
+				// Construct an instance of the DeletePolicyOptions model
+				deletePolicyOptionsModel := new(iampolicymanagementv1.DeletePolicyOptions)
+				deletePolicyOptionsModel.PolicyID = core.StringPtr("testString")
+ 				deletePolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				response, operationErr = testService.DeletePolicy(deletePolicyOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+			})
+			It(`Invoke DeletePolicy with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the DeletePolicyOptions model
+				deletePolicyOptionsModel := new(iampolicymanagementv1.DeletePolicyOptions)
+				deletePolicyOptionsModel.PolicyID = core.StringPtr("testString")
+				deletePolicyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				response, operationErr := testService.DeletePolicy(deletePolicyOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				// Construct a second instance of the DeletePolicyOptions model with no property values
+				deletePolicyOptionsModelNew := new(iampolicymanagementv1.DeletePolicyOptions)
+				// Invoke operation with invalid model (negative test)
+				response, operationErr = testService.DeletePolicy(deletePolicyOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+    Describe(`Service constructor tests`, func() {
+		It(`Instantiate service client`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				Authenticator: &core.NoAuthAuthenticator{},
+			})
+			Expect(testService).ToNot(BeNil())
+			Expect(testServiceErr).To(BeNil())
+		})
+		It(`Instantiate service client with error: Invalid URL`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "{BAD_URL_STRING",
+			})
+			Expect(testService).To(BeNil())
+			Expect(testServiceErr).ToNot(BeNil())
+		})
+		It(`Instantiate service client with error: Invalid Auth`, func() {
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "https://iampolicymanagementv1/api",
+				Authenticator: &core.BasicAuthenticator{
+					Username: "",
+					Password: "",
+				},
+			})
+			Expect(testService).To(BeNil())
+			Expect(testServiceErr).ToNot(BeNil())
+		})
+	})
+	Describe(`Service constructor tests using external config`, func() {
+		Context(`Using external config, construct service client instances`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_URL": "https://iampolicymanagementv1/api",
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE": "noauth",
+			}
+
+			It(`Create service client using external config successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				})
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+			It(`Create service client using external config and set url from constructor successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL: "https://testService/api",
+				})
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService.Service.GetServiceURL()).To(Equal("https://testService/api"))
+				ClearTestEnvironment(testEnvironment)
+			})
+			It(`Create service client using external config and set url programatically successfully`, func() {
+				SetTestEnvironment(testEnvironment)
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				})
+				err := testService.SetServiceURL("https://testService/api")
+				Expect(err).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService.Service.GetServiceURL()).To(Equal("https://testService/api"))
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+		Context(`Using external config, construct service client instances with error: Invalid Auth`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_URL": "https://iampolicymanagementv1/api",
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE": "someOtherAuth",
+			}
+
+			SetTestEnvironment(testEnvironment)
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+			})
+
+			It(`Instantiate service client with error`, func() {
+				Expect(testService).To(BeNil())
+				Expect(testServiceErr).ToNot(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+		Context(`Using external config, construct service client instances with error: Invalid URL`, func() {
+			// Map containing environment variables used in testing.
+			var testEnvironment = map[string]string{
+				"IAM_POLICY_MANAGEMENT_AUTH_TYPE":   "NOAuth",
+			}
+
+			SetTestEnvironment(testEnvironment)
+			testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1UsingExternalConfig(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL: "{BAD_URL_STRING",
+			})
+
+			It(`Instantiate service client with error`, func() {
+				Expect(testService).To(BeNil())
+				Expect(testServiceErr).ToNot(BeNil())
+				ClearTestEnvironment(testEnvironment)
+			})
+		})
+	})
+	Describe(`ListRoles(listRolesOptions *ListRolesOptions) - Operation response error`, func() {
+		listRolesPath := "/v2/roles"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(listRolesPath))
+					Expect(req.Method).To(Equal("GET"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["service_name"]).To(Equal([]string{"testString"}))
+
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke ListRoles with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ListRolesOptions model
+				listRolesOptionsModel := new(iampolicymanagementv1.ListRolesOptions)
+				listRolesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listRolesOptionsModel.AccountID = core.StringPtr("testString")
+				listRolesOptionsModel.ServiceName = core.StringPtr("testString")
+				listRolesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.ListRoles(listRolesOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`ListRoles(listRolesOptions *ListRolesOptions)`, func() {
+		listRolesPath := "/v2/roles"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(listRolesPath))
+					Expect(req.Method).To(Equal("GET"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"}))
+
+					Expect(req.URL.Query()["service_name"]).To(Equal([]string{"testString"}))
+
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"custom_roles": [{"id": "ID", "display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn", "name": "Name", "account_id": "AccountID", "service_name": "ServiceName", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID", "href": "Href"}], "service_roles": [{"display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn"}], "system_roles": [{"display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn"}]}`)
+				}))
+			})
+			It(`Invoke ListRoles successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.ListRoles(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the ListRolesOptions model
+				listRolesOptionsModel := new(iampolicymanagementv1.ListRolesOptions)
+				listRolesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listRolesOptionsModel.AccountID = core.StringPtr("testString")
+				listRolesOptionsModel.ServiceName = core.StringPtr("testString")
+ 				listRolesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.ListRoles(listRolesOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke ListRoles with error: Operation request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the ListRolesOptions model
+				listRolesOptionsModel := new(iampolicymanagementv1.ListRolesOptions)
+				listRolesOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				listRolesOptionsModel.AccountID = core.StringPtr("testString")
+				listRolesOptionsModel.ServiceName = core.StringPtr("testString")
+				listRolesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.ListRoles(listRolesOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`CreateRole(createRoleOptions *CreateRoleOptions) - Operation response error`, func() {
+		createRolePath := "/v2/roles"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(createRolePath))
+					Expect(req.Method).To(Equal("POST"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(201)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke CreateRole with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the CreateRoleOptions model
+				createRoleOptionsModel := new(iampolicymanagementv1.CreateRoleOptions)
+				createRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				createRoleOptionsModel.Actions = []string{"testString"}
+				createRoleOptionsModel.Name = core.StringPtr("testString")
+				createRoleOptionsModel.AccountID = core.StringPtr("testString")
+				createRoleOptionsModel.ServiceName = core.StringPtr("testString")
+				createRoleOptionsModel.Description = core.StringPtr("testString")
+				createRoleOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				createRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.CreateRole(createRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`CreateRole(createRoleOptions *CreateRoleOptions)`, func() {
+		createRolePath := "/v2/roles"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(createRolePath))
+					Expect(req.Method).To(Equal("POST"))
+					Expect(req.Header["Accept-Language"]).ToNot(BeNil())
+					Expect(req.Header["Accept-Language"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(201)
+					fmt.Fprintf(res, `{"id": "ID", "display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn", "name": "Name", "account_id": "AccountID", "service_name": "ServiceName", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID", "href": "Href"}`)
+				}))
+			})
+			It(`Invoke CreateRole successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.CreateRole(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the CreateRoleOptions model
+				createRoleOptionsModel := new(iampolicymanagementv1.CreateRoleOptions)
+				createRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				createRoleOptionsModel.Actions = []string{"testString"}
+				createRoleOptionsModel.Name = core.StringPtr("testString")
+				createRoleOptionsModel.AccountID = core.StringPtr("testString")
+				createRoleOptionsModel.ServiceName = core.StringPtr("testString")
+				createRoleOptionsModel.Description = core.StringPtr("testString")
+				createRoleOptionsModel.AcceptLanguage = core.StringPtr("testString")
+ 				createRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.CreateRole(createRoleOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke CreateRole with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the CreateRoleOptions model
+				createRoleOptionsModel := new(iampolicymanagementv1.CreateRoleOptions)
+				createRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				createRoleOptionsModel.Actions = []string{"testString"}
+				createRoleOptionsModel.Name = core.StringPtr("testString")
+				createRoleOptionsModel.AccountID = core.StringPtr("testString")
+				createRoleOptionsModel.ServiceName = core.StringPtr("testString")
+				createRoleOptionsModel.Description = core.StringPtr("testString")
+				createRoleOptionsModel.AcceptLanguage = core.StringPtr("testString")
+				createRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.CreateRole(createRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the CreateRoleOptions model with no property values
+				createRoleOptionsModelNew := new(iampolicymanagementv1.CreateRoleOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.CreateRole(createRoleOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`UpdateRole(updateRoleOptions *UpdateRoleOptions) - Operation response error`, func() {
+		updateRolePath := "/v2/roles/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(updateRolePath))
+					Expect(req.Method).To(Equal("PUT"))
+					Expect(req.Header["If-Match"]).ToNot(BeNil())
+					Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke UpdateRole with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the UpdateRoleOptions model
+				updateRoleOptionsModel := new(iampolicymanagementv1.UpdateRoleOptions)
+				updateRoleOptionsModel.RoleID = core.StringPtr("testString")
+				updateRoleOptionsModel.IfMatch = core.StringPtr("testString")
+				updateRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				updateRoleOptionsModel.Description = core.StringPtr("testString")
+				updateRoleOptionsModel.Actions = []string{"testString"}
+				updateRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.UpdateRole(updateRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`UpdateRole(updateRoleOptions *UpdateRoleOptions)`, func() {
+		updateRolePath := "/v2/roles/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(updateRolePath))
+					Expect(req.Method).To(Equal("PUT"))
+					Expect(req.Header["If-Match"]).ToNot(BeNil())
+					Expect(req.Header["If-Match"][0]).To(Equal(fmt.Sprintf("%v", "testString")))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"id": "ID", "display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn", "name": "Name", "account_id": "AccountID", "service_name": "ServiceName", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID", "href": "Href"}`)
+				}))
+			})
+			It(`Invoke UpdateRole successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.UpdateRole(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the UpdateRoleOptions model
+				updateRoleOptionsModel := new(iampolicymanagementv1.UpdateRoleOptions)
+				updateRoleOptionsModel.RoleID = core.StringPtr("testString")
+				updateRoleOptionsModel.IfMatch = core.StringPtr("testString")
+				updateRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				updateRoleOptionsModel.Description = core.StringPtr("testString")
+				updateRoleOptionsModel.Actions = []string{"testString"}
+ 				updateRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.UpdateRole(updateRoleOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke UpdateRole with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the UpdateRoleOptions model
+				updateRoleOptionsModel := new(iampolicymanagementv1.UpdateRoleOptions)
+				updateRoleOptionsModel.RoleID = core.StringPtr("testString")
+				updateRoleOptionsModel.IfMatch = core.StringPtr("testString")
+				updateRoleOptionsModel.DisplayName = core.StringPtr("testString")
+				updateRoleOptionsModel.Description = core.StringPtr("testString")
+				updateRoleOptionsModel.Actions = []string{"testString"}
+				updateRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.UpdateRole(updateRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the UpdateRoleOptions model with no property values
+				updateRoleOptionsModelNew := new(iampolicymanagementv1.UpdateRoleOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.UpdateRole(updateRoleOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`GetRole(getRoleOptions *GetRoleOptions) - Operation response error`, func() {
+		getRolePath := "/v2/roles/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(getRolePath))
+					Expect(req.Method).To(Equal("GET"))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `} this is not valid json {`)
+				}))
+			})
+			It(`Invoke GetRole with error: Operation response processing error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the GetRoleOptions model
+				getRoleOptionsModel := new(iampolicymanagementv1.GetRoleOptions)
+				getRoleOptionsModel.RoleID = core.StringPtr("testString")
+				getRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Expect response parsing to fail since we are receiving a text/plain response
+				result, response, operationErr := testService.GetRole(getRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`GetRole(getRoleOptions *GetRoleOptions)`, func() {
+		getRolePath := "/v2/roles/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(getRolePath))
+					Expect(req.Method).To(Equal("GET"))
+					res.Header().Set("Content-type", "application/json")
+					res.WriteHeader(200)
+					fmt.Fprintf(res, `{"id": "ID", "display_name": "DisplayName", "description": "Description", "actions": ["Actions"], "crn": "Crn", "name": "Name", "account_id": "AccountID", "service_name": "ServiceName", "created_at": "2019-01-01T12:00:00", "created_by_id": "CreatedByID", "last_modified_at": "2019-01-01T12:00:00", "last_modified_by_id": "LastModifiedByID", "href": "Href"}`)
+				}))
+			})
+			It(`Invoke GetRole successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				result, response, operationErr := testService.GetRole(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+
+				// Construct an instance of the GetRoleOptions model
+				getRoleOptionsModel := new(iampolicymanagementv1.GetRoleOptions)
+				getRoleOptionsModel.RoleID = core.StringPtr("testString")
+ 				getRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				result, response, operationErr = testService.GetRole(getRoleOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+				Expect(result).ToNot(BeNil())
+			})
+			It(`Invoke GetRole with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the GetRoleOptions model
+				getRoleOptionsModel := new(iampolicymanagementv1.GetRoleOptions)
+				getRoleOptionsModel.RoleID = core.StringPtr("testString")
+				getRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				result, response, operationErr := testService.GetRole(getRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+				// Construct a second instance of the GetRoleOptions model with no property values
+				getRoleOptionsModelNew := new(iampolicymanagementv1.GetRoleOptions)
+				// Invoke operation with invalid model (negative test)
+				result, response, operationErr = testService.GetRole(getRoleOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+				Expect(result).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+
+	Describe(`DeleteRole(deleteRoleOptions *DeleteRoleOptions)`, func() {
+		deleteRolePath := "/v2/roles/testString"
+		Context(`Using mock server endpoint`, func() {
+			BeforeEach(func() {
+				testServer = httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
+					defer GinkgoRecover()
+
+					// Verify the contents of the request
+					Expect(req.URL.Path).To(Equal(deleteRolePath))
+					Expect(req.Method).To(Equal("DELETE"))
+					res.WriteHeader(204)
+				}))
+			})
+			It(`Invoke DeleteRole successfully`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Invoke operation with nil options model (negative test)
+				response, operationErr := testService.DeleteRole(nil)
+				Expect(operationErr).NotTo(BeNil())
+				Expect(response).To(BeNil())
+
+				// Construct an instance of the DeleteRoleOptions model
+				deleteRoleOptionsModel := new(iampolicymanagementv1.DeleteRoleOptions)
+				deleteRoleOptionsModel.RoleID = core.StringPtr("testString")
+ 				deleteRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+
+				// Invoke operation with valid options model (positive test)
+				response, operationErr = testService.DeleteRole(deleteRoleOptionsModel)
+				Expect(operationErr).To(BeNil())
+				Expect(response).ToNot(BeNil())
+			})
+			It(`Invoke DeleteRole with error: Operation validation and request error`, func() {
+				testService, testServiceErr := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+					URL:           testServer.URL,
+					Authenticator: &core.NoAuthAuthenticator{},
+				})
+				Expect(testServiceErr).To(BeNil())
+				Expect(testService).ToNot(BeNil())
+
+				// Construct an instance of the DeleteRoleOptions model
+				deleteRoleOptionsModel := new(iampolicymanagementv1.DeleteRoleOptions)
+				deleteRoleOptionsModel.RoleID = core.StringPtr("testString")
+				deleteRoleOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"}
+				// Invoke operation with empty URL (negative test)
+				err := testService.SetServiceURL("")
+				Expect(err).To(BeNil())
+				response, operationErr := testService.DeleteRole(deleteRoleOptionsModel)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING))
+				Expect(response).To(BeNil())
+				// Construct a second instance of the DeleteRoleOptions model with no property values
+				deleteRoleOptionsModelNew := new(iampolicymanagementv1.DeleteRoleOptions)
+				// Invoke operation with invalid model (negative test)
+				response, operationErr = testService.DeleteRole(deleteRoleOptionsModelNew)
+				Expect(operationErr).ToNot(BeNil())
+				Expect(response).To(BeNil())
+			})
+			AfterEach(func() {
+				testServer.Close()
+			})
+		})
+	})
+	Describe(`Model constructor tests`, func() {
+		Context(`Using a service client instance`, func() {
+			testService, _ := iampolicymanagementv1.NewIamPolicyManagementV1(&iampolicymanagementv1.IamPolicyManagementV1Options{
+				URL:           "http://iampolicymanagementv1modelgenerator.com",
+				Authenticator: &core.NoAuthAuthenticator{},
+			})
+			It(`Invoke NewCreatePolicyOptions successfully`, func() {
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				Expect(resourceAttributeModel).ToNot(BeNil())
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+				Expect(resourceAttributeModel.Name).To(Equal(core.StringPtr("testString")))
+				Expect(resourceAttributeModel.Value).To(Equal(core.StringPtr("testString")))
+				Expect(resourceAttributeModel.Operator).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				Expect(subjectAttributeModel).ToNot(BeNil())
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+				Expect(subjectAttributeModel.Name).To(Equal(core.StringPtr("testString")))
+				Expect(subjectAttributeModel.Value).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				Expect(policyResourceModel).ToNot(BeNil())
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+				Expect(policyResourceModel.Attributes).To(Equal([]iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}))
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				Expect(policyRoleModel).ToNot(BeNil())
+				policyRoleModel.RoleID = core.StringPtr("testString")
+				Expect(policyRoleModel.RoleID).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				Expect(policySubjectModel).ToNot(BeNil())
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+				Expect(policySubjectModel.Attributes).To(Equal([]iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}))
+
+				// Construct an instance of the CreatePolicyOptions model
+				createPolicyOptionsType := "testString"
+				createPolicyOptionsSubjects := []iampolicymanagementv1.PolicySubject{}
+				createPolicyOptionsRoles := []iampolicymanagementv1.PolicyRole{}
+				createPolicyOptionsResources := []iampolicymanagementv1.PolicyResource{}
+				createPolicyOptionsModel := testService.NewCreatePolicyOptions(createPolicyOptionsType, createPolicyOptionsSubjects, createPolicyOptionsRoles, createPolicyOptionsResources)
+				createPolicyOptionsModel.SetType("testString")
+				createPolicyOptionsModel.SetSubjects([]iampolicymanagementv1.PolicySubject{*policySubjectModel})
+				createPolicyOptionsModel.SetRoles([]iampolicymanagementv1.PolicyRole{*policyRoleModel})
+				createPolicyOptionsModel.SetResources([]iampolicymanagementv1.PolicyResource{*policyResourceModel})
+				createPolicyOptionsModel.SetAcceptLanguage("testString")
+				createPolicyOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(createPolicyOptionsModel).ToNot(BeNil())
+				Expect(createPolicyOptionsModel.Type).To(Equal(core.StringPtr("testString")))
+				Expect(createPolicyOptionsModel.Subjects).To(Equal([]iampolicymanagementv1.PolicySubject{*policySubjectModel}))
+				Expect(createPolicyOptionsModel.Roles).To(Equal([]iampolicymanagementv1.PolicyRole{*policyRoleModel}))
+				Expect(createPolicyOptionsModel.Resources).To(Equal([]iampolicymanagementv1.PolicyResource{*policyResourceModel}))
+				Expect(createPolicyOptionsModel.AcceptLanguage).To(Equal(core.StringPtr("testString")))
+				Expect(createPolicyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewCreateRoleOptions successfully`, func() {
+				// Construct an instance of the CreateRoleOptions model
+				createRoleOptionsDisplayName := "testString"
+				createRoleOptionsActions := []string{"testString"}
+				createRoleOptionsName := "testString"
+				createRoleOptionsAccountID := "testString"
+				createRoleOptionsServiceName := "testString"
+				createRoleOptionsModel := testService.NewCreateRoleOptions(createRoleOptionsDisplayName, createRoleOptionsActions, createRoleOptionsName, createRoleOptionsAccountID, createRoleOptionsServiceName)
+				createRoleOptionsModel.SetDisplayName("testString")
+				createRoleOptionsModel.SetActions([]string{"testString"})
+				createRoleOptionsModel.SetName("testString")
+				createRoleOptionsModel.SetAccountID("testString")
+				createRoleOptionsModel.SetServiceName("testString")
+				createRoleOptionsModel.SetDescription("testString")
+				createRoleOptionsModel.SetAcceptLanguage("testString")
+				createRoleOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(createRoleOptionsModel).ToNot(BeNil())
+				Expect(createRoleOptionsModel.DisplayName).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.Actions).To(Equal([]string{"testString"}))
+				Expect(createRoleOptionsModel.Name).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.AccountID).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.ServiceName).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.Description).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.AcceptLanguage).To(Equal(core.StringPtr("testString")))
+				Expect(createRoleOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewDeletePolicyOptions successfully`, func() {
+				// Construct an instance of the DeletePolicyOptions model
+				policyID := "testString"
+				deletePolicyOptionsModel := testService.NewDeletePolicyOptions(policyID)
+				deletePolicyOptionsModel.SetPolicyID("testString")
+				deletePolicyOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(deletePolicyOptionsModel).ToNot(BeNil())
+				Expect(deletePolicyOptionsModel.PolicyID).To(Equal(core.StringPtr("testString")))
+				Expect(deletePolicyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewDeleteRoleOptions successfully`, func() {
+				// Construct an instance of the DeleteRoleOptions model
+				roleID := "testString"
+				deleteRoleOptionsModel := testService.NewDeleteRoleOptions(roleID)
+				deleteRoleOptionsModel.SetRoleID("testString")
+				deleteRoleOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(deleteRoleOptionsModel).ToNot(BeNil())
+				Expect(deleteRoleOptionsModel.RoleID).To(Equal(core.StringPtr("testString")))
+				Expect(deleteRoleOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewGetPolicyOptions successfully`, func() {
+				// Construct an instance of the GetPolicyOptions model
+				policyID := "testString"
+				getPolicyOptionsModel := testService.NewGetPolicyOptions(policyID)
+				getPolicyOptionsModel.SetPolicyID("testString")
+				getPolicyOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(getPolicyOptionsModel).ToNot(BeNil())
+				Expect(getPolicyOptionsModel.PolicyID).To(Equal(core.StringPtr("testString")))
+				Expect(getPolicyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewGetRoleOptions successfully`, func() {
+				// Construct an instance of the GetRoleOptions model
+				roleID := "testString"
+				getRoleOptionsModel := testService.NewGetRoleOptions(roleID)
+				getRoleOptionsModel.SetRoleID("testString")
+				getRoleOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(getRoleOptionsModel).ToNot(BeNil())
+				Expect(getRoleOptionsModel.RoleID).To(Equal(core.StringPtr("testString")))
+				Expect(getRoleOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewListPoliciesOptions successfully`, func() {
+				// Construct an instance of the ListPoliciesOptions model
+				accountID := "testString"
+				listPoliciesOptionsModel := testService.NewListPoliciesOptions(accountID)
+				listPoliciesOptionsModel.SetAccountID("testString")
+				listPoliciesOptionsModel.SetAcceptLanguage("testString")
+				listPoliciesOptionsModel.SetIamID("testString")
+				listPoliciesOptionsModel.SetAccessGroupID("testString")
+				listPoliciesOptionsModel.SetType("testString")
+				listPoliciesOptionsModel.SetServiceType("testString")
+				listPoliciesOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(listPoliciesOptionsModel).ToNot(BeNil())
+				Expect(listPoliciesOptionsModel.AccountID).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.AcceptLanguage).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.IamID).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.AccessGroupID).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.Type).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.ServiceType).To(Equal(core.StringPtr("testString")))
+				Expect(listPoliciesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewListRolesOptions successfully`, func() {
+				// Construct an instance of the ListRolesOptions model
+				listRolesOptionsModel := testService.NewListRolesOptions()
+				listRolesOptionsModel.SetAcceptLanguage("testString")
+				listRolesOptionsModel.SetAccountID("testString")
+				listRolesOptionsModel.SetServiceName("testString")
+				listRolesOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(listRolesOptionsModel).ToNot(BeNil())
+				Expect(listRolesOptionsModel.AcceptLanguage).To(Equal(core.StringPtr("testString")))
+				Expect(listRolesOptionsModel.AccountID).To(Equal(core.StringPtr("testString")))
+				Expect(listRolesOptionsModel.ServiceName).To(Equal(core.StringPtr("testString")))
+				Expect(listRolesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewUpdatePolicyOptions successfully`, func() {
+				// Construct an instance of the ResourceAttribute model
+				resourceAttributeModel := new(iampolicymanagementv1.ResourceAttribute)
+				Expect(resourceAttributeModel).ToNot(BeNil())
+				resourceAttributeModel.Name = core.StringPtr("testString")
+				resourceAttributeModel.Value = core.StringPtr("testString")
+				resourceAttributeModel.Operator = core.StringPtr("testString")
+				Expect(resourceAttributeModel.Name).To(Equal(core.StringPtr("testString")))
+				Expect(resourceAttributeModel.Value).To(Equal(core.StringPtr("testString")))
+				Expect(resourceAttributeModel.Operator).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the SubjectAttribute model
+				subjectAttributeModel := new(iampolicymanagementv1.SubjectAttribute)
+				Expect(subjectAttributeModel).ToNot(BeNil())
+				subjectAttributeModel.Name = core.StringPtr("testString")
+				subjectAttributeModel.Value = core.StringPtr("testString")
+				Expect(subjectAttributeModel.Name).To(Equal(core.StringPtr("testString")))
+				Expect(subjectAttributeModel.Value).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the PolicyResource model
+				policyResourceModel := new(iampolicymanagementv1.PolicyResource)
+				Expect(policyResourceModel).ToNot(BeNil())
+				policyResourceModel.Attributes = []iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}
+				Expect(policyResourceModel.Attributes).To(Equal([]iampolicymanagementv1.ResourceAttribute{*resourceAttributeModel}))
+
+				// Construct an instance of the PolicyRole model
+				policyRoleModel := new(iampolicymanagementv1.PolicyRole)
+				Expect(policyRoleModel).ToNot(BeNil())
+				policyRoleModel.RoleID = core.StringPtr("testString")
+				Expect(policyRoleModel.RoleID).To(Equal(core.StringPtr("testString")))
+
+				// Construct an instance of the PolicySubject model
+				policySubjectModel := new(iampolicymanagementv1.PolicySubject)
+				Expect(policySubjectModel).ToNot(BeNil())
+				policySubjectModel.Attributes = []iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}
+				Expect(policySubjectModel.Attributes).To(Equal([]iampolicymanagementv1.SubjectAttribute{*subjectAttributeModel}))
+
+				// Construct an instance of the UpdatePolicyOptions model
+				policyID := "testString"
+				ifMatch := "testString"
+				updatePolicyOptionsType := "testString"
+				updatePolicyOptionsSubjects := []iampolicymanagementv1.PolicySubject{}
+				updatePolicyOptionsRoles := []iampolicymanagementv1.PolicyRole{}
+				updatePolicyOptionsResources := []iampolicymanagementv1.PolicyResource{}
+				updatePolicyOptionsModel := testService.NewUpdatePolicyOptions(policyID, ifMatch, updatePolicyOptionsType, updatePolicyOptionsSubjects, updatePolicyOptionsRoles, updatePolicyOptionsResources)
+				updatePolicyOptionsModel.SetPolicyID("testString")
+				updatePolicyOptionsModel.SetIfMatch("testString")
+				updatePolicyOptionsModel.SetType("testString")
+				updatePolicyOptionsModel.SetSubjects([]iampolicymanagementv1.PolicySubject{*policySubjectModel})
+				updatePolicyOptionsModel.SetRoles([]iampolicymanagementv1.PolicyRole{*policyRoleModel})
+				updatePolicyOptionsModel.SetResources([]iampolicymanagementv1.PolicyResource{*policyResourceModel})
+				updatePolicyOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(updatePolicyOptionsModel).ToNot(BeNil())
+				Expect(updatePolicyOptionsModel.PolicyID).To(Equal(core.StringPtr("testString")))
+				Expect(updatePolicyOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
+				Expect(updatePolicyOptionsModel.Type).To(Equal(core.StringPtr("testString")))
+				Expect(updatePolicyOptionsModel.Subjects).To(Equal([]iampolicymanagementv1.PolicySubject{*policySubjectModel}))
+				Expect(updatePolicyOptionsModel.Roles).To(Equal([]iampolicymanagementv1.PolicyRole{*policyRoleModel}))
+				Expect(updatePolicyOptionsModel.Resources).To(Equal([]iampolicymanagementv1.PolicyResource{*policyResourceModel}))
+				Expect(updatePolicyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewUpdateRoleOptions successfully`, func() {
+				// Construct an instance of the UpdateRoleOptions model
+				roleID := "testString"
+				ifMatch := "testString"
+				updateRoleOptionsModel := testService.NewUpdateRoleOptions(roleID, ifMatch)
+				updateRoleOptionsModel.SetRoleID("testString")
+				updateRoleOptionsModel.SetIfMatch("testString")
+				updateRoleOptionsModel.SetDisplayName("testString")
+				updateRoleOptionsModel.SetDescription("testString")
+				updateRoleOptionsModel.SetActions([]string{"testString"})
+				updateRoleOptionsModel.SetHeaders(map[string]string{"foo": "bar"})
+				Expect(updateRoleOptionsModel).ToNot(BeNil())
+				Expect(updateRoleOptionsModel.RoleID).To(Equal(core.StringPtr("testString")))
+				Expect(updateRoleOptionsModel.IfMatch).To(Equal(core.StringPtr("testString")))
+				Expect(updateRoleOptionsModel.DisplayName).To(Equal(core.StringPtr("testString")))
+				Expect(updateRoleOptionsModel.Description).To(Equal(core.StringPtr("testString")))
+				Expect(updateRoleOptionsModel.Actions).To(Equal([]string{"testString"}))
+				Expect(updateRoleOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"}))
+			})
+			It(`Invoke NewPolicyRole successfully`, func() {
+				roleID := "testString"
+				model, err := testService.NewPolicyRole(roleID)
+				Expect(model).ToNot(BeNil())
+				Expect(err).To(BeNil())
+			})
+			It(`Invoke NewResourceAttribute successfully`, func() {
+				name := "testString"
+				value := "testString"
+				model, err := testService.NewResourceAttribute(name, value)
+				Expect(model).ToNot(BeNil())
+				Expect(err).To(BeNil())
+			})
+			It(`Invoke NewSubjectAttribute successfully`, func() {
+				name := "testString"
+				value := "testString"
+				model, err := testService.NewSubjectAttribute(name, value)
+				Expect(model).ToNot(BeNil())
+				Expect(err).To(BeNil())
+			})
+		})
+	})
+	Describe(`Utility function tests`, func() {
+		It(`Invoke CreateMockByteArray() successfully`, func() {
+			mockByteArray := CreateMockByteArray("This is a test")
+			Expect(mockByteArray).ToNot(BeNil())
+		})
+		It(`Invoke CreateMockUUID() successfully`, func() {
+			mockUUID := CreateMockUUID("9fab83da-98cb-4f18-a7ba-b6f0435c9673")
+			Expect(mockUUID).ToNot(BeNil())
+		})
+		It(`Invoke CreateMockReader() successfully`, func() {
+			mockReader := CreateMockReader("This is a test.")
+			Expect(mockReader).ToNot(BeNil())
+		})
+		It(`Invoke CreateMockDate() successfully`, func() {
+			mockDate := CreateMockDate()
+			Expect(mockDate).ToNot(BeNil())
+		})
+		It(`Invoke CreateMockDateTime() successfully`, func() {
+			mockDateTime := CreateMockDateTime()
+			Expect(mockDateTime).ToNot(BeNil())
+		})
+	})
+})
+
+//
+// Utility functions used by the generated test code
+//
+
+func CreateMockByteArray(mockData string) *[]byte {
+	ba := make([]byte, 0)
+	ba = append(ba, mockData...)
+	return &ba
+}
+
+func CreateMockUUID(mockData string) *strfmt.UUID {
+	uuid := strfmt.UUID(mockData)
+	return &uuid
+}
+
+func CreateMockReader(mockData string) io.ReadCloser {
+	return ioutil.NopCloser(bytes.NewReader([]byte(mockData)))
+}
+
+func CreateMockDate() *strfmt.Date {
+	d := strfmt.Date(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
+	return &d
+}
+
+func CreateMockDateTime() *strfmt.DateTime {
+	d := strfmt.DateTime(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
+	return &d
+}
+
+func SetTestEnvironment(testEnvironment map[string]string) {
+	for key, value := range testEnvironment {
+		os.Setenv(key, value)
+	}
+}
+
+func ClearTestEnvironment(testEnvironment map[string]string) {
+	for key := range testEnvironment {
+		os.Unsetenv(key)
+	}
+}