diff --git a/.travis.yml b/.travis.yml index 7dc4b868..84e58533 100644 --- a/.travis.yml +++ b/.travis.yml @@ -23,6 +23,7 @@ before_install: && 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 + && openssl aes-256-cbc -K $encrypted_6eaa1fc94541_key -iv $encrypted_6eaa1fc94541_iv -in catalog_mgmt.env.enc -out catalog_mgmt.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 59ea6ec2..84a975b0 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,7 @@ The IBM Cloud Platform Services Go SDK allows developers to programmatically int Service Name | Package name --- | --- [Case Management](https://cloud.ibm.com/apidocs/case-management) | casemanagementv1 +[Catalog Management](https://cloud.ibm.com/apidocs/resource-catalog/private-catalog) | catalogmanagementv1 [Enterprise Management](https://cloud.ibm.com/apidocs/enterprise-apis/enterprise) | enterprisemanagementv1 [Global Catalog](https://cloud.ibm.com/apidocs/resource-catalog/global-catalog) | globalcatalogv1 [Global Search](https://cloud.ibm.com/apidocs/search) | globalsearchv2 diff --git a/catalog_mgmt.env.enc b/catalog_mgmt.env.enc new file mode 100644 index 00000000..920d2eb1 Binary files /dev/null and b/catalog_mgmt.env.enc differ diff --git a/catalogmanagementv1/catalog_management_v1.go b/catalogmanagementv1/catalog_management_v1.go new file mode 100644 index 00000000..94e21f79 --- /dev/null +++ b/catalogmanagementv1/catalog_management_v1.go @@ -0,0 +1,11239 @@ +/** + * (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 catalogmanagementv1 : Operations and models for the CatalogManagementV1 service +package catalogmanagementv1 + +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" +) + +// CatalogManagementV1 : This is the API to use for managing private catalogs for IBM Cloud. Private catalogs provide a +// way to centrally manage access to products in the IBM Cloud catalog and your own catalogs. +// +// Version: 1.0 +type CatalogManagementV1 struct { + Service *core.BaseService +} + +// DefaultServiceURL is the default URL to make service requests to. +const DefaultServiceURL = "https://cm.globalcatalog.cloud.ibm.com/api/v1-beta" + +// DefaultServiceName is the default key used to find external configuration information. +const DefaultServiceName = "catalog_management" + +// CatalogManagementV1Options : Service options +type CatalogManagementV1Options struct { + ServiceName string + URL string + Authenticator core.Authenticator +} + +// NewCatalogManagementV1UsingExternalConfig : constructs an instance of CatalogManagementV1 with passed in options and external configuration. +func NewCatalogManagementV1UsingExternalConfig(options *CatalogManagementV1Options) (catalogManagement *CatalogManagementV1, err error) { + if options.ServiceName == "" { + options.ServiceName = DefaultServiceName + } + + if options.Authenticator == nil { + options.Authenticator, err = core.GetAuthenticatorFromEnvironment(options.ServiceName) + if err != nil { + return + } + } + + catalogManagement, err = NewCatalogManagementV1(options) + if err != nil { + return + } + + err = catalogManagement.Service.ConfigureService(options.ServiceName) + if err != nil { + return + } + + if options.URL != "" { + err = catalogManagement.Service.SetServiceURL(options.URL) + } + return +} + +// NewCatalogManagementV1 : constructs an instance of CatalogManagementV1 with passed in options. +func NewCatalogManagementV1(options *CatalogManagementV1Options) (service *CatalogManagementV1, 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 = &CatalogManagementV1{ + Service: baseService, + } + + return +} + +// SetServiceURL sets the service URL +func (catalogManagement *CatalogManagementV1) SetServiceURL(url string) error { + return catalogManagement.Service.SetServiceURL(url) +} + +// GetCatalogAccount : Get the account settings +// Get the account level settings for the account for private catalog. +func (catalogManagement *CatalogManagementV1) GetCatalogAccount(getCatalogAccountOptions *GetCatalogAccountOptions) (result *Account, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(getCatalogAccountOptions, "getCatalogAccountOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogaccount"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getCatalogAccountOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetCatalogAccount") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalAccount) + if err != nil { + return + } + response.Result = result + + return +} + +// UpdateCatalogAccount : Set the account settings +func (catalogManagement *CatalogManagementV1) UpdateCatalogAccount(updateCatalogAccountOptions *UpdateCatalogAccountOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateStruct(updateCatalogAccountOptions, "updateCatalogAccountOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogaccount"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range updateCatalogAccountOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "UpdateCatalogAccount") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if updateCatalogAccountOptions.ID != nil { + body["id"] = updateCatalogAccountOptions.ID + } + if updateCatalogAccountOptions.AccountFilters != nil { + body["account_filters"] = updateCatalogAccountOptions.AccountFilters + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetCatalogAccountFilters : Get the accumulated filters of the account and of the catalogs you have access to +// Get the accumulated filters of the account and of the catalogs you have access to. +func (catalogManagement *CatalogManagementV1) GetCatalogAccountFilters(getCatalogAccountFiltersOptions *GetCatalogAccountFiltersOptions) (result *AccumulatedFilters, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(getCatalogAccountFiltersOptions, "getCatalogAccountFiltersOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogaccount/filters"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getCatalogAccountFiltersOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetCatalogAccountFilters") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if getCatalogAccountFiltersOptions.Catalog != nil { + builder.AddQuery("catalog", fmt.Sprint(*getCatalogAccountFiltersOptions.Catalog)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalAccumulatedFilters) + if err != nil { + return + } + response.Result = result + + return +} + +// ListCatalogs : Get list of catalogs +// List the available catalogs for a given account. +func (catalogManagement *CatalogManagementV1) ListCatalogs(listCatalogsOptions *ListCatalogsOptions) (result *CatalogSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(listCatalogsOptions, "listCatalogsOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listCatalogsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListCatalogs") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCatalogSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// CreateCatalog : Create a catalog +// Create a catalog for a given account. +func (catalogManagement *CatalogManagementV1) CreateCatalog(createCatalogOptions *CreateCatalogOptions) (result *Catalog, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(createCatalogOptions, "createCatalogOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range createCatalogOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CreateCatalog") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if createCatalogOptions.ID != nil { + body["id"] = createCatalogOptions.ID + } + if createCatalogOptions.Rev != nil { + body["_rev"] = createCatalogOptions.Rev + } + if createCatalogOptions.Label != nil { + body["label"] = createCatalogOptions.Label + } + if createCatalogOptions.ShortDescription != nil { + body["short_description"] = createCatalogOptions.ShortDescription + } + if createCatalogOptions.CatalogIconURL != nil { + body["catalog_icon_url"] = createCatalogOptions.CatalogIconURL + } + if createCatalogOptions.Tags != nil { + body["tags"] = createCatalogOptions.Tags + } + if createCatalogOptions.URL != nil { + body["url"] = createCatalogOptions.URL + } + if createCatalogOptions.Crn != nil { + body["crn"] = createCatalogOptions.Crn + } + if createCatalogOptions.OfferingsURL != nil { + body["offerings_url"] = createCatalogOptions.OfferingsURL + } + if createCatalogOptions.Features != nil { + body["features"] = createCatalogOptions.Features + } + if createCatalogOptions.Disabled != nil { + body["disabled"] = createCatalogOptions.Disabled + } + if createCatalogOptions.Created != nil { + body["created"] = createCatalogOptions.Created + } + if createCatalogOptions.Updated != nil { + body["updated"] = createCatalogOptions.Updated + } + if createCatalogOptions.ResourceGroupID != nil { + body["resource_group_id"] = createCatalogOptions.ResourceGroupID + } + if createCatalogOptions.OwningAccount != nil { + body["owning_account"] = createCatalogOptions.OwningAccount + } + if createCatalogOptions.CatalogFilters != nil { + body["catalog_filters"] = createCatalogOptions.CatalogFilters + } + if createCatalogOptions.SyndicationSettings != nil { + body["syndication_settings"] = createCatalogOptions.SyndicationSettings + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCatalog) + if err != nil { + return + } + response.Result = result + + return +} + +// GetCatalog : Get a catalog +// Get a catalog. +func (catalogManagement *CatalogManagementV1) GetCatalog(getCatalogOptions *GetCatalogOptions) (result *Catalog, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getCatalogOptions, "getCatalogOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getCatalogOptions, "getCatalogOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs"} + pathParameters := []string{*getCatalogOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getCatalogOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetCatalog") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCatalog) + if err != nil { + return + } + response.Result = result + + return +} + +// ReplaceCatalog : Update a catalog +// Update a catalog. +func (catalogManagement *CatalogManagementV1) ReplaceCatalog(replaceCatalogOptions *ReplaceCatalogOptions) (result *Catalog, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(replaceCatalogOptions, "replaceCatalogOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(replaceCatalogOptions, "replaceCatalogOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs"} + pathParameters := []string{*replaceCatalogOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range replaceCatalogOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReplaceCatalog") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if replaceCatalogOptions.ID != nil { + body["id"] = replaceCatalogOptions.ID + } + if replaceCatalogOptions.Rev != nil { + body["_rev"] = replaceCatalogOptions.Rev + } + if replaceCatalogOptions.Label != nil { + body["label"] = replaceCatalogOptions.Label + } + if replaceCatalogOptions.ShortDescription != nil { + body["short_description"] = replaceCatalogOptions.ShortDescription + } + if replaceCatalogOptions.CatalogIconURL != nil { + body["catalog_icon_url"] = replaceCatalogOptions.CatalogIconURL + } + if replaceCatalogOptions.Tags != nil { + body["tags"] = replaceCatalogOptions.Tags + } + if replaceCatalogOptions.URL != nil { + body["url"] = replaceCatalogOptions.URL + } + if replaceCatalogOptions.Crn != nil { + body["crn"] = replaceCatalogOptions.Crn + } + if replaceCatalogOptions.OfferingsURL != nil { + body["offerings_url"] = replaceCatalogOptions.OfferingsURL + } + if replaceCatalogOptions.Features != nil { + body["features"] = replaceCatalogOptions.Features + } + if replaceCatalogOptions.Disabled != nil { + body["disabled"] = replaceCatalogOptions.Disabled + } + if replaceCatalogOptions.Created != nil { + body["created"] = replaceCatalogOptions.Created + } + if replaceCatalogOptions.Updated != nil { + body["updated"] = replaceCatalogOptions.Updated + } + if replaceCatalogOptions.ResourceGroupID != nil { + body["resource_group_id"] = replaceCatalogOptions.ResourceGroupID + } + if replaceCatalogOptions.OwningAccount != nil { + body["owning_account"] = replaceCatalogOptions.OwningAccount + } + if replaceCatalogOptions.CatalogFilters != nil { + body["catalog_filters"] = replaceCatalogOptions.CatalogFilters + } + if replaceCatalogOptions.SyndicationSettings != nil { + body["syndication_settings"] = replaceCatalogOptions.SyndicationSettings + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCatalog) + if err != nil { + return + } + response.Result = result + + return +} + +// DeleteCatalog : Delete a catalog +// Delete a catalog. +func (catalogManagement *CatalogManagementV1) DeleteCatalog(deleteCatalogOptions *DeleteCatalogOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deleteCatalogOptions, "deleteCatalogOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deleteCatalogOptions, "deleteCatalogOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs"} + pathParameters := []string{*deleteCatalogOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.DELETE) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deleteCatalogOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeleteCatalog") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetEnterprise : Get the enterprise settings for the specified enterprise ID +// Get the enterprise settings for the specified enterprise ID. +func (catalogManagement *CatalogManagementV1) GetEnterprise(getEnterpriseOptions *GetEnterpriseOptions) (result *Enterprise, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getEnterpriseOptions, "getEnterpriseOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getEnterpriseOptions, "getEnterpriseOptions") + if err != nil { + return + } + + pathSegments := []string{"enterprises"} + pathParameters := []string{*getEnterpriseOptions.EnterpriseID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getEnterpriseOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetEnterprise") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalEnterprise) + if err != nil { + return + } + response.Result = result + + return +} + +// ReplaceEnterprise : Set the enterprise settings +func (catalogManagement *CatalogManagementV1) ReplaceEnterprise(replaceEnterpriseOptions *ReplaceEnterpriseOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(replaceEnterpriseOptions, "replaceEnterpriseOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(replaceEnterpriseOptions, "replaceEnterpriseOptions") + if err != nil { + return + } + + pathSegments := []string{"enterprises"} + pathParameters := []string{*replaceEnterpriseOptions.EnterpriseID} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range replaceEnterpriseOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReplaceEnterprise") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if replaceEnterpriseOptions.ID != nil { + body["id"] = replaceEnterpriseOptions.ID + } + if replaceEnterpriseOptions.Rev != nil { + body["_rev"] = replaceEnterpriseOptions.Rev + } + if replaceEnterpriseOptions.AccountFilters != nil { + body["account_filters"] = replaceEnterpriseOptions.AccountFilters + } + if replaceEnterpriseOptions.AccountGroups != nil { + body["account_groups"] = replaceEnterpriseOptions.AccountGroups + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetConsumptionOfferings : Get list of offerings for consumption +// List the available offerings from both public and from the account that currently scoped for consumption. These +// copies cannot be used updating. They are not complete and only return what is visible to the caller. +func (catalogManagement *CatalogManagementV1) GetConsumptionOfferings(getConsumptionOfferingsOptions *GetConsumptionOfferingsOptions) (result *OfferingSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(getConsumptionOfferingsOptions, "getConsumptionOfferingsOptions") + if err != nil { + return + } + + pathSegments := []string{"offerings"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getConsumptionOfferingsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetConsumptionOfferings") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if getConsumptionOfferingsOptions.Digest != nil { + builder.AddQuery("digest", fmt.Sprint(*getConsumptionOfferingsOptions.Digest)) + } + if getConsumptionOfferingsOptions.Catalog != nil { + builder.AddQuery("catalog", fmt.Sprint(*getConsumptionOfferingsOptions.Catalog)) + } + if getConsumptionOfferingsOptions.Select != nil { + builder.AddQuery("select", fmt.Sprint(*getConsumptionOfferingsOptions.Select)) + } + if getConsumptionOfferingsOptions.IncludeHidden != nil { + builder.AddQuery("includeHidden", fmt.Sprint(*getConsumptionOfferingsOptions.IncludeHidden)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOfferingSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// ListOfferings : Get list of offerings +// List the available offerings in the specified catalog. +func (catalogManagement *CatalogManagementV1) ListOfferings(listOfferingsOptions *ListOfferingsOptions) (result *OfferingSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(listOfferingsOptions, "listOfferingsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(listOfferingsOptions, "listOfferingsOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings"} + pathParameters := []string{*listOfferingsOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listOfferingsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListOfferings") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if listOfferingsOptions.Digest != nil { + builder.AddQuery("digest", fmt.Sprint(*listOfferingsOptions.Digest)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOfferingSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// CreateOffering : Create an offering +// Create an offering. +func (catalogManagement *CatalogManagementV1) CreateOffering(createOfferingOptions *CreateOfferingOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(createOfferingOptions, "createOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(createOfferingOptions, "createOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings"} + pathParameters := []string{*createOfferingOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range createOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CreateOffering") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if createOfferingOptions.ID != nil { + body["id"] = createOfferingOptions.ID + } + if createOfferingOptions.Rev != nil { + body["_rev"] = createOfferingOptions.Rev + } + if createOfferingOptions.URL != nil { + body["url"] = createOfferingOptions.URL + } + if createOfferingOptions.Crn != nil { + body["crn"] = createOfferingOptions.Crn + } + if createOfferingOptions.Label != nil { + body["label"] = createOfferingOptions.Label + } + if createOfferingOptions.Name != nil { + body["name"] = createOfferingOptions.Name + } + if createOfferingOptions.OfferingIconURL != nil { + body["offering_icon_url"] = createOfferingOptions.OfferingIconURL + } + if createOfferingOptions.OfferingDocsURL != nil { + body["offering_docs_url"] = createOfferingOptions.OfferingDocsURL + } + if createOfferingOptions.OfferingSupportURL != nil { + body["offering_support_url"] = createOfferingOptions.OfferingSupportURL + } + if createOfferingOptions.Tags != nil { + body["tags"] = createOfferingOptions.Tags + } + if createOfferingOptions.Rating != nil { + body["rating"] = createOfferingOptions.Rating + } + if createOfferingOptions.Created != nil { + body["created"] = createOfferingOptions.Created + } + if createOfferingOptions.Updated != nil { + body["updated"] = createOfferingOptions.Updated + } + if createOfferingOptions.ShortDescription != nil { + body["short_description"] = createOfferingOptions.ShortDescription + } + if createOfferingOptions.LongDescription != nil { + body["long_description"] = createOfferingOptions.LongDescription + } + if createOfferingOptions.Features != nil { + body["features"] = createOfferingOptions.Features + } + if createOfferingOptions.Kinds != nil { + body["kinds"] = createOfferingOptions.Kinds + } + if createOfferingOptions.PermitRequestIbmPublicPublish != nil { + body["permit_request_ibm_public_publish"] = createOfferingOptions.PermitRequestIbmPublicPublish + } + if createOfferingOptions.IbmPublishApproved != nil { + body["ibm_publish_approved"] = createOfferingOptions.IbmPublishApproved + } + if createOfferingOptions.PublicPublishApproved != nil { + body["public_publish_approved"] = createOfferingOptions.PublicPublishApproved + } + if createOfferingOptions.PublicOriginalCrn != nil { + body["public_original_crn"] = createOfferingOptions.PublicOriginalCrn + } + if createOfferingOptions.PublishPublicCrn != nil { + body["publish_public_crn"] = createOfferingOptions.PublishPublicCrn + } + if createOfferingOptions.PortalApprovalRecord != nil { + body["portal_approval_record"] = createOfferingOptions.PortalApprovalRecord + } + if createOfferingOptions.PortalUiURL != nil { + body["portal_ui_url"] = createOfferingOptions.PortalUiURL + } + if createOfferingOptions.CatalogID != nil { + body["catalog_id"] = createOfferingOptions.CatalogID + } + if createOfferingOptions.CatalogName != nil { + body["catalog_name"] = createOfferingOptions.CatalogName + } + if createOfferingOptions.Metadata != nil { + body["metadata"] = createOfferingOptions.Metadata + } + if createOfferingOptions.Disclaimer != nil { + body["disclaimer"] = createOfferingOptions.Disclaimer + } + if createOfferingOptions.Hidden != nil { + body["hidden"] = createOfferingOptions.Hidden + } + if createOfferingOptions.Provider != nil { + body["provider"] = createOfferingOptions.Provider + } + if createOfferingOptions.RepoInfo != nil { + body["repo_info"] = createOfferingOptions.RepoInfo + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// ImportOfferingVersion : Import new version to offering from a tgz +// Import new version to offering from a tgz. +func (catalogManagement *CatalogManagementV1) ImportOfferingVersion(importOfferingVersionOptions *ImportOfferingVersionOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(importOfferingVersionOptions, "importOfferingVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(importOfferingVersionOptions, "importOfferingVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings", "version"} + pathParameters := []string{*importOfferingVersionOptions.CatalogIdentifier, *importOfferingVersionOptions.OfferingID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range importOfferingVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ImportOfferingVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + if importOfferingVersionOptions.XAuthToken != nil { + builder.AddHeader("X-Auth-Token", fmt.Sprint(*importOfferingVersionOptions.XAuthToken)) + } + + builder.AddQuery("zipurl", fmt.Sprint(*importOfferingVersionOptions.Zipurl)) + if importOfferingVersionOptions.TargetVersion != nil { + builder.AddQuery("targetVersion", fmt.Sprint(*importOfferingVersionOptions.TargetVersion)) + } + if importOfferingVersionOptions.IncludeConfig != nil { + builder.AddQuery("includeConfig", fmt.Sprint(*importOfferingVersionOptions.IncludeConfig)) + } + if importOfferingVersionOptions.RepoType != nil { + builder.AddQuery("repoType", fmt.Sprint(*importOfferingVersionOptions.RepoType)) + } + + body := make(map[string]interface{}) + if importOfferingVersionOptions.Tags != nil { + body["tags"] = importOfferingVersionOptions.Tags + } + if importOfferingVersionOptions.TargetKinds != nil { + body["target_kinds"] = importOfferingVersionOptions.TargetKinds + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// ImportOffering : Import a new offering from a tgz +// Import a new offering from a tgz. +func (catalogManagement *CatalogManagementV1) ImportOffering(importOfferingOptions *ImportOfferingOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(importOfferingOptions, "importOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(importOfferingOptions, "importOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "import/offerings"} + pathParameters := []string{*importOfferingOptions.CatalogIdentifier} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range importOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ImportOffering") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + if importOfferingOptions.XAuthToken != nil { + builder.AddHeader("X-Auth-Token", fmt.Sprint(*importOfferingOptions.XAuthToken)) + } + + builder.AddQuery("zipurl", fmt.Sprint(*importOfferingOptions.Zipurl)) + if importOfferingOptions.OfferingID != nil { + builder.AddQuery("offeringID", fmt.Sprint(*importOfferingOptions.OfferingID)) + } + if importOfferingOptions.IncludeConfig != nil { + builder.AddQuery("includeConfig", fmt.Sprint(*importOfferingOptions.IncludeConfig)) + } + if importOfferingOptions.RepoType != nil { + builder.AddQuery("repoType", fmt.Sprint(*importOfferingOptions.RepoType)) + } + + body := make(map[string]interface{}) + if importOfferingOptions.Tags != nil { + body["tags"] = importOfferingOptions.Tags + } + if importOfferingOptions.TargetKinds != nil { + body["target_kinds"] = importOfferingOptions.TargetKinds + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// ReloadOffering : Reload existing version in offering from a tgz +// Reload existing version in offering from a tgz. +func (catalogManagement *CatalogManagementV1) ReloadOffering(reloadOfferingOptions *ReloadOfferingOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(reloadOfferingOptions, "reloadOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(reloadOfferingOptions, "reloadOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings", "reload"} + pathParameters := []string{*reloadOfferingOptions.CatalogIdentifier, *reloadOfferingOptions.OfferingID} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range reloadOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReloadOffering") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + if reloadOfferingOptions.XAuthToken != nil { + builder.AddHeader("X-Auth-Token", fmt.Sprint(*reloadOfferingOptions.XAuthToken)) + } + + builder.AddQuery("zipurl", fmt.Sprint(*reloadOfferingOptions.Zipurl)) + builder.AddQuery("targetVersion", fmt.Sprint(*reloadOfferingOptions.TargetVersion)) + if reloadOfferingOptions.RepoType != nil { + builder.AddQuery("repoType", fmt.Sprint(*reloadOfferingOptions.RepoType)) + } + + body := make(map[string]interface{}) + if reloadOfferingOptions.Tags != nil { + body["tags"] = reloadOfferingOptions.Tags + } + if reloadOfferingOptions.TargetKinds != nil { + body["target_kinds"] = reloadOfferingOptions.TargetKinds + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// GetOffering : Get an offering +// Get an offering. +func (catalogManagement *CatalogManagementV1) GetOffering(getOfferingOptions *GetOfferingOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getOfferingOptions, "getOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getOfferingOptions, "getOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings"} + pathParameters := []string{*getOfferingOptions.CatalogIdentifier, *getOfferingOptions.OfferingID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetOffering") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// ReplaceOffering : Update an offering +// Update an offering. +func (catalogManagement *CatalogManagementV1) ReplaceOffering(replaceOfferingOptions *ReplaceOfferingOptions) (result *Catalog, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(replaceOfferingOptions, "replaceOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(replaceOfferingOptions, "replaceOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings"} + pathParameters := []string{*replaceOfferingOptions.CatalogIdentifier, *replaceOfferingOptions.OfferingID} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range replaceOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReplaceOffering") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + + body := make(map[string]interface{}) + if replaceOfferingOptions.ID != nil { + body["id"] = replaceOfferingOptions.ID + } + if replaceOfferingOptions.Rev != nil { + body["_rev"] = replaceOfferingOptions.Rev + } + if replaceOfferingOptions.URL != nil { + body["url"] = replaceOfferingOptions.URL + } + if replaceOfferingOptions.Crn != nil { + body["crn"] = replaceOfferingOptions.Crn + } + if replaceOfferingOptions.Label != nil { + body["label"] = replaceOfferingOptions.Label + } + if replaceOfferingOptions.Name != nil { + body["name"] = replaceOfferingOptions.Name + } + if replaceOfferingOptions.OfferingIconURL != nil { + body["offering_icon_url"] = replaceOfferingOptions.OfferingIconURL + } + if replaceOfferingOptions.OfferingDocsURL != nil { + body["offering_docs_url"] = replaceOfferingOptions.OfferingDocsURL + } + if replaceOfferingOptions.OfferingSupportURL != nil { + body["offering_support_url"] = replaceOfferingOptions.OfferingSupportURL + } + if replaceOfferingOptions.Tags != nil { + body["tags"] = replaceOfferingOptions.Tags + } + if replaceOfferingOptions.Rating != nil { + body["rating"] = replaceOfferingOptions.Rating + } + if replaceOfferingOptions.Created != nil { + body["created"] = replaceOfferingOptions.Created + } + if replaceOfferingOptions.Updated != nil { + body["updated"] = replaceOfferingOptions.Updated + } + if replaceOfferingOptions.ShortDescription != nil { + body["short_description"] = replaceOfferingOptions.ShortDescription + } + if replaceOfferingOptions.LongDescription != nil { + body["long_description"] = replaceOfferingOptions.LongDescription + } + if replaceOfferingOptions.Features != nil { + body["features"] = replaceOfferingOptions.Features + } + if replaceOfferingOptions.Kinds != nil { + body["kinds"] = replaceOfferingOptions.Kinds + } + if replaceOfferingOptions.PermitRequestIbmPublicPublish != nil { + body["permit_request_ibm_public_publish"] = replaceOfferingOptions.PermitRequestIbmPublicPublish + } + if replaceOfferingOptions.IbmPublishApproved != nil { + body["ibm_publish_approved"] = replaceOfferingOptions.IbmPublishApproved + } + if replaceOfferingOptions.PublicPublishApproved != nil { + body["public_publish_approved"] = replaceOfferingOptions.PublicPublishApproved + } + if replaceOfferingOptions.PublicOriginalCrn != nil { + body["public_original_crn"] = replaceOfferingOptions.PublicOriginalCrn + } + if replaceOfferingOptions.PublishPublicCrn != nil { + body["publish_public_crn"] = replaceOfferingOptions.PublishPublicCrn + } + if replaceOfferingOptions.PortalApprovalRecord != nil { + body["portal_approval_record"] = replaceOfferingOptions.PortalApprovalRecord + } + if replaceOfferingOptions.PortalUiURL != nil { + body["portal_ui_url"] = replaceOfferingOptions.PortalUiURL + } + if replaceOfferingOptions.CatalogID != nil { + body["catalog_id"] = replaceOfferingOptions.CatalogID + } + if replaceOfferingOptions.CatalogName != nil { + body["catalog_name"] = replaceOfferingOptions.CatalogName + } + if replaceOfferingOptions.Metadata != nil { + body["metadata"] = replaceOfferingOptions.Metadata + } + if replaceOfferingOptions.Disclaimer != nil { + body["disclaimer"] = replaceOfferingOptions.Disclaimer + } + if replaceOfferingOptions.Hidden != nil { + body["hidden"] = replaceOfferingOptions.Hidden + } + if replaceOfferingOptions.Provider != nil { + body["provider"] = replaceOfferingOptions.Provider + } + if replaceOfferingOptions.RepoInfo != nil { + body["repo_info"] = replaceOfferingOptions.RepoInfo + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalCatalog) + if err != nil { + return + } + response.Result = result + + return +} + +// DeleteOffering : Delete an offering +// Delete an offering. +func (catalogManagement *CatalogManagementV1) DeleteOffering(deleteOfferingOptions *DeleteOfferingOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deleteOfferingOptions, "deleteOfferingOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deleteOfferingOptions, "deleteOfferingOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings"} + pathParameters := []string{*deleteOfferingOptions.CatalogIdentifier, *deleteOfferingOptions.OfferingID} + + builder := core.NewRequestBuilder(core.DELETE) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deleteOfferingOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeleteOffering") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// ReplaceOfferingIcon : upload an icon for the offering +// upload an icon file to be stored in GC. File is uploaded as a binary payload - not as a form. +func (catalogManagement *CatalogManagementV1) ReplaceOfferingIcon(replaceOfferingIconOptions *ReplaceOfferingIconOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(replaceOfferingIconOptions, "replaceOfferingIconOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(replaceOfferingIconOptions, "replaceOfferingIconOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings", "icon"} + pathParameters := []string{*replaceOfferingIconOptions.CatalogIdentifier, *replaceOfferingIconOptions.OfferingID, *replaceOfferingIconOptions.FileName} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range replaceOfferingIconOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReplaceOfferingIcon") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// UpdateOfferingIbm : Approve offering to be permitted to publish to IBM Public Catalog (IBMers only or Everyone) +// Approve or disapprove the offering to be allowed to publish to the IBM Public Catalog in `ibm` (visible to IBM only) +// or `public` (visible to everyone). Can approve to only `ibm`, or it can be extended to `public`. If extended to +// `public` then `ibm` is automatically approved too. If disapprove `public`, then `ibm` approval will not be changed. +// If disapprove `ibm` then `public` will automatically be disapproved. This is because the process steps always go +// first through `ibm` and then to `public`. `ibm` cannot be skipped. Only users with Approval IAM authority can use +// this. +func (catalogManagement *CatalogManagementV1) UpdateOfferingIbm(updateOfferingIbmOptions *UpdateOfferingIbmOptions) (result *ApprovalResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(updateOfferingIbmOptions, "updateOfferingIbmOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(updateOfferingIbmOptions, "updateOfferingIbmOptions") + if err != nil { + return + } + + pathSegments := []string{"catalogs", "offerings", "publish", ""} + pathParameters := []string{*updateOfferingIbmOptions.CatalogIdentifier, *updateOfferingIbmOptions.OfferingID, *updateOfferingIbmOptions.ApprovalType, *updateOfferingIbmOptions.Approved} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range updateOfferingIbmOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "UpdateOfferingIbm") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalApprovalResult) + if err != nil { + return + } + response.Result = result + + return +} + +// GetVersionAbout : Get the about information, in markdown, for the current version +// Get the about information, in markdown, for the current version. +func (catalogManagement *CatalogManagementV1) GetVersionAbout(getVersionAboutOptions *GetVersionAboutOptions) (result *string, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionAboutOptions, "getVersionAboutOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionAboutOptions, "getVersionAboutOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "about"} + pathParameters := []string{*getVersionAboutOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionAboutOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersionAbout") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "text/markdown") + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, &result) + + return +} + +// GetVersionLicense : Get the license content for the specified license ID in the specified version +// Get the license content for the specified license ID in the specified version. +func (catalogManagement *CatalogManagementV1) GetVersionLicense(getVersionLicenseOptions *GetVersionLicenseOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionLicenseOptions, "getVersionLicenseOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionLicenseOptions, "getVersionLicenseOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "licenses"} + pathParameters := []string{*getVersionLicenseOptions.VersionLocID, *getVersionLicenseOptions.LicenseID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionLicenseOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersionLicense") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetVersionContainerImages : Get get the list of container images associated with this version +// The "image_manifest_url" property of the version should be pointing the a URL for the image manifest, this api +// reflects that content. +func (catalogManagement *CatalogManagementV1) GetVersionContainerImages(getVersionContainerImagesOptions *GetVersionContainerImagesOptions) (result *ImageManifest, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionContainerImagesOptions, "getVersionContainerImagesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionContainerImagesOptions, "getVersionContainerImagesOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "containerImages"} + pathParameters := []string{*getVersionContainerImagesOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionContainerImagesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersionContainerImages") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalImageManifest) + if err != nil { + return + } + response.Result = result + + return +} + +// DeprecateVersion : Deprecate the specified version +// Deprecate the specified version. +func (catalogManagement *CatalogManagementV1) DeprecateVersion(deprecateVersionOptions *DeprecateVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deprecateVersionOptions, "deprecateVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deprecateVersionOptions, "deprecateVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "deprecate"} + pathParameters := []string{*deprecateVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deprecateVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeprecateVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// AccountPublishVersion : Publish the specified version so it is viewable by account members +// Publish the specified version so it is viewable by account members. +func (catalogManagement *CatalogManagementV1) AccountPublishVersion(accountPublishVersionOptions *AccountPublishVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(accountPublishVersionOptions, "accountPublishVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(accountPublishVersionOptions, "accountPublishVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "account-publish"} + pathParameters := []string{*accountPublishVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range accountPublishVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "AccountPublishVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// IbmPublishVersion : Publish the specified version so that it is visible to IBMers in the public catalog +// Publish the specified version so that it is visible to IBMers in the public catalog. +func (catalogManagement *CatalogManagementV1) IbmPublishVersion(ibmPublishVersionOptions *IbmPublishVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(ibmPublishVersionOptions, "ibmPublishVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(ibmPublishVersionOptions, "ibmPublishVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "ibm-publish"} + pathParameters := []string{*ibmPublishVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range ibmPublishVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "IbmPublishVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// PublicPublishVersion : Publish the specified version so it is visible to all users in the public catalog +// Publish the specified version so it is visible to all users in the public catalog. +func (catalogManagement *CatalogManagementV1) PublicPublishVersion(publicPublishVersionOptions *PublicPublishVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(publicPublishVersionOptions, "publicPublishVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(publicPublishVersionOptions, "publicPublishVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "public-publish"} + pathParameters := []string{*publicPublishVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range publicPublishVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "PublicPublishVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// CommitVersion : Commit a working copy of the specified version +// Commit a working copy of the specified version. +func (catalogManagement *CatalogManagementV1) CommitVersion(commitVersionOptions *CommitVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(commitVersionOptions, "commitVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(commitVersionOptions, "commitVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "commit"} + pathParameters := []string{*commitVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range commitVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CommitVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetVersionWorkingCopy : Create a working copy of the specified version +// Create a working copy of the specified version. +func (catalogManagement *CatalogManagementV1) GetVersionWorkingCopy(getVersionWorkingCopyOptions *GetVersionWorkingCopyOptions) (result *Version, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionWorkingCopyOptions, "getVersionWorkingCopyOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionWorkingCopyOptions, "getVersionWorkingCopyOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "workingcopy"} + pathParameters := []string{*getVersionWorkingCopyOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionWorkingCopyOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersionWorkingCopy") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalVersion) + if err != nil { + return + } + response.Result = result + + return +} + +// GetVersionUpdates : Get available updates for the specified version +// Get available updates for the specified version. +func (catalogManagement *CatalogManagementV1) GetVersionUpdates(getVersionUpdatesOptions *GetVersionUpdatesOptions) (result []VersionUpdateDescriptor, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionUpdatesOptions, "getVersionUpdatesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionUpdatesOptions, "getVersionUpdatesOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "updates"} + pathParameters := []string{*getVersionUpdatesOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionUpdatesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersionUpdates") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if getVersionUpdatesOptions.ClusterID != nil { + builder.AddQuery("cluster_id", fmt.Sprint(*getVersionUpdatesOptions.ClusterID)) + } + if getVersionUpdatesOptions.Region != nil { + builder.AddQuery("region", fmt.Sprint(*getVersionUpdatesOptions.Region)) + } + if getVersionUpdatesOptions.ResourceGroupID != nil { + builder.AddQuery("resource_group_id", fmt.Sprint(*getVersionUpdatesOptions.ResourceGroupID)) + } + if getVersionUpdatesOptions.Namespace != nil { + builder.AddQuery("namespace", fmt.Sprint(*getVersionUpdatesOptions.Namespace)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse []json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalVersionUpdateDescriptor) + if err != nil { + return + } + response.Result = result + + return +} + +// GetVersion : Get the Offering/Kind/Version 'branch' for the specified locator ID +// Get the Offering/Kind/Version 'branch' for the specified locator ID. +func (catalogManagement *CatalogManagementV1) GetVersion(getVersionOptions *GetVersionOptions) (result *Offering, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getVersionOptions, "getVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getVersionOptions, "getVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions"} + pathParameters := []string{*getVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetVersion") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOffering) + if err != nil { + return + } + response.Result = result + + return +} + +// DeleteVersion : Delete a version +// Delete a the specified version. If the version is an active version with a working copy, the working copy will be +// deleted as well. +func (catalogManagement *CatalogManagementV1) DeleteVersion(deleteVersionOptions *DeleteVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deleteVersionOptions, "deleteVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deleteVersionOptions, "deleteVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions"} + pathParameters := []string{*deleteVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.DELETE) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deleteVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeleteVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// ListVersions : Search for versions +// [deprecated] use /search/license/versions api instead. Search across all accounts for versions, requires global +// admin permission. +func (catalogManagement *CatalogManagementV1) ListVersions(listVersionsOptions *ListVersionsOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(listVersionsOptions, "listVersionsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(listVersionsOptions, "listVersionsOptions") + if err != nil { + return + } + + pathSegments := []string{"versions"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listVersionsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListVersions") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + builder.AddQuery("q", fmt.Sprint(*listVersionsOptions.Q)) + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetRepos : List a repo's entries +// List the available entries from a given repo. +func (catalogManagement *CatalogManagementV1) GetRepos(getReposOptions *GetReposOptions) (result *HelmRepoList, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getReposOptions, "getReposOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getReposOptions, "getReposOptions") + if err != nil { + return + } + + pathSegments := []string{"repo", "entries"} + pathParameters := []string{*getReposOptions.Type} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getReposOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetRepos") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + builder.AddQuery("repourl", fmt.Sprint(*getReposOptions.Repourl)) + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalHelmRepoList) + if err != nil { + return + } + response.Result = result + + return +} + +// GetRepo : Get contents of a repo +// Get the contents of a given repo. +func (catalogManagement *CatalogManagementV1) GetRepo(getRepoOptions *GetRepoOptions) (result *HelmPackage, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getRepoOptions, "getRepoOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getRepoOptions, "getRepoOptions") + if err != nil { + return + } + + pathSegments := []string{"repo"} + pathParameters := []string{*getRepoOptions.Type} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getRepoOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetRepo") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + builder.AddQuery("charturl", fmt.Sprint(*getRepoOptions.Charturl)) + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalHelmPackage) + if err != nil { + return + } + response.Result = result + + return +} + +// ListClusters : List Kube clusters +// List Kube clusters. +func (catalogManagement *CatalogManagementV1) ListClusters(listClustersOptions *ListClustersOptions) (result *ClusterSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(listClustersOptions, "listClustersOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/clusters"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listClustersOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListClusters") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if listClustersOptions.Limit != nil { + builder.AddQuery("limit", fmt.Sprint(*listClustersOptions.Limit)) + } + if listClustersOptions.Offset != nil { + builder.AddQuery("offset", fmt.Sprint(*listClustersOptions.Offset)) + } + if listClustersOptions.Type != nil { + builder.AddQuery("type", fmt.Sprint(*listClustersOptions.Type)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalClusterSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// GetCluster : Get Kube cluster +// Get Kube cluster. +func (catalogManagement *CatalogManagementV1) GetCluster(getClusterOptions *GetClusterOptions) (result *ClusterInfo, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getClusterOptions, "getClusterOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getClusterOptions, "getClusterOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/clusters"} + pathParameters := []string{*getClusterOptions.ClusterID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getClusterOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetCluster") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if getClusterOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*getClusterOptions.XAuthRefreshToken)) + } + + builder.AddQuery("region", fmt.Sprint(*getClusterOptions.Region)) + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalClusterInfo) + if err != nil { + return + } + response.Result = result + + return +} + +// GetNamespaces : Get cluster namespaces +// Get cluster namespaces. +func (catalogManagement *CatalogManagementV1) GetNamespaces(getNamespacesOptions *GetNamespacesOptions) (result *NamespaceSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getNamespacesOptions, "getNamespacesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getNamespacesOptions, "getNamespacesOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/clusters", "namespaces"} + pathParameters := []string{*getNamespacesOptions.ClusterID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getNamespacesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetNamespaces") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if getNamespacesOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*getNamespacesOptions.XAuthRefreshToken)) + } + + builder.AddQuery("region", fmt.Sprint(*getNamespacesOptions.Region)) + if getNamespacesOptions.Limit != nil { + builder.AddQuery("limit", fmt.Sprint(*getNamespacesOptions.Limit)) + } + if getNamespacesOptions.Offset != nil { + builder.AddQuery("offset", fmt.Sprint(*getNamespacesOptions.Offset)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalNamespaceSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// CreateOperator : Deploy Operator(s) on a Kube cluster +// Deploy Operator(s) on a Kube cluster. +func (catalogManagement *CatalogManagementV1) CreateOperator(createOperatorOptions *CreateOperatorOptions) (result []OperatorDeployResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(createOperatorOptions, "createOperatorOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(createOperatorOptions, "createOperatorOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/olm/operator"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range createOperatorOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CreateOperator") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + if createOperatorOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*createOperatorOptions.XAuthRefreshToken)) + } + + body := make(map[string]interface{}) + if createOperatorOptions.ClusterID != nil { + body["cluster_id"] = createOperatorOptions.ClusterID + } + if createOperatorOptions.Region != nil { + body["region"] = createOperatorOptions.Region + } + if createOperatorOptions.Namespaces != nil { + body["namespaces"] = createOperatorOptions.Namespaces + } + if createOperatorOptions.VersionLocatorID != nil { + body["version_locator_id"] = createOperatorOptions.VersionLocatorID + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse []json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOperatorDeployResult) + if err != nil { + return + } + response.Result = result + + return +} + +// ListOperators : Get Operator(s) from a Kube cluster +// Get Operator(s) from a Kube cluster. +func (catalogManagement *CatalogManagementV1) ListOperators(listOperatorsOptions *ListOperatorsOptions) (result []OperatorDeployResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(listOperatorsOptions, "listOperatorsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(listOperatorsOptions, "listOperatorsOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/olm/operator"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listOperatorsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListOperators") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if listOperatorsOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*listOperatorsOptions.XAuthRefreshToken)) + } + + builder.AddQuery("cluster_id", fmt.Sprint(*listOperatorsOptions.ClusterID)) + builder.AddQuery("region", fmt.Sprint(*listOperatorsOptions.Region)) + builder.AddQuery("version_locator_id", fmt.Sprint(*listOperatorsOptions.VersionLocatorID)) + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse []json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOperatorDeployResult) + if err != nil { + return + } + response.Result = result + + return +} + +// ReplaceOperator : Update Operator(s) on a Kube cluster +// Update Operator(s) on a Kube cluster. +func (catalogManagement *CatalogManagementV1) ReplaceOperator(replaceOperatorOptions *ReplaceOperatorOptions) (result []OperatorDeployResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(replaceOperatorOptions, "replaceOperatorOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(replaceOperatorOptions, "replaceOperatorOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/olm/operator"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.PUT) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range replaceOperatorOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ReplaceOperator") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + if replaceOperatorOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*replaceOperatorOptions.XAuthRefreshToken)) + } + + body := make(map[string]interface{}) + if replaceOperatorOptions.ClusterID != nil { + body["cluster_id"] = replaceOperatorOptions.ClusterID + } + if replaceOperatorOptions.Region != nil { + body["region"] = replaceOperatorOptions.Region + } + if replaceOperatorOptions.Namespaces != nil { + body["namespaces"] = replaceOperatorOptions.Namespaces + } + if replaceOperatorOptions.VersionLocatorID != nil { + body["version_locator_id"] = replaceOperatorOptions.VersionLocatorID + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse []json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalOperatorDeployResult) + if err != nil { + return + } + response.Result = result + + return +} + +// DeleteOperator : Delete Operator(s) from a Kube cluster +// Delete Operator(s) from a Kube cluster. +func (catalogManagement *CatalogManagementV1) DeleteOperator(deleteOperatorOptions *DeleteOperatorOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deleteOperatorOptions, "deleteOperatorOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deleteOperatorOptions, "deleteOperatorOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/kubernetes/olm/operator"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.DELETE) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deleteOperatorOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeleteOperator") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + if deleteOperatorOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*deleteOperatorOptions.XAuthRefreshToken)) + } + + builder.AddQuery("cluster_id", fmt.Sprint(*deleteOperatorOptions.ClusterID)) + builder.AddQuery("region", fmt.Sprint(*deleteOperatorOptions.Region)) + builder.AddQuery("version_locator_id", fmt.Sprint(*deleteOperatorOptions.VersionLocatorID)) + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// InstallVersion : Create an install +// Create an install. +func (catalogManagement *CatalogManagementV1) InstallVersion(installVersionOptions *InstallVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(installVersionOptions, "installVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(installVersionOptions, "installVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "install"} + pathParameters := []string{*installVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range installVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "InstallVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Content-Type", "application/json") + if installVersionOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*installVersionOptions.XAuthRefreshToken)) + } + + body := make(map[string]interface{}) + if installVersionOptions.ClusterID != nil { + body["cluster_id"] = installVersionOptions.ClusterID + } + if installVersionOptions.Region != nil { + body["region"] = installVersionOptions.Region + } + if installVersionOptions.Namespace != nil { + body["namespace"] = installVersionOptions.Namespace + } + if installVersionOptions.OverrideValues != nil { + body["override_values"] = installVersionOptions.OverrideValues + } + if installVersionOptions.EntitlementApikey != nil { + body["entitlement_apikey"] = installVersionOptions.EntitlementApikey + } + if installVersionOptions.Schematics != nil { + body["schematics"] = installVersionOptions.Schematics + } + if installVersionOptions.Script != nil { + body["script"] = installVersionOptions.Script + } + if installVersionOptions.ScriptID != nil { + body["script_id"] = installVersionOptions.ScriptID + } + if installVersionOptions.VersionLocatorID != nil { + body["version_locator_id"] = installVersionOptions.VersionLocatorID + } + if installVersionOptions.VcenterID != nil { + body["vcenter_id"] = installVersionOptions.VcenterID + } + if installVersionOptions.VcenterPassword != nil { + body["vcenter_password"] = installVersionOptions.VcenterPassword + } + if installVersionOptions.VcenterLocation != nil { + body["vcenter_location"] = installVersionOptions.VcenterLocation + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// PreinstallVersion : Create a preinstall +// Create a preinstall. +func (catalogManagement *CatalogManagementV1) PreinstallVersion(preinstallVersionOptions *PreinstallVersionOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(preinstallVersionOptions, "preinstallVersionOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(preinstallVersionOptions, "preinstallVersionOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "preinstall"} + pathParameters := []string{*preinstallVersionOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range preinstallVersionOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "PreinstallVersion") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Content-Type", "application/json") + if preinstallVersionOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*preinstallVersionOptions.XAuthRefreshToken)) + } + + body := make(map[string]interface{}) + if preinstallVersionOptions.ClusterID != nil { + body["cluster_id"] = preinstallVersionOptions.ClusterID + } + if preinstallVersionOptions.Region != nil { + body["region"] = preinstallVersionOptions.Region + } + if preinstallVersionOptions.Namespace != nil { + body["namespace"] = preinstallVersionOptions.Namespace + } + if preinstallVersionOptions.OverrideValues != nil { + body["override_values"] = preinstallVersionOptions.OverrideValues + } + if preinstallVersionOptions.EntitlementApikey != nil { + body["entitlement_apikey"] = preinstallVersionOptions.EntitlementApikey + } + if preinstallVersionOptions.Schematics != nil { + body["schematics"] = preinstallVersionOptions.Schematics + } + if preinstallVersionOptions.Script != nil { + body["script"] = preinstallVersionOptions.Script + } + if preinstallVersionOptions.ScriptID != nil { + body["script_id"] = preinstallVersionOptions.ScriptID + } + if preinstallVersionOptions.VersionLocatorID != nil { + body["version_locator_id"] = preinstallVersionOptions.VersionLocatorID + } + if preinstallVersionOptions.VcenterID != nil { + body["vcenter_id"] = preinstallVersionOptions.VcenterID + } + if preinstallVersionOptions.VcenterPassword != nil { + body["vcenter_password"] = preinstallVersionOptions.VcenterPassword + } + if preinstallVersionOptions.VcenterLocation != nil { + body["vcenter_location"] = preinstallVersionOptions.VcenterLocation + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetPreinstall : Get a preinstall +// Get a preinstall. +func (catalogManagement *CatalogManagementV1) GetPreinstall(getPreinstallOptions *GetPreinstallOptions) (result *InstallStatus, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getPreinstallOptions, "getPreinstallOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getPreinstallOptions, "getPreinstallOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "preinstall"} + pathParameters := []string{*getPreinstallOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getPreinstallOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetPreinstall") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if getPreinstallOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*getPreinstallOptions.XAuthRefreshToken)) + } + + if getPreinstallOptions.ClusterID != nil { + builder.AddQuery("cluster_id", fmt.Sprint(*getPreinstallOptions.ClusterID)) + } + if getPreinstallOptions.Region != nil { + builder.AddQuery("region", fmt.Sprint(*getPreinstallOptions.Region)) + } + if getPreinstallOptions.Namespace != nil { + builder.AddQuery("namespace", fmt.Sprint(*getPreinstallOptions.Namespace)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalInstallStatus) + if err != nil { + return + } + response.Result = result + + return +} + +// ValidationInstall : Validate a offering +// Validate a offering. +func (catalogManagement *CatalogManagementV1) ValidationInstall(validationInstallOptions *ValidationInstallOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(validationInstallOptions, "validationInstallOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(validationInstallOptions, "validationInstallOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "validation/install"} + pathParameters := []string{*validationInstallOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range validationInstallOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ValidationInstall") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Content-Type", "application/json") + if validationInstallOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*validationInstallOptions.XAuthRefreshToken)) + } + + body := make(map[string]interface{}) + if validationInstallOptions.ClusterID != nil { + body["cluster_id"] = validationInstallOptions.ClusterID + } + if validationInstallOptions.Region != nil { + body["region"] = validationInstallOptions.Region + } + if validationInstallOptions.Namespace != nil { + body["namespace"] = validationInstallOptions.Namespace + } + if validationInstallOptions.OverrideValues != nil { + body["override_values"] = validationInstallOptions.OverrideValues + } + if validationInstallOptions.EntitlementApikey != nil { + body["entitlement_apikey"] = validationInstallOptions.EntitlementApikey + } + if validationInstallOptions.Schematics != nil { + body["schematics"] = validationInstallOptions.Schematics + } + if validationInstallOptions.Script != nil { + body["script"] = validationInstallOptions.Script + } + if validationInstallOptions.ScriptID != nil { + body["script_id"] = validationInstallOptions.ScriptID + } + if validationInstallOptions.VersionLocatorID != nil { + body["version_locator_id"] = validationInstallOptions.VersionLocatorID + } + if validationInstallOptions.VcenterID != nil { + body["vcenter_id"] = validationInstallOptions.VcenterID + } + if validationInstallOptions.VcenterPassword != nil { + body["vcenter_password"] = validationInstallOptions.VcenterPassword + } + if validationInstallOptions.VcenterLocation != nil { + body["vcenter_location"] = validationInstallOptions.VcenterLocation + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetValidationStatus : Returns the install status for the specified offering version +// Returns the install status for the specified offering version. +func (catalogManagement *CatalogManagementV1) GetValidationStatus(getValidationStatusOptions *GetValidationStatusOptions) (result *Validation, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getValidationStatusOptions, "getValidationStatusOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getValidationStatusOptions, "getValidationStatusOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "validation/install"} + pathParameters := []string{*getValidationStatusOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getValidationStatusOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetValidationStatus") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if getValidationStatusOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*getValidationStatusOptions.XAuthRefreshToken)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalValidation) + if err != nil { + return + } + response.Result = result + + return +} + +// GetOverrideValues : Returns the override values that were used to validate the specified offering version +// Returns the override values that were used to validate the specified offering version. +func (catalogManagement *CatalogManagementV1) GetOverrideValues(getOverrideValuesOptions *GetOverrideValuesOptions) (result map[string]interface{}, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getOverrideValuesOptions, "getOverrideValuesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getOverrideValuesOptions, "getOverrideValuesOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "validation/overridevalues"} + pathParameters := []string{*getOverrideValuesOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getOverrideValuesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetOverrideValues") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, &result) + + return +} + +// GetSchematicsWorkspaces : Returns the schematics workspaces for the specified offering version +// Returns the schematics workspaces for the specified offering version. +func (catalogManagement *CatalogManagementV1) GetSchematicsWorkspaces(getSchematicsWorkspacesOptions *GetSchematicsWorkspacesOptions) (result *SchematicsWorkspaceSearchResult, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getSchematicsWorkspacesOptions, "getSchematicsWorkspacesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getSchematicsWorkspacesOptions, "getSchematicsWorkspacesOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "workspaces"} + pathParameters := []string{*getSchematicsWorkspacesOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getSchematicsWorkspacesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetSchematicsWorkspaces") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + if getSchematicsWorkspacesOptions.XAuthRefreshToken != nil { + builder.AddHeader("X-Auth-Refresh-Token", fmt.Sprint(*getSchematicsWorkspacesOptions.XAuthRefreshToken)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalSchematicsWorkspaceSearchResult) + if err != nil { + return + } + response.Result = result + + return +} + +// CanDeploySchematics : Returns the schematics permissions for the specified user +// Returns the schematics permissions for the specified user. +func (catalogManagement *CatalogManagementV1) CanDeploySchematics(canDeploySchematicsOptions *CanDeploySchematicsOptions) (result *DeployRequirementsCheck, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(canDeploySchematicsOptions, "canDeploySchematicsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(canDeploySchematicsOptions, "canDeploySchematicsOptions") + if err != nil { + return + } + + pathSegments := []string{"versions", "candeploy"} + pathParameters := []string{*canDeploySchematicsOptions.VersionLocID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range canDeploySchematicsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CanDeploySchematics") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + builder.AddQuery("cluster_id", fmt.Sprint(*canDeploySchematicsOptions.ClusterID)) + builder.AddQuery("region", fmt.Sprint(*canDeploySchematicsOptions.Region)) + if canDeploySchematicsOptions.Namespace != nil { + builder.AddQuery("namespace", fmt.Sprint(*canDeploySchematicsOptions.Namespace)) + } + if canDeploySchematicsOptions.ResourceGroupID != nil { + builder.AddQuery("resource_group_id", fmt.Sprint(*canDeploySchematicsOptions.ResourceGroupID)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalDeployRequirementsCheck) + if err != nil { + return + } + response.Result = result + + return +} + +// GetResourceGroups : Returns all active resource groups in the current account, where the current user has permission to create schematics workspaces +// Returns all active resource groups in the current account, where the current user has permission to create schematics +// workspaces. +func (catalogManagement *CatalogManagementV1) GetResourceGroups(getResourceGroupsOptions *GetResourceGroupsOptions) (result *ResourceGroups, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(getResourceGroupsOptions, "getResourceGroupsOptions") + if err != nil { + return + } + + pathSegments := []string{"deploy/schematics/resourcegroups"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getResourceGroupsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetResourceGroups") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalResourceGroups) + if err != nil { + return + } + response.Result = result + + return +} + +// GetLicenseProviders : Get license providers +// Get license providers. +func (catalogManagement *CatalogManagementV1) GetLicenseProviders(getLicenseProvidersOptions *GetLicenseProvidersOptions) (result *LicenseProviders, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(getLicenseProvidersOptions, "getLicenseProvidersOptions") + if err != nil { + return + } + + pathSegments := []string{"license/license_providers"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getLicenseProvidersOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetLicenseProviders") + 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 = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalLicenseProviders) + if err != nil { + return + } + response.Result = result + + return +} + +// ListLicenseEntitlements : Get license entitlements +// Get license entitlements bound to an account. +func (catalogManagement *CatalogManagementV1) ListLicenseEntitlements(listLicenseEntitlementsOptions *ListLicenseEntitlementsOptions) (result *LicenseEntitlements, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(listLicenseEntitlementsOptions, "listLicenseEntitlementsOptions") + if err != nil { + return + } + + pathSegments := []string{"license/entitlements"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range listLicenseEntitlementsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "ListLicenseEntitlements") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if listLicenseEntitlementsOptions.AccountID != nil { + builder.AddQuery("account_id", fmt.Sprint(*listLicenseEntitlementsOptions.AccountID)) + } + if listLicenseEntitlementsOptions.LicenseProductID != nil { + builder.AddQuery("license_product_id", fmt.Sprint(*listLicenseEntitlementsOptions.LicenseProductID)) + } + if listLicenseEntitlementsOptions.VersionID != nil { + builder.AddQuery("version_id", fmt.Sprint(*listLicenseEntitlementsOptions.VersionID)) + } + if listLicenseEntitlementsOptions.State != nil { + builder.AddQuery("state", fmt.Sprint(*listLicenseEntitlementsOptions.State)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalLicenseEntitlements) + if err != nil { + return + } + response.Result = result + + return +} + +// CreateLicenseEntitlement : Create a license entitlement +// Create an entitlement for a Cloud account. This is used to give an account an entitlement to a license. +func (catalogManagement *CatalogManagementV1) CreateLicenseEntitlement(createLicenseEntitlementOptions *CreateLicenseEntitlementOptions) (result *LicenseEntitlement, response *core.DetailedResponse, err error) { + err = core.ValidateStruct(createLicenseEntitlementOptions, "createLicenseEntitlementOptions") + if err != nil { + return + } + + pathSegments := []string{"license/entitlements"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.POST) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range createLicenseEntitlementOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "CreateLicenseEntitlement") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + builder.AddHeader("Content-Type", "application/json") + + if createLicenseEntitlementOptions.AccountID != nil { + builder.AddQuery("account_id", fmt.Sprint(*createLicenseEntitlementOptions.AccountID)) + } + + body := make(map[string]interface{}) + if createLicenseEntitlementOptions.Name != nil { + body["name"] = createLicenseEntitlementOptions.Name + } + if createLicenseEntitlementOptions.EffectiveFrom != nil { + body["effective_from"] = createLicenseEntitlementOptions.EffectiveFrom + } + if createLicenseEntitlementOptions.EffectiveUntil != nil { + body["effective_until"] = createLicenseEntitlementOptions.EffectiveUntil + } + if createLicenseEntitlementOptions.VersionID != nil { + body["version_id"] = createLicenseEntitlementOptions.VersionID + } + if createLicenseEntitlementOptions.LicenseID != nil { + body["license_id"] = createLicenseEntitlementOptions.LicenseID + } + if createLicenseEntitlementOptions.LicenseOwnerID != nil { + body["license_owner_id"] = createLicenseEntitlementOptions.LicenseOwnerID + } + if createLicenseEntitlementOptions.LicenseProviderID != nil { + body["license_provider_id"] = createLicenseEntitlementOptions.LicenseProviderID + } + if createLicenseEntitlementOptions.LicenseProductID != nil { + body["license_product_id"] = createLicenseEntitlementOptions.LicenseProductID + } + _, err = builder.SetBodyContentJSON(body) + if err != nil { + return + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalLicenseEntitlement) + if err != nil { + return + } + response.Result = result + + return +} + +// GetLicenseEntitlements : Get entitlements for a specific license product ID +// Get an entitlements for a specific license product ID bound to an account. +func (catalogManagement *CatalogManagementV1) GetLicenseEntitlements(getLicenseEntitlementsOptions *GetLicenseEntitlementsOptions) (result *LicenseEntitlements, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getLicenseEntitlementsOptions, "getLicenseEntitlementsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getLicenseEntitlementsOptions, "getLicenseEntitlementsOptions") + if err != nil { + return + } + + pathSegments := []string{"license/entitlements/productID"} + pathParameters := []string{*getLicenseEntitlementsOptions.LicenseProductID} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getLicenseEntitlementsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetLicenseEntitlements") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + if getLicenseEntitlementsOptions.AccountID != nil { + builder.AddQuery("account_id", fmt.Sprint(*getLicenseEntitlementsOptions.AccountID)) + } + if getLicenseEntitlementsOptions.VersionID != nil { + builder.AddQuery("version_id", fmt.Sprint(*getLicenseEntitlementsOptions.VersionID)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalLicenseEntitlements) + if err != nil { + return + } + response.Result = result + + return +} + +// DeleteLicenseEntitlement : Delete license entitlement +// Delete a license entitlement that is bound to an account. Note that BSS will mark the entitlement field "state": +// "removed". +func (catalogManagement *CatalogManagementV1) DeleteLicenseEntitlement(deleteLicenseEntitlementOptions *DeleteLicenseEntitlementOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(deleteLicenseEntitlementOptions, "deleteLicenseEntitlementOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(deleteLicenseEntitlementOptions, "deleteLicenseEntitlementOptions") + if err != nil { + return + } + + pathSegments := []string{"license/entitlements"} + pathParameters := []string{*deleteLicenseEntitlementOptions.EntitlementID} + + builder := core.NewRequestBuilder(core.DELETE) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range deleteLicenseEntitlementOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "DeleteLicenseEntitlement") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + if deleteLicenseEntitlementOptions.AccountID != nil { + builder.AddQuery("account_id", fmt.Sprint(*deleteLicenseEntitlementOptions.AccountID)) + } + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// GetLicenses : Get licenses +// Retrieve available licenses from supported license subsystems. This is used to get the list of available licenses +// that the user has. +func (catalogManagement *CatalogManagementV1) GetLicenses(getLicensesOptions *GetLicensesOptions) (result *Licenses, response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(getLicensesOptions, "getLicensesOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(getLicensesOptions, "getLicensesOptions") + if err != nil { + return + } + + pathSegments := []string{"license/licenses"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range getLicensesOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "GetLicenses") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + builder.AddHeader("Accept", "application/json") + + builder.AddQuery("license_provider_id", fmt.Sprint(*getLicensesOptions.LicenseProviderID)) + if getLicensesOptions.AccountID != nil { + builder.AddQuery("account_id", fmt.Sprint(*getLicensesOptions.AccountID)) + } + if getLicensesOptions.Name != nil { + builder.AddQuery("name", fmt.Sprint(*getLicensesOptions.Name)) + } + if getLicensesOptions.LicenseType != nil { + builder.AddQuery("license_type", fmt.Sprint(*getLicensesOptions.LicenseType)) + } + if getLicensesOptions.LicenseProductID != nil { + builder.AddQuery("license_product_id", fmt.Sprint(*getLicensesOptions.LicenseProductID)) + } + + request, err := builder.Build() + if err != nil { + return + } + + var rawResponse map[string]json.RawMessage + response, err = catalogManagement.Service.Request(request, &rawResponse) + if err != nil { + return + } + err = core.UnmarshalModel(rawResponse, "", &result, UnmarshalLicenses) + if err != nil { + return + } + response.Result = result + + return +} + +// SearchLicenseVersions : Search for versions +// Search across accounts for all versions usig a particular license, requires global admin permission. +func (catalogManagement *CatalogManagementV1) SearchLicenseVersions(searchLicenseVersionsOptions *SearchLicenseVersionsOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(searchLicenseVersionsOptions, "searchLicenseVersionsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(searchLicenseVersionsOptions, "searchLicenseVersionsOptions") + if err != nil { + return + } + + pathSegments := []string{"search/license/versions"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range searchLicenseVersionsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "SearchLicenseVersions") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + builder.AddQuery("q", fmt.Sprint(*searchLicenseVersionsOptions.Q)) + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// SearchLicenseOfferings : Search for Offerings +// Search across accounts for all offerings using a particular license, requires global admin permission. +func (catalogManagement *CatalogManagementV1) SearchLicenseOfferings(searchLicenseOfferingsOptions *SearchLicenseOfferingsOptions) (response *core.DetailedResponse, err error) { + err = core.ValidateNotNil(searchLicenseOfferingsOptions, "searchLicenseOfferingsOptions cannot be nil") + if err != nil { + return + } + err = core.ValidateStruct(searchLicenseOfferingsOptions, "searchLicenseOfferingsOptions") + if err != nil { + return + } + + pathSegments := []string{"search/license/offerings"} + pathParameters := []string{} + + builder := core.NewRequestBuilder(core.GET) + _, err = builder.ConstructHTTPURL(catalogManagement.Service.Options.URL, pathSegments, pathParameters) + if err != nil { + return + } + + for headerName, headerValue := range searchLicenseOfferingsOptions.Headers { + builder.AddHeader(headerName, headerValue) + } + + sdkHeaders := common.GetSdkHeaders("catalog_management", "V1", "SearchLicenseOfferings") + for headerName, headerValue := range sdkHeaders { + builder.AddHeader(headerName, headerValue) + } + + builder.AddQuery("q", fmt.Sprint(*searchLicenseOfferingsOptions.Q)) + + request, err := builder.Build() + if err != nil { + return + } + + response, err = catalogManagement.Service.Request(request, nil) + + return +} + +// Account : Account information. +type Account struct { + // Account identification. + ID *string `json:"id,omitempty"` + + // Filters for account and catalog filters. + AccountFilters *Filters `json:"account_filters,omitempty"` +} + + +// UnmarshalAccount unmarshals an instance of Account from the specified map of raw messages. +func UnmarshalAccount(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Account) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalModel(m, "account_filters", &obj.AccountFilters, UnmarshalFilters) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// AccountGroup : Filters for an Account Group. +type AccountGroup struct { + // Account group identification. + ID *string `json:"id,omitempty"` + + // Filters for account and catalog filters. + AccountFilters *Filters `json:"account_filters,omitempty"` +} + + +// UnmarshalAccountGroup unmarshals an instance of AccountGroup from the specified map of raw messages. +func UnmarshalAccountGroup(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(AccountGroup) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalModel(m, "account_filters", &obj.AccountFilters, UnmarshalFilters) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// AccountPublishVersionOptions : The AccountPublishVersion options. +type AccountPublishVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewAccountPublishVersionOptions : Instantiate AccountPublishVersionOptions +func (*CatalogManagementV1) NewAccountPublishVersionOptions(versionLocID string) *AccountPublishVersionOptions { + return &AccountPublishVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *AccountPublishVersionOptions) SetVersionLocID(versionLocID string) *AccountPublishVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *AccountPublishVersionOptions) SetHeaders(param map[string]string) *AccountPublishVersionOptions { + options.Headers = param + return options +} + +// AccumulatedFilters : The accumulated filters for an account. This will return the account filters plus a filter for each catalog the user +// has access to. +type AccumulatedFilters struct { + // Filters for accounts (at this time this will always be just one item array). + AccountFilters []Filters `json:"account_filters,omitempty"` + + // The filters for all of the accessible catalogs. + CatalogFilters []AccumulatedFiltersCatalogFiltersItem `json:"catalog_filters,omitempty"` +} + + +// UnmarshalAccumulatedFilters unmarshals an instance of AccumulatedFilters from the specified map of raw messages. +func UnmarshalAccumulatedFilters(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(AccumulatedFilters) + err = core.UnmarshalModel(m, "account_filters", &obj.AccountFilters, UnmarshalFilters) + if err != nil { + return + } + err = core.UnmarshalModel(m, "catalog_filters", &obj.CatalogFilters, UnmarshalAccumulatedFiltersCatalogFiltersItem) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// AccumulatedFiltersCatalogFiltersItem : AccumulatedFiltersCatalogFiltersItem struct +type AccumulatedFiltersCatalogFiltersItem struct { + // Filters for catalog. + Catalog *AccumulatedFiltersCatalogFiltersItemCatalog `json:"catalog,omitempty"` + + // Filters for account and catalog filters. + Filters *Filters `json:"filters,omitempty"` +} + + +// UnmarshalAccumulatedFiltersCatalogFiltersItem unmarshals an instance of AccumulatedFiltersCatalogFiltersItem from the specified map of raw messages. +func UnmarshalAccumulatedFiltersCatalogFiltersItem(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(AccumulatedFiltersCatalogFiltersItem) + err = core.UnmarshalModel(m, "catalog", &obj.Catalog, UnmarshalAccumulatedFiltersCatalogFiltersItemCatalog) + if err != nil { + return + } + err = core.UnmarshalModel(m, "filters", &obj.Filters, UnmarshalFilters) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// AccumulatedFiltersCatalogFiltersItemCatalog : Filters for catalog. +type AccumulatedFiltersCatalogFiltersItemCatalog struct { + // The ID of the catalog. + ID *string `json:"id,omitempty"` + + // The name of the catalog. + Name *string `json:"name,omitempty"` +} + + +// UnmarshalAccumulatedFiltersCatalogFiltersItemCatalog unmarshals an instance of AccumulatedFiltersCatalogFiltersItemCatalog from the specified map of raw messages. +func UnmarshalAccumulatedFiltersCatalogFiltersItemCatalog(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(AccumulatedFiltersCatalogFiltersItemCatalog) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ApprovalResult : Result of approval. +type ApprovalResult struct { + // Visible to IBM. + Ibm *bool `json:"ibm,omitempty"` + + // Visible to everyone. + Public *bool `json:"public,omitempty"` + + // Denotes whether approval has changed. + Changed *bool `json:"changed,omitempty"` +} + + +// UnmarshalApprovalResult unmarshals an instance of ApprovalResult from the specified map of raw messages. +func UnmarshalApprovalResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ApprovalResult) + err = core.UnmarshalPrimitive(m, "ibm", &obj.Ibm) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "public", &obj.Public) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "changed", &obj.Changed) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// CanDeploySchematicsOptions : The CanDeploySchematics options. +type CanDeploySchematicsOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // ID of the cluster. + ClusterID *string `json:"cluster_id" validate:"required"` + + // Cluster region. + Region *string `json:"region" validate:"required"` + + // Required if the version's pre-install scope is `namespace`. + Namespace *string `json:"namespace,omitempty"` + + // Resource group identification. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCanDeploySchematicsOptions : Instantiate CanDeploySchematicsOptions +func (*CatalogManagementV1) NewCanDeploySchematicsOptions(versionLocID string, clusterID string, region string) *CanDeploySchematicsOptions { + return &CanDeploySchematicsOptions{ + VersionLocID: core.StringPtr(versionLocID), + ClusterID: core.StringPtr(clusterID), + Region: core.StringPtr(region), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *CanDeploySchematicsOptions) SetVersionLocID(versionLocID string) *CanDeploySchematicsOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *CanDeploySchematicsOptions) SetClusterID(clusterID string) *CanDeploySchematicsOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *CanDeploySchematicsOptions) SetRegion(region string) *CanDeploySchematicsOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *CanDeploySchematicsOptions) SetNamespace(namespace string) *CanDeploySchematicsOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetResourceGroupID : Allow user to set ResourceGroupID +func (options *CanDeploySchematicsOptions) SetResourceGroupID(resourceGroupID string) *CanDeploySchematicsOptions { + options.ResourceGroupID = core.StringPtr(resourceGroupID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CanDeploySchematicsOptions) SetHeaders(param map[string]string) *CanDeploySchematicsOptions { + options.Headers = param + return options +} + +// Catalog : Catalog information. +type Catalog struct { + // Unique ID. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // Description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // URL for an icon associated with this catalog. + CatalogIconURL *string `json:"catalog_icon_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // The url for this specific catalog. + URL *string `json:"url,omitempty"` + + // CRN associated with the catalog. + Crn *string `json:"crn,omitempty"` + + // URL path to offerings. + OfferingsURL *string `json:"offerings_url,omitempty"` + + // List of features associated with this catalog. + Features []Feature `json:"features,omitempty"` + + // Denotes whether a catalog is disabled. + Disabled *bool `json:"disabled,omitempty"` + + // The date'time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date'time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Resource group id the catalog is owned by. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // Account that owns catalog. + OwningAccount *string `json:"owning_account,omitempty"` + + // Filters for account and catalog filters. + CatalogFilters *Filters `json:"catalog_filters,omitempty"` + + // Feature information. + SyndicationSettings *SyndicationResource `json:"syndication_settings,omitempty"` +} + + +// UnmarshalCatalog unmarshals an instance of Catalog from the specified map of raw messages. +func UnmarshalCatalog(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Catalog) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "_rev", &obj.Rev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "label", &obj.Label) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "short_description", &obj.ShortDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_icon_url", &obj.CatalogIconURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "url", &obj.URL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offerings_url", &obj.OfferingsURL) + if err != nil { + return + } + err = core.UnmarshalModel(m, "features", &obj.Features, UnmarshalFeature) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "disabled", &obj.Disabled) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_group_id", &obj.ResourceGroupID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "owning_account", &obj.OwningAccount) + if err != nil { + return + } + err = core.UnmarshalModel(m, "catalog_filters", &obj.CatalogFilters, UnmarshalFilters) + if err != nil { + return + } + err = core.UnmarshalModel(m, "syndication_settings", &obj.SyndicationSettings, UnmarshalSyndicationResource) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// CatalogSearchResult : Paginated catalog search result. +type CatalogSearchResult struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting objects. + Resources []Catalog `json:"resources,omitempty"` +} + + +// UnmarshalCatalogSearchResult unmarshals an instance of CatalogSearchResult from the specified map of raw messages. +func UnmarshalCatalogSearchResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(CatalogSearchResult) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalCatalog) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// CategoryFilter : Filter on a category. The filter will match against the values of the given category with include or exclude. +type CategoryFilter struct { + // -> true - This is an include filter, false - this is an exclude filter. + Include *bool `json:"include,omitempty"` + + // Offering filter terms. + Filter *FilterTerms `json:"filter,omitempty"` +} + + +// UnmarshalCategoryFilter unmarshals an instance of CategoryFilter from the specified map of raw messages. +func UnmarshalCategoryFilter(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(CategoryFilter) + err = core.UnmarshalPrimitive(m, "include", &obj.Include) + if err != nil { + return + } + err = core.UnmarshalModel(m, "filter", &obj.Filter, UnmarshalFilterTerms) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ClusterInfo : Cluster information. +type ClusterInfo struct { + // Resource Group ID. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // Resource Group name. + ResourceGroupName *string `json:"resource_group_name,omitempty"` + + // Cluster ID. + ID *string `json:"id,omitempty"` + + // Cluster name. + Name *string `json:"name,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` +} + + +// UnmarshalClusterInfo unmarshals an instance of ClusterInfo from the specified map of raw messages. +func UnmarshalClusterInfo(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ClusterInfo) + err = core.UnmarshalPrimitive(m, "resource_group_id", &obj.ResourceGroupID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_group_name", &obj.ResourceGroupName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "region", &obj.Region) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ClusterSearchResult : Paginated cluster search result. +type ClusterSearchResult struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting objects. + Resources []ClusterInfo `json:"resources,omitempty"` +} + + +// UnmarshalClusterSearchResult unmarshals an instance of ClusterSearchResult from the specified map of raw messages. +func UnmarshalClusterSearchResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ClusterSearchResult) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalClusterInfo) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// CommitVersionOptions : The CommitVersion options. +type CommitVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCommitVersionOptions : Instantiate CommitVersionOptions +func (*CatalogManagementV1) NewCommitVersionOptions(versionLocID string) *CommitVersionOptions { + return &CommitVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *CommitVersionOptions) SetVersionLocID(versionLocID string) *CommitVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CommitVersionOptions) SetHeaders(param map[string]string) *CommitVersionOptions { + options.Headers = param + return options +} + +// Configuration : Configuration description. +type Configuration struct { + // Configuration key. + Key *string `json:"key,omitempty"` + + // Value type (string, boolean, int). + Type *string `json:"type,omitempty"` + + // The default value. + DefaultValue interface{} `json:"default_value,omitempty"` + + // Constraint associated with value, e.g., for string type - regx:[a-z]. + ValueConstraint *string `json:"value_constraint,omitempty"` + + // Key description. + Description *string `json:"description,omitempty"` + + // Is key required to install. + Required *bool `json:"required,omitempty"` + + // List of options of type. + Options []interface{} `json:"options,omitempty"` + + // Hide values. + Hidden *bool `json:"hidden,omitempty"` +} + + +// UnmarshalConfiguration unmarshals an instance of Configuration from the specified map of raw messages. +func UnmarshalConfiguration(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Configuration) + err = core.UnmarshalPrimitive(m, "key", &obj.Key) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "default_value", &obj.DefaultValue) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "value_constraint", &obj.ValueConstraint) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "required", &obj.Required) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "options", &obj.Options) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "hidden", &obj.Hidden) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// CreateCatalogOptions : The CreateCatalog options. +type CreateCatalogOptions struct { + // Unique ID. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // Description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // URL for an icon associated with this catalog. + CatalogIconURL *string `json:"catalog_icon_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // The url for this specific catalog. + URL *string `json:"url,omitempty"` + + // CRN associated with the catalog. + Crn *string `json:"crn,omitempty"` + + // URL path to offerings. + OfferingsURL *string `json:"offerings_url,omitempty"` + + // List of features associated with this catalog. + Features []Feature `json:"features,omitempty"` + + // Denotes whether a catalog is disabled. + Disabled *bool `json:"disabled,omitempty"` + + // The date'time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date'time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Resource group id the catalog is owned by. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // Account that owns catalog. + OwningAccount *string `json:"owning_account,omitempty"` + + // Filters for account and catalog filters. + CatalogFilters *Filters `json:"catalog_filters,omitempty"` + + // Feature information. + SyndicationSettings *SyndicationResource `json:"syndication_settings,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCreateCatalogOptions : Instantiate CreateCatalogOptions +func (*CatalogManagementV1) NewCreateCatalogOptions() *CreateCatalogOptions { + return &CreateCatalogOptions{} +} + +// SetID : Allow user to set ID +func (options *CreateCatalogOptions) SetID(id string) *CreateCatalogOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetRev : Allow user to set Rev +func (options *CreateCatalogOptions) SetRev(rev string) *CreateCatalogOptions { + options.Rev = core.StringPtr(rev) + return options +} + +// SetLabel : Allow user to set Label +func (options *CreateCatalogOptions) SetLabel(label string) *CreateCatalogOptions { + options.Label = core.StringPtr(label) + return options +} + +// SetShortDescription : Allow user to set ShortDescription +func (options *CreateCatalogOptions) SetShortDescription(shortDescription string) *CreateCatalogOptions { + options.ShortDescription = core.StringPtr(shortDescription) + return options +} + +// SetCatalogIconURL : Allow user to set CatalogIconURL +func (options *CreateCatalogOptions) SetCatalogIconURL(catalogIconURL string) *CreateCatalogOptions { + options.CatalogIconURL = core.StringPtr(catalogIconURL) + return options +} + +// SetTags : Allow user to set Tags +func (options *CreateCatalogOptions) SetTags(tags []string) *CreateCatalogOptions { + options.Tags = tags + return options +} + +// SetURL : Allow user to set URL +func (options *CreateCatalogOptions) SetURL(url string) *CreateCatalogOptions { + options.URL = core.StringPtr(url) + return options +} + +// SetCrn : Allow user to set Crn +func (options *CreateCatalogOptions) SetCrn(crn string) *CreateCatalogOptions { + options.Crn = core.StringPtr(crn) + return options +} + +// SetOfferingsURL : Allow user to set OfferingsURL +func (options *CreateCatalogOptions) SetOfferingsURL(offeringsURL string) *CreateCatalogOptions { + options.OfferingsURL = core.StringPtr(offeringsURL) + return options +} + +// SetFeatures : Allow user to set Features +func (options *CreateCatalogOptions) SetFeatures(features []Feature) *CreateCatalogOptions { + options.Features = features + return options +} + +// SetDisabled : Allow user to set Disabled +func (options *CreateCatalogOptions) SetDisabled(disabled bool) *CreateCatalogOptions { + options.Disabled = core.BoolPtr(disabled) + return options +} + +// SetCreated : Allow user to set Created +func (options *CreateCatalogOptions) SetCreated(created *strfmt.DateTime) *CreateCatalogOptions { + options.Created = created + return options +} + +// SetUpdated : Allow user to set Updated +func (options *CreateCatalogOptions) SetUpdated(updated *strfmt.DateTime) *CreateCatalogOptions { + options.Updated = updated + return options +} + +// SetResourceGroupID : Allow user to set ResourceGroupID +func (options *CreateCatalogOptions) SetResourceGroupID(resourceGroupID string) *CreateCatalogOptions { + options.ResourceGroupID = core.StringPtr(resourceGroupID) + return options +} + +// SetOwningAccount : Allow user to set OwningAccount +func (options *CreateCatalogOptions) SetOwningAccount(owningAccount string) *CreateCatalogOptions { + options.OwningAccount = core.StringPtr(owningAccount) + return options +} + +// SetCatalogFilters : Allow user to set CatalogFilters +func (options *CreateCatalogOptions) SetCatalogFilters(catalogFilters *Filters) *CreateCatalogOptions { + options.CatalogFilters = catalogFilters + return options +} + +// SetSyndicationSettings : Allow user to set SyndicationSettings +func (options *CreateCatalogOptions) SetSyndicationSettings(syndicationSettings *SyndicationResource) *CreateCatalogOptions { + options.SyndicationSettings = syndicationSettings + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CreateCatalogOptions) SetHeaders(param map[string]string) *CreateCatalogOptions { + options.Headers = param + return options +} + +// CreateLicenseEntitlementOptions : The CreateLicenseEntitlement options. +type CreateLicenseEntitlementOptions struct { + // Entitlement name. + Name *string `json:"name,omitempty"` + + // Entitlement is good from this starting date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveFrom *string `json:"effective_from,omitempty"` + + // Entitlement is good until this ending date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveUntil *string `json:"effective_until,omitempty"` + + // Global Catalog ID of the version. + VersionID *string `json:"version_id,omitempty"` + + // Specific license entitlement ID from the license provider, eg. D1W3R4. + LicenseID *string `json:"license_id,omitempty"` + + // IBM ID of the owner of this license entitlement. + LicenseOwnerID *string `json:"license_owner_id,omitempty"` + + // License provider ID. + LicenseProviderID *string `json:"license_provider_id,omitempty"` + + // License product ID. + LicenseProductID *string `json:"license_product_id,omitempty"` + + // if not specified the token's account will be used. + AccountID *string `json:"account_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCreateLicenseEntitlementOptions : Instantiate CreateLicenseEntitlementOptions +func (*CatalogManagementV1) NewCreateLicenseEntitlementOptions() *CreateLicenseEntitlementOptions { + return &CreateLicenseEntitlementOptions{} +} + +// SetName : Allow user to set Name +func (options *CreateLicenseEntitlementOptions) SetName(name string) *CreateLicenseEntitlementOptions { + options.Name = core.StringPtr(name) + return options +} + +// SetEffectiveFrom : Allow user to set EffectiveFrom +func (options *CreateLicenseEntitlementOptions) SetEffectiveFrom(effectiveFrom string) *CreateLicenseEntitlementOptions { + options.EffectiveFrom = core.StringPtr(effectiveFrom) + return options +} + +// SetEffectiveUntil : Allow user to set EffectiveUntil +func (options *CreateLicenseEntitlementOptions) SetEffectiveUntil(effectiveUntil string) *CreateLicenseEntitlementOptions { + options.EffectiveUntil = core.StringPtr(effectiveUntil) + return options +} + +// SetVersionID : Allow user to set VersionID +func (options *CreateLicenseEntitlementOptions) SetVersionID(versionID string) *CreateLicenseEntitlementOptions { + options.VersionID = core.StringPtr(versionID) + return options +} + +// SetLicenseID : Allow user to set LicenseID +func (options *CreateLicenseEntitlementOptions) SetLicenseID(licenseID string) *CreateLicenseEntitlementOptions { + options.LicenseID = core.StringPtr(licenseID) + return options +} + +// SetLicenseOwnerID : Allow user to set LicenseOwnerID +func (options *CreateLicenseEntitlementOptions) SetLicenseOwnerID(licenseOwnerID string) *CreateLicenseEntitlementOptions { + options.LicenseOwnerID = core.StringPtr(licenseOwnerID) + return options +} + +// SetLicenseProviderID : Allow user to set LicenseProviderID +func (options *CreateLicenseEntitlementOptions) SetLicenseProviderID(licenseProviderID string) *CreateLicenseEntitlementOptions { + options.LicenseProviderID = core.StringPtr(licenseProviderID) + return options +} + +// SetLicenseProductID : Allow user to set LicenseProductID +func (options *CreateLicenseEntitlementOptions) SetLicenseProductID(licenseProductID string) *CreateLicenseEntitlementOptions { + options.LicenseProductID = core.StringPtr(licenseProductID) + return options +} + +// SetAccountID : Allow user to set AccountID +func (options *CreateLicenseEntitlementOptions) SetAccountID(accountID string) *CreateLicenseEntitlementOptions { + options.AccountID = core.StringPtr(accountID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CreateLicenseEntitlementOptions) SetHeaders(param map[string]string) *CreateLicenseEntitlementOptions { + options.Headers = param + return options +} + +// CreateOfferingOptions : The CreateOffering options. +type CreateOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // unique id. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // The url for this specific offering. + URL *string `json:"url,omitempty"` + + // The crn for this specific offering. + Crn *string `json:"crn,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // The programmatic name of this offering. + Name *string `json:"name,omitempty"` + + // URL for an icon associated with this offering. + OfferingIconURL *string `json:"offering_icon_url,omitempty"` + + // URL for an additional docs with this offering. + OfferingDocsURL *string `json:"offering_docs_url,omitempty"` + + // URL to be displayed in the Consumption UI for getting support on this offering. + OfferingSupportURL *string `json:"offering_support_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // Repository info for offerings. + Rating *Rating `json:"rating,omitempty"` + + // The date and time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date and time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Short description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // Long description in the requested language. + LongDescription *string `json:"long_description,omitempty"` + + // list of features associated with this offering. + Features []Feature `json:"features,omitempty"` + + // Array of kind. + Kinds []Kind `json:"kinds,omitempty"` + + // Is it permitted to request publishing to IBM or Public. + PermitRequestIbmPublicPublish *bool `json:"permit_request_ibm_public_publish,omitempty"` + + // Indicates if this offering has been approved for use by all IBMers. + IbmPublishApproved *bool `json:"ibm_publish_approved,omitempty"` + + // Indicates if this offering has been approved for use by all IBM Cloud users. + PublicPublishApproved *bool `json:"public_publish_approved,omitempty"` + + // The original offering CRN that this publish entry came from. + PublicOriginalCrn *string `json:"public_original_crn,omitempty"` + + // The crn of the public catalog entry of this offering. + PublishPublicCrn *string `json:"publish_public_crn,omitempty"` + + // The portal's approval record ID. + PortalApprovalRecord *string `json:"portal_approval_record,omitempty"` + + // The portal UI URL. + PortalUiURL *string `json:"portal_ui_url,omitempty"` + + // The id of the catalog containing this offering. + CatalogID *string `json:"catalog_id,omitempty"` + + // The name of the catalog. + CatalogName *string `json:"catalog_name,omitempty"` + + // Map of metadata values for this offering. + Metadata interface{} `json:"metadata,omitempty"` + + // A disclaimer for this offering. + Disclaimer *string `json:"disclaimer,omitempty"` + + // Determine if this offering should be displayed in the Consumption UI. + Hidden *bool `json:"hidden,omitempty"` + + // Provider of this offering. + Provider *string `json:"provider,omitempty"` + + // Repository info for offerings. + RepoInfo *RepoInfo `json:"repo_info,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCreateOfferingOptions : Instantiate CreateOfferingOptions +func (*CatalogManagementV1) NewCreateOfferingOptions(catalogIdentifier string) *CreateOfferingOptions { + return &CreateOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *CreateOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *CreateOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetID : Allow user to set ID +func (options *CreateOfferingOptions) SetID(id string) *CreateOfferingOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetRev : Allow user to set Rev +func (options *CreateOfferingOptions) SetRev(rev string) *CreateOfferingOptions { + options.Rev = core.StringPtr(rev) + return options +} + +// SetURL : Allow user to set URL +func (options *CreateOfferingOptions) SetURL(url string) *CreateOfferingOptions { + options.URL = core.StringPtr(url) + return options +} + +// SetCrn : Allow user to set Crn +func (options *CreateOfferingOptions) SetCrn(crn string) *CreateOfferingOptions { + options.Crn = core.StringPtr(crn) + return options +} + +// SetLabel : Allow user to set Label +func (options *CreateOfferingOptions) SetLabel(label string) *CreateOfferingOptions { + options.Label = core.StringPtr(label) + return options +} + +// SetName : Allow user to set Name +func (options *CreateOfferingOptions) SetName(name string) *CreateOfferingOptions { + options.Name = core.StringPtr(name) + return options +} + +// SetOfferingIconURL : Allow user to set OfferingIconURL +func (options *CreateOfferingOptions) SetOfferingIconURL(offeringIconURL string) *CreateOfferingOptions { + options.OfferingIconURL = core.StringPtr(offeringIconURL) + return options +} + +// SetOfferingDocsURL : Allow user to set OfferingDocsURL +func (options *CreateOfferingOptions) SetOfferingDocsURL(offeringDocsURL string) *CreateOfferingOptions { + options.OfferingDocsURL = core.StringPtr(offeringDocsURL) + return options +} + +// SetOfferingSupportURL : Allow user to set OfferingSupportURL +func (options *CreateOfferingOptions) SetOfferingSupportURL(offeringSupportURL string) *CreateOfferingOptions { + options.OfferingSupportURL = core.StringPtr(offeringSupportURL) + return options +} + +// SetTags : Allow user to set Tags +func (options *CreateOfferingOptions) SetTags(tags []string) *CreateOfferingOptions { + options.Tags = tags + return options +} + +// SetRating : Allow user to set Rating +func (options *CreateOfferingOptions) SetRating(rating *Rating) *CreateOfferingOptions { + options.Rating = rating + return options +} + +// SetCreated : Allow user to set Created +func (options *CreateOfferingOptions) SetCreated(created *strfmt.DateTime) *CreateOfferingOptions { + options.Created = created + return options +} + +// SetUpdated : Allow user to set Updated +func (options *CreateOfferingOptions) SetUpdated(updated *strfmt.DateTime) *CreateOfferingOptions { + options.Updated = updated + return options +} + +// SetShortDescription : Allow user to set ShortDescription +func (options *CreateOfferingOptions) SetShortDescription(shortDescription string) *CreateOfferingOptions { + options.ShortDescription = core.StringPtr(shortDescription) + return options +} + +// SetLongDescription : Allow user to set LongDescription +func (options *CreateOfferingOptions) SetLongDescription(longDescription string) *CreateOfferingOptions { + options.LongDescription = core.StringPtr(longDescription) + return options +} + +// SetFeatures : Allow user to set Features +func (options *CreateOfferingOptions) SetFeatures(features []Feature) *CreateOfferingOptions { + options.Features = features + return options +} + +// SetKinds : Allow user to set Kinds +func (options *CreateOfferingOptions) SetKinds(kinds []Kind) *CreateOfferingOptions { + options.Kinds = kinds + return options +} + +// SetPermitRequestIbmPublicPublish : Allow user to set PermitRequestIbmPublicPublish +func (options *CreateOfferingOptions) SetPermitRequestIbmPublicPublish(permitRequestIbmPublicPublish bool) *CreateOfferingOptions { + options.PermitRequestIbmPublicPublish = core.BoolPtr(permitRequestIbmPublicPublish) + return options +} + +// SetIbmPublishApproved : Allow user to set IbmPublishApproved +func (options *CreateOfferingOptions) SetIbmPublishApproved(ibmPublishApproved bool) *CreateOfferingOptions { + options.IbmPublishApproved = core.BoolPtr(ibmPublishApproved) + return options +} + +// SetPublicPublishApproved : Allow user to set PublicPublishApproved +func (options *CreateOfferingOptions) SetPublicPublishApproved(publicPublishApproved bool) *CreateOfferingOptions { + options.PublicPublishApproved = core.BoolPtr(publicPublishApproved) + return options +} + +// SetPublicOriginalCrn : Allow user to set PublicOriginalCrn +func (options *CreateOfferingOptions) SetPublicOriginalCrn(publicOriginalCrn string) *CreateOfferingOptions { + options.PublicOriginalCrn = core.StringPtr(publicOriginalCrn) + return options +} + +// SetPublishPublicCrn : Allow user to set PublishPublicCrn +func (options *CreateOfferingOptions) SetPublishPublicCrn(publishPublicCrn string) *CreateOfferingOptions { + options.PublishPublicCrn = core.StringPtr(publishPublicCrn) + return options +} + +// SetPortalApprovalRecord : Allow user to set PortalApprovalRecord +func (options *CreateOfferingOptions) SetPortalApprovalRecord(portalApprovalRecord string) *CreateOfferingOptions { + options.PortalApprovalRecord = core.StringPtr(portalApprovalRecord) + return options +} + +// SetPortalUiURL : Allow user to set PortalUiURL +func (options *CreateOfferingOptions) SetPortalUiURL(portalUiURL string) *CreateOfferingOptions { + options.PortalUiURL = core.StringPtr(portalUiURL) + return options +} + +// SetCatalogID : Allow user to set CatalogID +func (options *CreateOfferingOptions) SetCatalogID(catalogID string) *CreateOfferingOptions { + options.CatalogID = core.StringPtr(catalogID) + return options +} + +// SetCatalogName : Allow user to set CatalogName +func (options *CreateOfferingOptions) SetCatalogName(catalogName string) *CreateOfferingOptions { + options.CatalogName = core.StringPtr(catalogName) + return options +} + +// SetMetadata : Allow user to set Metadata +func (options *CreateOfferingOptions) SetMetadata(metadata interface{}) *CreateOfferingOptions { + options.Metadata = metadata + return options +} + +// SetDisclaimer : Allow user to set Disclaimer +func (options *CreateOfferingOptions) SetDisclaimer(disclaimer string) *CreateOfferingOptions { + options.Disclaimer = core.StringPtr(disclaimer) + return options +} + +// SetHidden : Allow user to set Hidden +func (options *CreateOfferingOptions) SetHidden(hidden bool) *CreateOfferingOptions { + options.Hidden = core.BoolPtr(hidden) + return options +} + +// SetProvider : Allow user to set Provider +func (options *CreateOfferingOptions) SetProvider(provider string) *CreateOfferingOptions { + options.Provider = core.StringPtr(provider) + return options +} + +// SetRepoInfo : Allow user to set RepoInfo +func (options *CreateOfferingOptions) SetRepoInfo(repoInfo *RepoInfo) *CreateOfferingOptions { + options.RepoInfo = repoInfo + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CreateOfferingOptions) SetHeaders(param map[string]string) *CreateOfferingOptions { + options.Headers = param + return options +} + +// CreateOperatorOptions : The CreateOperator options. +type CreateOperatorOptions struct { + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Kube namespaces to deploy Operator(s) to. + Namespaces []string `json:"namespaces,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewCreateOperatorOptions : Instantiate CreateOperatorOptions +func (*CatalogManagementV1) NewCreateOperatorOptions(xAuthRefreshToken string) *CreateOperatorOptions { + return &CreateOperatorOptions{ + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *CreateOperatorOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *CreateOperatorOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *CreateOperatorOptions) SetClusterID(clusterID string) *CreateOperatorOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *CreateOperatorOptions) SetRegion(region string) *CreateOperatorOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespaces : Allow user to set Namespaces +func (options *CreateOperatorOptions) SetNamespaces(namespaces []string) *CreateOperatorOptions { + options.Namespaces = namespaces + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *CreateOperatorOptions) SetVersionLocatorID(versionLocatorID string) *CreateOperatorOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *CreateOperatorOptions) SetHeaders(param map[string]string) *CreateOperatorOptions { + options.Headers = param + return options +} + +// DeleteCatalogOptions : The DeleteCatalog options. +type DeleteCatalogOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeleteCatalogOptions : Instantiate DeleteCatalogOptions +func (*CatalogManagementV1) NewDeleteCatalogOptions(catalogIdentifier string) *DeleteCatalogOptions { + return &DeleteCatalogOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *DeleteCatalogOptions) SetCatalogIdentifier(catalogIdentifier string) *DeleteCatalogOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeleteCatalogOptions) SetHeaders(param map[string]string) *DeleteCatalogOptions { + options.Headers = param + return options +} + +// DeleteLicenseEntitlementOptions : The DeleteLicenseEntitlement options. +type DeleteLicenseEntitlementOptions struct { + // The specific entitlement ID (can be obtained from one of the license entitlement queries). + EntitlementID *string `json:"entitlement_id" validate:"required"` + + // The account ID to query for the entitlement. Default is the account from the user's token. + AccountID *string `json:"account_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeleteLicenseEntitlementOptions : Instantiate DeleteLicenseEntitlementOptions +func (*CatalogManagementV1) NewDeleteLicenseEntitlementOptions(entitlementID string) *DeleteLicenseEntitlementOptions { + return &DeleteLicenseEntitlementOptions{ + EntitlementID: core.StringPtr(entitlementID), + } +} + +// SetEntitlementID : Allow user to set EntitlementID +func (options *DeleteLicenseEntitlementOptions) SetEntitlementID(entitlementID string) *DeleteLicenseEntitlementOptions { + options.EntitlementID = core.StringPtr(entitlementID) + return options +} + +// SetAccountID : Allow user to set AccountID +func (options *DeleteLicenseEntitlementOptions) SetAccountID(accountID string) *DeleteLicenseEntitlementOptions { + options.AccountID = core.StringPtr(accountID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeleteLicenseEntitlementOptions) SetHeaders(param map[string]string) *DeleteLicenseEntitlementOptions { + options.Headers = param + return options +} + +// DeleteOfferingOptions : The DeleteOffering options. +type DeleteOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeleteOfferingOptions : Instantiate DeleteOfferingOptions +func (*CatalogManagementV1) NewDeleteOfferingOptions(catalogIdentifier string, offeringID string) *DeleteOfferingOptions { + return &DeleteOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *DeleteOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *DeleteOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *DeleteOfferingOptions) SetOfferingID(offeringID string) *DeleteOfferingOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeleteOfferingOptions) SetHeaders(param map[string]string) *DeleteOfferingOptions { + options.Headers = param + return options +} + +// DeleteOperatorOptions : The DeleteOperator options. +type DeleteOperatorOptions struct { + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster identification. + ClusterID *string `json:"cluster_id" validate:"required"` + + // Cluster region. + Region *string `json:"region" validate:"required"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeleteOperatorOptions : Instantiate DeleteOperatorOptions +func (*CatalogManagementV1) NewDeleteOperatorOptions(xAuthRefreshToken string, clusterID string, region string, versionLocatorID string) *DeleteOperatorOptions { + return &DeleteOperatorOptions{ + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + ClusterID: core.StringPtr(clusterID), + Region: core.StringPtr(region), + VersionLocatorID: core.StringPtr(versionLocatorID), + } +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *DeleteOperatorOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *DeleteOperatorOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *DeleteOperatorOptions) SetClusterID(clusterID string) *DeleteOperatorOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *DeleteOperatorOptions) SetRegion(region string) *DeleteOperatorOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *DeleteOperatorOptions) SetVersionLocatorID(versionLocatorID string) *DeleteOperatorOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeleteOperatorOptions) SetHeaders(param map[string]string) *DeleteOperatorOptions { + options.Headers = param + return options +} + +// DeleteVersionOptions : The DeleteVersion options. +type DeleteVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeleteVersionOptions : Instantiate DeleteVersionOptions +func (*CatalogManagementV1) NewDeleteVersionOptions(versionLocID string) *DeleteVersionOptions { + return &DeleteVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *DeleteVersionOptions) SetVersionLocID(versionLocID string) *DeleteVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeleteVersionOptions) SetHeaders(param map[string]string) *DeleteVersionOptions { + options.Headers = param + return options +} + +// DeployRequestBodySchematics : Schematics workspace configuration. +type DeployRequestBodySchematics struct { + // Schematics workspace name. + Name *string `json:"name,omitempty"` + + // Schematics workspace description. + Description *string `json:"description,omitempty"` + + // Schematics workspace tags. + Tags []string `json:"tags,omitempty"` + + // Resource group to use when creating the schematics workspace. + ResourceGroupID *string `json:"resource_group_id,omitempty"` +} + + +// UnmarshalDeployRequestBodySchematics unmarshals an instance of DeployRequestBodySchematics from the specified map of raw messages. +func UnmarshalDeployRequestBodySchematics(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(DeployRequestBodySchematics) + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_group_id", &obj.ResourceGroupID) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// DeployRequirementsCheck : Failed deployment requirements. +type DeployRequirementsCheck struct { + // Failed during pre-install. + PreInstall interface{} `json:"pre_install,omitempty"` + + // Failed during install. + Install interface{} `json:"install,omitempty"` +} + + +// UnmarshalDeployRequirementsCheck unmarshals an instance of DeployRequirementsCheck from the specified map of raw messages. +func UnmarshalDeployRequirementsCheck(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(DeployRequirementsCheck) + err = core.UnmarshalPrimitive(m, "pre_install", &obj.PreInstall) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "install", &obj.Install) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Deployment : Deployment for offering. +type Deployment struct { + // unique id. + ID *string `json:"id,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // The programmatic name of this offering. + Name *string `json:"name,omitempty"` + + // Short description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // Long description in the requested language. + LongDescription *string `json:"long_description,omitempty"` + + // open ended metadata information. + Metadata interface{} `json:"metadata,omitempty"` + + // list of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // the date'time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // the date'time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` +} + + +// UnmarshalDeployment unmarshals an instance of Deployment from the specified map of raw messages. +func UnmarshalDeployment(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Deployment) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "label", &obj.Label) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "short_description", &obj.ShortDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "long_description", &obj.LongDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "metadata", &obj.Metadata) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// DeprecateVersionOptions : The DeprecateVersion options. +type DeprecateVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewDeprecateVersionOptions : Instantiate DeprecateVersionOptions +func (*CatalogManagementV1) NewDeprecateVersionOptions(versionLocID string) *DeprecateVersionOptions { + return &DeprecateVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *DeprecateVersionOptions) SetVersionLocID(versionLocID string) *DeprecateVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *DeprecateVersionOptions) SetHeaders(param map[string]string) *DeprecateVersionOptions { + options.Headers = param + return options +} + +// Enterprise : Enterprise account information. +type Enterprise struct { + // Enterprise identification. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Filters for account and catalog filters. + AccountFilters *Filters `json:"account_filters,omitempty"` + + // Map of account group ids to AccountGroup objects. + AccountGroups *EnterpriseAccountGroups `json:"account_groups,omitempty"` +} + + +// UnmarshalEnterprise unmarshals an instance of Enterprise from the specified map of raw messages. +func UnmarshalEnterprise(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Enterprise) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "_rev", &obj.Rev) + if err != nil { + return + } + err = core.UnmarshalModel(m, "account_filters", &obj.AccountFilters, UnmarshalFilters) + if err != nil { + return + } + err = core.UnmarshalModel(m, "account_groups", &obj.AccountGroups, UnmarshalEnterpriseAccountGroups) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// EnterpriseAccountGroups : Map of account group ids to AccountGroup objects. +type EnterpriseAccountGroups struct { + // Filters for an Account Group. + Keys *AccountGroup `json:"keys,omitempty"` +} + + +// UnmarshalEnterpriseAccountGroups unmarshals an instance of EnterpriseAccountGroups from the specified map of raw messages. +func UnmarshalEnterpriseAccountGroups(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(EnterpriseAccountGroups) + err = core.UnmarshalModel(m, "keys", &obj.Keys, UnmarshalAccountGroup) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Feature : Feature information. +type Feature struct { + // Heading. + Title *string `json:"title,omitempty"` + + // Feature description. + Description *string `json:"description,omitempty"` +} + + +// UnmarshalFeature unmarshals an instance of Feature from the specified map of raw messages. +func UnmarshalFeature(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Feature) + err = core.UnmarshalPrimitive(m, "title", &obj.Title) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// FilterTerms : Offering filter terms. +type FilterTerms struct { + // List of values to match against. If include is true, then if the offering has one of the values then the offering is + // included. If include is false, then if the offering has one of the values then the offering is excluded. + FilterTerms []string `json:"filter_terms,omitempty"` +} + + +// UnmarshalFilterTerms unmarshals an instance of FilterTerms from the specified map of raw messages. +func UnmarshalFilterTerms(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(FilterTerms) + err = core.UnmarshalPrimitive(m, "filter_terms", &obj.FilterTerms) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Filters : Filters for account and catalog filters. +type Filters struct { + // -> true - Include all of the public catalog when filtering. Further settings will specifically exclude some + // offerings. false - Exclude all of the public catalog when filtering. Further settings will specifically include some + // offerings. + IncludeAll *bool `json:"include_all,omitempty"` + + // Filter against offering properties. + CategoryFilters map[string]CategoryFilter `json:"category_filters,omitempty"` + + // Filter on offering ID's. There is an include filter and an exclule filter. Both can be set. + IdFilters *IDFilter `json:"id_filters,omitempty"` +} + + +// UnmarshalFilters unmarshals an instance of Filters from the specified map of raw messages. +func UnmarshalFilters(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Filters) + err = core.UnmarshalPrimitive(m, "include_all", &obj.IncludeAll) + if err != nil { + return + } + err = core.UnmarshalModel(m, "category_filters", &obj.CategoryFilters, UnmarshalCategoryFilter) + if err != nil { + return + } + err = core.UnmarshalModel(m, "id_filters", &obj.IdFilters, UnmarshalIDFilter) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// GetCatalogAccountFiltersOptions : The GetCatalogAccountFilters options. +type GetCatalogAccountFiltersOptions struct { + // catalog id. Narrow down filters to the account and just the one catalog. + Catalog *string `json:"catalog,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetCatalogAccountFiltersOptions : Instantiate GetCatalogAccountFiltersOptions +func (*CatalogManagementV1) NewGetCatalogAccountFiltersOptions() *GetCatalogAccountFiltersOptions { + return &GetCatalogAccountFiltersOptions{} +} + +// SetCatalog : Allow user to set Catalog +func (options *GetCatalogAccountFiltersOptions) SetCatalog(catalog string) *GetCatalogAccountFiltersOptions { + options.Catalog = core.StringPtr(catalog) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetCatalogAccountFiltersOptions) SetHeaders(param map[string]string) *GetCatalogAccountFiltersOptions { + options.Headers = param + return options +} + +// GetCatalogAccountOptions : The GetCatalogAccount options. +type GetCatalogAccountOptions struct { + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetCatalogAccountOptions : Instantiate GetCatalogAccountOptions +func (*CatalogManagementV1) NewGetCatalogAccountOptions() *GetCatalogAccountOptions { + return &GetCatalogAccountOptions{} +} + +// SetHeaders : Allow user to set Headers +func (options *GetCatalogAccountOptions) SetHeaders(param map[string]string) *GetCatalogAccountOptions { + options.Headers = param + return options +} + +// GetCatalogOptions : The GetCatalog options. +type GetCatalogOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetCatalogOptions : Instantiate GetCatalogOptions +func (*CatalogManagementV1) NewGetCatalogOptions(catalogIdentifier string) *GetCatalogOptions { + return &GetCatalogOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *GetCatalogOptions) SetCatalogIdentifier(catalogIdentifier string) *GetCatalogOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetCatalogOptions) SetHeaders(param map[string]string) *GetCatalogOptions { + options.Headers = param + return options +} + +// GetClusterOptions : The GetCluster options. +type GetClusterOptions struct { + // ID of the cluster. + ClusterID *string `json:"cluster_id" validate:"required"` + + // Region of the cluster. + Region *string `json:"region" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetClusterOptions : Instantiate GetClusterOptions +func (*CatalogManagementV1) NewGetClusterOptions(clusterID string, region string, xAuthRefreshToken string) *GetClusterOptions { + return &GetClusterOptions{ + ClusterID: core.StringPtr(clusterID), + Region: core.StringPtr(region), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetClusterID : Allow user to set ClusterID +func (options *GetClusterOptions) SetClusterID(clusterID string) *GetClusterOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *GetClusterOptions) SetRegion(region string) *GetClusterOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *GetClusterOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *GetClusterOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetClusterOptions) SetHeaders(param map[string]string) *GetClusterOptions { + options.Headers = param + return options +} + +// GetConsumptionOfferingsOptions : The GetConsumptionOfferings options. +type GetConsumptionOfferingsOptions struct { + // true - Strip down the content of what is returned. For example don't return the readme. Makes the result much + // smaller. Defaults to false. + Digest *bool `json:"digest,omitempty"` + + // catalog id. Narrow search down to just a particular catalog. It will apply the catalog's public filters to the + // public catalog offerings on the result. + Catalog *string `json:"catalog,omitempty"` + + // What should be selected. Default is 'all' which will return both public and private offerings. 'public' returns only + // the public offerings and 'private' returns only the private offerings. + Select *string `json:"select,omitempty"` + + // true - include offerings which have been marked as hidden. The default is false and hidden offerings are not + // returned. + IncludeHidden *bool `json:"includeHidden,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// Constants associated with the GetConsumptionOfferingsOptions.Select property. +// What should be selected. Default is 'all' which will return both public and private offerings. 'public' returns only +// the public offerings and 'private' returns only the private offerings. +const ( + GetConsumptionOfferingsOptions_Select_All = "all" + GetConsumptionOfferingsOptions_Select_Private = "private" + GetConsumptionOfferingsOptions_Select_Public = "public" +) + +// NewGetConsumptionOfferingsOptions : Instantiate GetConsumptionOfferingsOptions +func (*CatalogManagementV1) NewGetConsumptionOfferingsOptions() *GetConsumptionOfferingsOptions { + return &GetConsumptionOfferingsOptions{} +} + +// SetDigest : Allow user to set Digest +func (options *GetConsumptionOfferingsOptions) SetDigest(digest bool) *GetConsumptionOfferingsOptions { + options.Digest = core.BoolPtr(digest) + return options +} + +// SetCatalog : Allow user to set Catalog +func (options *GetConsumptionOfferingsOptions) SetCatalog(catalog string) *GetConsumptionOfferingsOptions { + options.Catalog = core.StringPtr(catalog) + return options +} + +// SetSelect : Allow user to set Select +func (options *GetConsumptionOfferingsOptions) SetSelect(selectVar string) *GetConsumptionOfferingsOptions { + options.Select = core.StringPtr(selectVar) + return options +} + +// SetIncludeHidden : Allow user to set IncludeHidden +func (options *GetConsumptionOfferingsOptions) SetIncludeHidden(includeHidden bool) *GetConsumptionOfferingsOptions { + options.IncludeHidden = core.BoolPtr(includeHidden) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetConsumptionOfferingsOptions) SetHeaders(param map[string]string) *GetConsumptionOfferingsOptions { + options.Headers = param + return options +} + +// GetEnterpriseOptions : The GetEnterprise options. +type GetEnterpriseOptions struct { + // Enterprise identification. + EnterpriseID *string `json:"enterprise_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetEnterpriseOptions : Instantiate GetEnterpriseOptions +func (*CatalogManagementV1) NewGetEnterpriseOptions(enterpriseID string) *GetEnterpriseOptions { + return &GetEnterpriseOptions{ + EnterpriseID: core.StringPtr(enterpriseID), + } +} + +// SetEnterpriseID : Allow user to set EnterpriseID +func (options *GetEnterpriseOptions) SetEnterpriseID(enterpriseID string) *GetEnterpriseOptions { + options.EnterpriseID = core.StringPtr(enterpriseID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetEnterpriseOptions) SetHeaders(param map[string]string) *GetEnterpriseOptions { + options.Headers = param + return options +} + +// GetLicenseEntitlementsOptions : The GetLicenseEntitlements options. +type GetLicenseEntitlementsOptions struct { + // The license product ID. If from PPA (Passport Advantage) this is a specific product Part number, eg. D1YGZLL. + LicenseProductID *string `json:"license_product_id" validate:"required"` + + // The account ID to query for the entitlement. Default is the account from the user's token. + AccountID *string `json:"account_id,omitempty"` + + // The GC ID of the specific offering version. + VersionID *string `json:"version_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetLicenseEntitlementsOptions : Instantiate GetLicenseEntitlementsOptions +func (*CatalogManagementV1) NewGetLicenseEntitlementsOptions(licenseProductID string) *GetLicenseEntitlementsOptions { + return &GetLicenseEntitlementsOptions{ + LicenseProductID: core.StringPtr(licenseProductID), + } +} + +// SetLicenseProductID : Allow user to set LicenseProductID +func (options *GetLicenseEntitlementsOptions) SetLicenseProductID(licenseProductID string) *GetLicenseEntitlementsOptions { + options.LicenseProductID = core.StringPtr(licenseProductID) + return options +} + +// SetAccountID : Allow user to set AccountID +func (options *GetLicenseEntitlementsOptions) SetAccountID(accountID string) *GetLicenseEntitlementsOptions { + options.AccountID = core.StringPtr(accountID) + return options +} + +// SetVersionID : Allow user to set VersionID +func (options *GetLicenseEntitlementsOptions) SetVersionID(versionID string) *GetLicenseEntitlementsOptions { + options.VersionID = core.StringPtr(versionID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetLicenseEntitlementsOptions) SetHeaders(param map[string]string) *GetLicenseEntitlementsOptions { + options.Headers = param + return options +} + +// GetLicenseProvidersOptions : The GetLicenseProviders options. +type GetLicenseProvidersOptions struct { + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetLicenseProvidersOptions : Instantiate GetLicenseProvidersOptions +func (*CatalogManagementV1) NewGetLicenseProvidersOptions() *GetLicenseProvidersOptions { + return &GetLicenseProvidersOptions{} +} + +// SetHeaders : Allow user to set Headers +func (options *GetLicenseProvidersOptions) SetHeaders(param map[string]string) *GetLicenseProvidersOptions { + options.Headers = param + return options +} + +// GetLicensesOptions : The GetLicenses options. +type GetLicensesOptions struct { + // ID of the license provider, ie. retrieved from GET license_providers. + LicenseProviderID *string `json:"license_provider_id" validate:"required"` + + // If not specified the token's account will be used. + AccountID *string `json:"account_id,omitempty"` + + // License name. + Name *string `json:"name,omitempty"` + + // Type of license, if not specified, default is ibm-ppa. + LicenseType *string `json:"license_type,omitempty"` + + // The license product ID. If from PPA (Passport Advantage) this is the product Part number, eg. D1YGZLL. + LicenseProductID *string `json:"license_product_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetLicensesOptions : Instantiate GetLicensesOptions +func (*CatalogManagementV1) NewGetLicensesOptions(licenseProviderID string) *GetLicensesOptions { + return &GetLicensesOptions{ + LicenseProviderID: core.StringPtr(licenseProviderID), + } +} + +// SetLicenseProviderID : Allow user to set LicenseProviderID +func (options *GetLicensesOptions) SetLicenseProviderID(licenseProviderID string) *GetLicensesOptions { + options.LicenseProviderID = core.StringPtr(licenseProviderID) + return options +} + +// SetAccountID : Allow user to set AccountID +func (options *GetLicensesOptions) SetAccountID(accountID string) *GetLicensesOptions { + options.AccountID = core.StringPtr(accountID) + return options +} + +// SetName : Allow user to set Name +func (options *GetLicensesOptions) SetName(name string) *GetLicensesOptions { + options.Name = core.StringPtr(name) + return options +} + +// SetLicenseType : Allow user to set LicenseType +func (options *GetLicensesOptions) SetLicenseType(licenseType string) *GetLicensesOptions { + options.LicenseType = core.StringPtr(licenseType) + return options +} + +// SetLicenseProductID : Allow user to set LicenseProductID +func (options *GetLicensesOptions) SetLicenseProductID(licenseProductID string) *GetLicensesOptions { + options.LicenseProductID = core.StringPtr(licenseProductID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetLicensesOptions) SetHeaders(param map[string]string) *GetLicensesOptions { + options.Headers = param + return options +} + +// GetNamespacesOptions : The GetNamespaces options. +type GetNamespacesOptions struct { + // ID of the cluster. + ClusterID *string `json:"cluster_id" validate:"required"` + + // Cluster region. + Region *string `json:"region" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // number or results to return. + Limit *int64 `json:"limit,omitempty"` + + // number of results to skip before returning values. + Offset *int64 `json:"offset,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetNamespacesOptions : Instantiate GetNamespacesOptions +func (*CatalogManagementV1) NewGetNamespacesOptions(clusterID string, region string, xAuthRefreshToken string) *GetNamespacesOptions { + return &GetNamespacesOptions{ + ClusterID: core.StringPtr(clusterID), + Region: core.StringPtr(region), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetClusterID : Allow user to set ClusterID +func (options *GetNamespacesOptions) SetClusterID(clusterID string) *GetNamespacesOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *GetNamespacesOptions) SetRegion(region string) *GetNamespacesOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *GetNamespacesOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *GetNamespacesOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetLimit : Allow user to set Limit +func (options *GetNamespacesOptions) SetLimit(limit int64) *GetNamespacesOptions { + options.Limit = core.Int64Ptr(limit) + return options +} + +// SetOffset : Allow user to set Offset +func (options *GetNamespacesOptions) SetOffset(offset int64) *GetNamespacesOptions { + options.Offset = core.Int64Ptr(offset) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetNamespacesOptions) SetHeaders(param map[string]string) *GetNamespacesOptions { + options.Headers = param + return options +} + +// GetOfferingOptions : The GetOffering options. +type GetOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetOfferingOptions : Instantiate GetOfferingOptions +func (*CatalogManagementV1) NewGetOfferingOptions(catalogIdentifier string, offeringID string) *GetOfferingOptions { + return &GetOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *GetOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *GetOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *GetOfferingOptions) SetOfferingID(offeringID string) *GetOfferingOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetOfferingOptions) SetHeaders(param map[string]string) *GetOfferingOptions { + options.Headers = param + return options +} + +// GetOverrideValuesOptions : The GetOverrideValues options. +type GetOverrideValuesOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetOverrideValuesOptions : Instantiate GetOverrideValuesOptions +func (*CatalogManagementV1) NewGetOverrideValuesOptions(versionLocID string) *GetOverrideValuesOptions { + return &GetOverrideValuesOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetOverrideValuesOptions) SetVersionLocID(versionLocID string) *GetOverrideValuesOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetOverrideValuesOptions) SetHeaders(param map[string]string) *GetOverrideValuesOptions { + options.Headers = param + return options +} + +// GetPreinstallOptions : The GetPreinstall options. +type GetPreinstallOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // ID of the cluster. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Required if the version's pre-install scope is `namespace`. + Namespace *string `json:"namespace,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetPreinstallOptions : Instantiate GetPreinstallOptions +func (*CatalogManagementV1) NewGetPreinstallOptions(versionLocID string, xAuthRefreshToken string) *GetPreinstallOptions { + return &GetPreinstallOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetPreinstallOptions) SetVersionLocID(versionLocID string) *GetPreinstallOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *GetPreinstallOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *GetPreinstallOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *GetPreinstallOptions) SetClusterID(clusterID string) *GetPreinstallOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *GetPreinstallOptions) SetRegion(region string) *GetPreinstallOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *GetPreinstallOptions) SetNamespace(namespace string) *GetPreinstallOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetPreinstallOptions) SetHeaders(param map[string]string) *GetPreinstallOptions { + options.Headers = param + return options +} + +// GetRepoOptions : The GetRepo options. +type GetRepoOptions struct { + // The type of repo (valid repo types: helm). + Type *string `json:"type" validate:"required"` + + // The URL for the repo's chart zip file (e.g + // https://registry.bluemix.net/helm/ibm-charts/charts/ibm-redis-ha-dev-1.0.0.tgz). + Charturl *string `json:"charturl" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetRepoOptions : Instantiate GetRepoOptions +func (*CatalogManagementV1) NewGetRepoOptions(typeVar string, charturl string) *GetRepoOptions { + return &GetRepoOptions{ + Type: core.StringPtr(typeVar), + Charturl: core.StringPtr(charturl), + } +} + +// SetType : Allow user to set Type +func (options *GetRepoOptions) SetType(typeVar string) *GetRepoOptions { + options.Type = core.StringPtr(typeVar) + return options +} + +// SetCharturl : Allow user to set Charturl +func (options *GetRepoOptions) SetCharturl(charturl string) *GetRepoOptions { + options.Charturl = core.StringPtr(charturl) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetRepoOptions) SetHeaders(param map[string]string) *GetRepoOptions { + options.Headers = param + return options +} + +// GetReposOptions : The GetRepos options. +type GetReposOptions struct { + // The type of repo (valid repo types: helm). + Type *string `json:"type" validate:"required"` + + // The URL for the repo's root (e.g https://kubernetes-charts-incubator.storage.googleapis.com). + Repourl *string `json:"repourl" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetReposOptions : Instantiate GetReposOptions +func (*CatalogManagementV1) NewGetReposOptions(typeVar string, repourl string) *GetReposOptions { + return &GetReposOptions{ + Type: core.StringPtr(typeVar), + Repourl: core.StringPtr(repourl), + } +} + +// SetType : Allow user to set Type +func (options *GetReposOptions) SetType(typeVar string) *GetReposOptions { + options.Type = core.StringPtr(typeVar) + return options +} + +// SetRepourl : Allow user to set Repourl +func (options *GetReposOptions) SetRepourl(repourl string) *GetReposOptions { + options.Repourl = core.StringPtr(repourl) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetReposOptions) SetHeaders(param map[string]string) *GetReposOptions { + options.Headers = param + return options +} + +// GetResourceGroupsOptions : The GetResourceGroups options. +type GetResourceGroupsOptions struct { + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetResourceGroupsOptions : Instantiate GetResourceGroupsOptions +func (*CatalogManagementV1) NewGetResourceGroupsOptions() *GetResourceGroupsOptions { + return &GetResourceGroupsOptions{} +} + +// SetHeaders : Allow user to set Headers +func (options *GetResourceGroupsOptions) SetHeaders(param map[string]string) *GetResourceGroupsOptions { + options.Headers = param + return options +} + +// GetSchematicsWorkspacesOptions : The GetSchematicsWorkspaces options. +type GetSchematicsWorkspacesOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetSchematicsWorkspacesOptions : Instantiate GetSchematicsWorkspacesOptions +func (*CatalogManagementV1) NewGetSchematicsWorkspacesOptions(versionLocID string, xAuthRefreshToken string) *GetSchematicsWorkspacesOptions { + return &GetSchematicsWorkspacesOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetSchematicsWorkspacesOptions) SetVersionLocID(versionLocID string) *GetSchematicsWorkspacesOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *GetSchematicsWorkspacesOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *GetSchematicsWorkspacesOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetSchematicsWorkspacesOptions) SetHeaders(param map[string]string) *GetSchematicsWorkspacesOptions { + options.Headers = param + return options +} + +// GetValidationStatusOptions : The GetValidationStatus options. +type GetValidationStatusOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetValidationStatusOptions : Instantiate GetValidationStatusOptions +func (*CatalogManagementV1) NewGetValidationStatusOptions(versionLocID string, xAuthRefreshToken string) *GetValidationStatusOptions { + return &GetValidationStatusOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetValidationStatusOptions) SetVersionLocID(versionLocID string) *GetValidationStatusOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *GetValidationStatusOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *GetValidationStatusOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetValidationStatusOptions) SetHeaders(param map[string]string) *GetValidationStatusOptions { + options.Headers = param + return options +} + +// GetVersionAboutOptions : The GetVersionAbout options. +type GetVersionAboutOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionAboutOptions : Instantiate GetVersionAboutOptions +func (*CatalogManagementV1) NewGetVersionAboutOptions(versionLocID string) *GetVersionAboutOptions { + return &GetVersionAboutOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionAboutOptions) SetVersionLocID(versionLocID string) *GetVersionAboutOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionAboutOptions) SetHeaders(param map[string]string) *GetVersionAboutOptions { + options.Headers = param + return options +} + +// GetVersionContainerImagesOptions : The GetVersionContainerImages options. +type GetVersionContainerImagesOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionContainerImagesOptions : Instantiate GetVersionContainerImagesOptions +func (*CatalogManagementV1) NewGetVersionContainerImagesOptions(versionLocID string) *GetVersionContainerImagesOptions { + return &GetVersionContainerImagesOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionContainerImagesOptions) SetVersionLocID(versionLocID string) *GetVersionContainerImagesOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionContainerImagesOptions) SetHeaders(param map[string]string) *GetVersionContainerImagesOptions { + options.Headers = param + return options +} + +// GetVersionLicenseOptions : The GetVersionLicense options. +type GetVersionLicenseOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // The ID of the license, which maps to the file name in the 'licenses' directory of this verions tgz file. + LicenseID *string `json:"license_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionLicenseOptions : Instantiate GetVersionLicenseOptions +func (*CatalogManagementV1) NewGetVersionLicenseOptions(versionLocID string, licenseID string) *GetVersionLicenseOptions { + return &GetVersionLicenseOptions{ + VersionLocID: core.StringPtr(versionLocID), + LicenseID: core.StringPtr(licenseID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionLicenseOptions) SetVersionLocID(versionLocID string) *GetVersionLicenseOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetLicenseID : Allow user to set LicenseID +func (options *GetVersionLicenseOptions) SetLicenseID(licenseID string) *GetVersionLicenseOptions { + options.LicenseID = core.StringPtr(licenseID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionLicenseOptions) SetHeaders(param map[string]string) *GetVersionLicenseOptions { + options.Headers = param + return options +} + +// GetVersionOptions : The GetVersion options. +type GetVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionOptions : Instantiate GetVersionOptions +func (*CatalogManagementV1) NewGetVersionOptions(versionLocID string) *GetVersionOptions { + return &GetVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionOptions) SetVersionLocID(versionLocID string) *GetVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionOptions) SetHeaders(param map[string]string) *GetVersionOptions { + options.Headers = param + return options +} + +// GetVersionUpdatesOptions : The GetVersionUpdates options. +type GetVersionUpdatesOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // The id of the cluster where this version was installed. + ClusterID *string `json:"cluster_id,omitempty"` + + // The region of the cluster where this version was installed. + Region *string `json:"region,omitempty"` + + // The resource group id of the cluster where this version was installed. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // The namespace of the cluster where this version was installed. + Namespace *string `json:"namespace,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionUpdatesOptions : Instantiate GetVersionUpdatesOptions +func (*CatalogManagementV1) NewGetVersionUpdatesOptions(versionLocID string) *GetVersionUpdatesOptions { + return &GetVersionUpdatesOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionUpdatesOptions) SetVersionLocID(versionLocID string) *GetVersionUpdatesOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *GetVersionUpdatesOptions) SetClusterID(clusterID string) *GetVersionUpdatesOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *GetVersionUpdatesOptions) SetRegion(region string) *GetVersionUpdatesOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetResourceGroupID : Allow user to set ResourceGroupID +func (options *GetVersionUpdatesOptions) SetResourceGroupID(resourceGroupID string) *GetVersionUpdatesOptions { + options.ResourceGroupID = core.StringPtr(resourceGroupID) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *GetVersionUpdatesOptions) SetNamespace(namespace string) *GetVersionUpdatesOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionUpdatesOptions) SetHeaders(param map[string]string) *GetVersionUpdatesOptions { + options.Headers = param + return options +} + +// GetVersionWorkingCopyOptions : The GetVersionWorkingCopy options. +type GetVersionWorkingCopyOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewGetVersionWorkingCopyOptions : Instantiate GetVersionWorkingCopyOptions +func (*CatalogManagementV1) NewGetVersionWorkingCopyOptions(versionLocID string) *GetVersionWorkingCopyOptions { + return &GetVersionWorkingCopyOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *GetVersionWorkingCopyOptions) SetVersionLocID(versionLocID string) *GetVersionWorkingCopyOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *GetVersionWorkingCopyOptions) SetHeaders(param map[string]string) *GetVersionWorkingCopyOptions { + options.Headers = param + return options +} + +// HelmChart : Helm chart. +type HelmChart struct { + // Chart name. + Name *string `json:"name,omitempty"` + + // Chart description. + Description *string `json:"description,omitempty"` + + // Chart icon. + Icon *string `json:"icon,omitempty"` + + // Chart version. + Version *string `json:"version,omitempty"` + + // Chart app version. + AppVersion *string `json:"appVersion,omitempty"` +} + + +// UnmarshalHelmChart unmarshals an instance of HelmChart from the specified map of raw messages. +func UnmarshalHelmChart(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(HelmChart) + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "icon", &obj.Icon) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version", &obj.Version) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "appVersion", &obj.AppVersion) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// HelmPackage : Helm package. +type HelmPackage struct { + // The name of the requested chart, or the name of a nested chart within the requested chart. + Chart *HelmPackageChart `json:"chart,omitempty"` +} + + +// UnmarshalHelmPackage unmarshals an instance of HelmPackage from the specified map of raw messages. +func UnmarshalHelmPackage(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(HelmPackage) + err = core.UnmarshalModel(m, "chart", &obj.Chart, UnmarshalHelmPackageChart) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// HelmPackageChart : The name of the requested chart, or the name of a nested chart within the requested chart. +type HelmPackageChart struct { + // Helm chart. + ChartYaml *HelmChart `json:"Chart.yaml,omitempty"` + + // Project SHA. + Sha interface{} `json:"sha,omitempty"` + + // Helm chart description. + READMEMd *string `json:"README.md,omitempty"` + + // Values metadata. + ValuesMetadata interface{} `json:"values-metadata,omitempty"` + + // License metadata. + LicenseMetadata interface{} `json:"license-metadata,omitempty"` +} + + +// UnmarshalHelmPackageChart unmarshals an instance of HelmPackageChart from the specified map of raw messages. +func UnmarshalHelmPackageChart(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(HelmPackageChart) + err = core.UnmarshalModel(m, "Chart.yaml", &obj.ChartYaml, UnmarshalHelmChart) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "sha", &obj.Sha) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "README.md", &obj.READMEMd) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "values-metadata", &obj.ValuesMetadata) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license-metadata", &obj.LicenseMetadata) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// HelmRepoList : Helm repository metadata. +type HelmRepoList struct { + // A chart entry in the repo. This response will contain many chart names. + Chart *HelmRepoListChart `json:"chart,omitempty"` +} + + +// UnmarshalHelmRepoList unmarshals an instance of HelmRepoList from the specified map of raw messages. +func UnmarshalHelmRepoList(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(HelmRepoList) + err = core.UnmarshalModel(m, "chart", &obj.Chart, UnmarshalHelmRepoListChart) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// HelmRepoListChart : A chart entry in the repo. This response will contain many chart names. +type HelmRepoListChart struct { + // API version. + ApiVersion *string `json:"api_version,omitempty"` + + // Date and time created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // Description of Helm repo entry. + Description *string `json:"description,omitempty"` + + // Denotes whether repo entry is deprecated. + Deprecated *bool `json:"deprecated,omitempty"` + + // Digest of entry. + Digest *string `json:"digest,omitempty"` + + // Location of repo entry. + Home *string `json:"home,omitempty"` + + // Entry icon. + Icon *string `json:"icon,omitempty"` + + // List of keywords. + Keywords []string `json:"keywords,omitempty"` + + // Emails and names of repo maintainers. + Maintainers []Maintainers `json:"maintainers,omitempty"` + + // Entry name. + Name *string `json:"name,omitempty"` + + // Helm server version. + TillerVersion *string `json:"tiller_version,omitempty"` + + // Array of URLs. + Urls []string `json:"urls,omitempty"` + + // Array of sources. + Sources []string `json:"sources,omitempty"` + + // Entry version. + Version *string `json:"version,omitempty"` + + // Application version. + AppVersion *string `json:"appVersion,omitempty"` +} + + +// UnmarshalHelmRepoListChart unmarshals an instance of HelmRepoListChart from the specified map of raw messages. +func UnmarshalHelmRepoListChart(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(HelmRepoListChart) + err = core.UnmarshalPrimitive(m, "api_version", &obj.ApiVersion) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "deprecated", &obj.Deprecated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "digest", &obj.Digest) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "home", &obj.Home) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "icon", &obj.Icon) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "keywords", &obj.Keywords) + if err != nil { + return + } + err = core.UnmarshalModel(m, "maintainers", &obj.Maintainers, UnmarshalMaintainers) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tiller_version", &obj.TillerVersion) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "urls", &obj.Urls) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "sources", &obj.Sources) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version", &obj.Version) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "appVersion", &obj.AppVersion) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// IDFilter : Filter on offering ID's. There is an include filter and an exclule filter. Both can be set. +type IDFilter struct { + // Offering filter terms. + Include *FilterTerms `json:"include,omitempty"` + + // Offering filter terms. + Exclude *FilterTerms `json:"exclude,omitempty"` +} + + +// UnmarshalIDFilter unmarshals an instance of IDFilter from the specified map of raw messages. +func UnmarshalIDFilter(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(IDFilter) + err = core.UnmarshalModel(m, "include", &obj.Include, UnmarshalFilterTerms) + if err != nil { + return + } + err = core.UnmarshalModel(m, "exclude", &obj.Exclude, UnmarshalFilterTerms) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// IbmPublishVersionOptions : The IbmPublishVersion options. +type IbmPublishVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewIbmPublishVersionOptions : Instantiate IbmPublishVersionOptions +func (*CatalogManagementV1) NewIbmPublishVersionOptions(versionLocID string) *IbmPublishVersionOptions { + return &IbmPublishVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *IbmPublishVersionOptions) SetVersionLocID(versionLocID string) *IbmPublishVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *IbmPublishVersionOptions) SetHeaders(param map[string]string) *IbmPublishVersionOptions { + options.Headers = param + return options +} + +// Image : Image. +type Image struct { + // Image. + Image *string `json:"image,omitempty"` +} + + +// UnmarshalImage unmarshals an instance of Image from the specified map of raw messages. +func UnmarshalImage(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Image) + err = core.UnmarshalPrimitive(m, "image", &obj.Image) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ImageManifest : Image Manifest. +type ImageManifest struct { + // Image manifest description. + Description *string `json:"description,omitempty"` + + // List of images. + Images []Image `json:"images,omitempty"` +} + + +// UnmarshalImageManifest unmarshals an instance of ImageManifest from the specified map of raw messages. +func UnmarshalImageManifest(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ImageManifest) + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalModel(m, "images", &obj.Images, UnmarshalImage) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ImportOfferingOptions : The ImportOffering options. +type ImportOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // URL path to zip location. + Zipurl *string `json:"zipurl" validate:"required"` + + // Tags array. + Tags []string `json:"tags,omitempty"` + + // Target kinds. Current valid values are 'iks', 'roks', 'vcenter', and 'terraform'. + TargetKinds []string `json:"target_kinds,omitempty"` + + // Re-use the specified offeringID during import. + OfferingID *string `json:"offeringID,omitempty"` + + // Add all possible configuration items when creating this version. + IncludeConfig *bool `json:"includeConfig,omitempty"` + + // The type of repository containing this version. Valid values are 'public_git' or 'enterprise_git'. + RepoType *string `json:"repoType,omitempty"` + + // Authentication token used to access the specified zip file. + XAuthToken *string `json:"X-Auth-Token,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewImportOfferingOptions : Instantiate ImportOfferingOptions +func (*CatalogManagementV1) NewImportOfferingOptions(catalogIdentifier string, zipurl string) *ImportOfferingOptions { + return &ImportOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + Zipurl: core.StringPtr(zipurl), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ImportOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *ImportOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetZipurl : Allow user to set Zipurl +func (options *ImportOfferingOptions) SetZipurl(zipurl string) *ImportOfferingOptions { + options.Zipurl = core.StringPtr(zipurl) + return options +} + +// SetTags : Allow user to set Tags +func (options *ImportOfferingOptions) SetTags(tags []string) *ImportOfferingOptions { + options.Tags = tags + return options +} + +// SetTargetKinds : Allow user to set TargetKinds +func (options *ImportOfferingOptions) SetTargetKinds(targetKinds []string) *ImportOfferingOptions { + options.TargetKinds = targetKinds + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *ImportOfferingOptions) SetOfferingID(offeringID string) *ImportOfferingOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetIncludeConfig : Allow user to set IncludeConfig +func (options *ImportOfferingOptions) SetIncludeConfig(includeConfig bool) *ImportOfferingOptions { + options.IncludeConfig = core.BoolPtr(includeConfig) + return options +} + +// SetRepoType : Allow user to set RepoType +func (options *ImportOfferingOptions) SetRepoType(repoType string) *ImportOfferingOptions { + options.RepoType = core.StringPtr(repoType) + return options +} + +// SetXAuthToken : Allow user to set XAuthToken +func (options *ImportOfferingOptions) SetXAuthToken(xAuthToken string) *ImportOfferingOptions { + options.XAuthToken = core.StringPtr(xAuthToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ImportOfferingOptions) SetHeaders(param map[string]string) *ImportOfferingOptions { + options.Headers = param + return options +} + +// ImportOfferingVersionOptions : The ImportOfferingVersion options. +type ImportOfferingVersionOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // URL path to zip location. + Zipurl *string `json:"zipurl" validate:"required"` + + // Tags array. + Tags []string `json:"tags,omitempty"` + + // Target kinds. Current valid values are 'iks', 'roks', 'vcenter', and 'terraform'. + TargetKinds []string `json:"target_kinds,omitempty"` + + // The semver value for this new version, if not found in the zip url package content. + TargetVersion *string `json:"targetVersion,omitempty"` + + // Add all possible configuration values to this version when importing. + IncludeConfig *bool `json:"includeConfig,omitempty"` + + // The type of repository containing this version. Valid values are 'public_git' or 'enterprise_git'. + RepoType *string `json:"repoType,omitempty"` + + // Authentication token used to access the specified zip file. + XAuthToken *string `json:"X-Auth-Token,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewImportOfferingVersionOptions : Instantiate ImportOfferingVersionOptions +func (*CatalogManagementV1) NewImportOfferingVersionOptions(catalogIdentifier string, offeringID string, zipurl string) *ImportOfferingVersionOptions { + return &ImportOfferingVersionOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + Zipurl: core.StringPtr(zipurl), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ImportOfferingVersionOptions) SetCatalogIdentifier(catalogIdentifier string) *ImportOfferingVersionOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *ImportOfferingVersionOptions) SetOfferingID(offeringID string) *ImportOfferingVersionOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetZipurl : Allow user to set Zipurl +func (options *ImportOfferingVersionOptions) SetZipurl(zipurl string) *ImportOfferingVersionOptions { + options.Zipurl = core.StringPtr(zipurl) + return options +} + +// SetTags : Allow user to set Tags +func (options *ImportOfferingVersionOptions) SetTags(tags []string) *ImportOfferingVersionOptions { + options.Tags = tags + return options +} + +// SetTargetKinds : Allow user to set TargetKinds +func (options *ImportOfferingVersionOptions) SetTargetKinds(targetKinds []string) *ImportOfferingVersionOptions { + options.TargetKinds = targetKinds + return options +} + +// SetTargetVersion : Allow user to set TargetVersion +func (options *ImportOfferingVersionOptions) SetTargetVersion(targetVersion string) *ImportOfferingVersionOptions { + options.TargetVersion = core.StringPtr(targetVersion) + return options +} + +// SetIncludeConfig : Allow user to set IncludeConfig +func (options *ImportOfferingVersionOptions) SetIncludeConfig(includeConfig bool) *ImportOfferingVersionOptions { + options.IncludeConfig = core.BoolPtr(includeConfig) + return options +} + +// SetRepoType : Allow user to set RepoType +func (options *ImportOfferingVersionOptions) SetRepoType(repoType string) *ImportOfferingVersionOptions { + options.RepoType = core.StringPtr(repoType) + return options +} + +// SetXAuthToken : Allow user to set XAuthToken +func (options *ImportOfferingVersionOptions) SetXAuthToken(xAuthToken string) *ImportOfferingVersionOptions { + options.XAuthToken = core.StringPtr(xAuthToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ImportOfferingVersionOptions) SetHeaders(param map[string]string) *ImportOfferingVersionOptions { + options.Headers = param + return options +} + +// InstallStatus : Installation status. +type InstallStatus struct { + // Installation status metadata. + Metadata *InstallStatusMetadata `json:"metadata,omitempty"` + + // Release information. + Release *InstallStatusRelease `json:"release,omitempty"` + + // Content management information. + ContentMgmt *InstallStatusContentMgmt `json:"content_mgmt,omitempty"` +} + + +// UnmarshalInstallStatus unmarshals an instance of InstallStatus from the specified map of raw messages. +func UnmarshalInstallStatus(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(InstallStatus) + err = core.UnmarshalModel(m, "metadata", &obj.Metadata, UnmarshalInstallStatusMetadata) + if err != nil { + return + } + err = core.UnmarshalModel(m, "release", &obj.Release, UnmarshalInstallStatusRelease) + if err != nil { + return + } + err = core.UnmarshalModel(m, "content_mgmt", &obj.ContentMgmt, UnmarshalInstallStatusContentMgmt) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// InstallStatusContentMgmt : Content management information. +type InstallStatusContentMgmt struct { + // Pods. + Pods []interface{} `json:"pods,omitempty"` + + // Errors. + Errors []interface{} `json:"errors,omitempty"` +} + + +// UnmarshalInstallStatusContentMgmt unmarshals an instance of InstallStatusContentMgmt from the specified map of raw messages. +func UnmarshalInstallStatusContentMgmt(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(InstallStatusContentMgmt) + err = core.UnmarshalPrimitive(m, "pods", &obj.Pods) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "errors", &obj.Errors) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// InstallStatusMetadata : Installation status metadata. +type InstallStatusMetadata struct { + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Cluster namespace. + Namespace *string `json:"namespace,omitempty"` + + // Workspace ID. + WorkspaceID *string `json:"workspace_id,omitempty"` + + // Workspace name. + WorkspaceName *string `json:"workspace_name,omitempty"` +} + + +// UnmarshalInstallStatusMetadata unmarshals an instance of InstallStatusMetadata from the specified map of raw messages. +func UnmarshalInstallStatusMetadata(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(InstallStatusMetadata) + err = core.UnmarshalPrimitive(m, "cluster_id", &obj.ClusterID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "region", &obj.Region) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "namespace", &obj.Namespace) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "workspace_id", &obj.WorkspaceID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "workspace_name", &obj.WorkspaceName) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// InstallStatusRelease : Release information. +type InstallStatusRelease struct { + // Kube deployments. + Deployments []interface{} `json:"deployments,omitempty"` + + // Kube replica sets. + Replicasets []interface{} `json:"replicasets,omitempty"` + + // Kube stateful sets. + Statefulsets []interface{} `json:"statefulsets,omitempty"` + + // Kube pods. + Pods []interface{} `json:"pods,omitempty"` + + // Kube errors. + Errors []interface{} `json:"errors,omitempty"` +} + + +// UnmarshalInstallStatusRelease unmarshals an instance of InstallStatusRelease from the specified map of raw messages. +func UnmarshalInstallStatusRelease(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(InstallStatusRelease) + err = core.UnmarshalPrimitive(m, "deployments", &obj.Deployments) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "replicasets", &obj.Replicasets) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "statefulsets", &obj.Statefulsets) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "pods", &obj.Pods) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "errors", &obj.Errors) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// InstallVersionOptions : The InstallVersion options. +type InstallVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Kube namespace. + Namespace *string `json:"namespace,omitempty"` + + // Object containing Helm chart override values. + OverrideValues interface{} `json:"override_values,omitempty"` + + // Entitlement API Key for this offering. + EntitlementApikey *string `json:"entitlement_apikey,omitempty"` + + // Schematics workspace configuration. + Schematics *DeployRequestBodySchematics `json:"schematics,omitempty"` + + // Script. + Script *string `json:"script,omitempty"` + + // Script ID. + ScriptID *string `json:"script_id,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id,omitempty"` + + // VCenter ID. + VcenterID *string `json:"vcenter_id,omitempty"` + + // VCenter Password. + VcenterPassword *string `json:"vcenter_password,omitempty"` + + // VCenter Location. + VcenterLocation *string `json:"vcenter_location,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewInstallVersionOptions : Instantiate InstallVersionOptions +func (*CatalogManagementV1) NewInstallVersionOptions(versionLocID string, xAuthRefreshToken string) *InstallVersionOptions { + return &InstallVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *InstallVersionOptions) SetVersionLocID(versionLocID string) *InstallVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *InstallVersionOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *InstallVersionOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *InstallVersionOptions) SetClusterID(clusterID string) *InstallVersionOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *InstallVersionOptions) SetRegion(region string) *InstallVersionOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *InstallVersionOptions) SetNamespace(namespace string) *InstallVersionOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetOverrideValues : Allow user to set OverrideValues +func (options *InstallVersionOptions) SetOverrideValues(overrideValues interface{}) *InstallVersionOptions { + options.OverrideValues = overrideValues + return options +} + +// SetEntitlementApikey : Allow user to set EntitlementApikey +func (options *InstallVersionOptions) SetEntitlementApikey(entitlementApikey string) *InstallVersionOptions { + options.EntitlementApikey = core.StringPtr(entitlementApikey) + return options +} + +// SetSchematics : Allow user to set Schematics +func (options *InstallVersionOptions) SetSchematics(schematics *DeployRequestBodySchematics) *InstallVersionOptions { + options.Schematics = schematics + return options +} + +// SetScript : Allow user to set Script +func (options *InstallVersionOptions) SetScript(script string) *InstallVersionOptions { + options.Script = core.StringPtr(script) + return options +} + +// SetScriptID : Allow user to set ScriptID +func (options *InstallVersionOptions) SetScriptID(scriptID string) *InstallVersionOptions { + options.ScriptID = core.StringPtr(scriptID) + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *InstallVersionOptions) SetVersionLocatorID(versionLocatorID string) *InstallVersionOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetVcenterID : Allow user to set VcenterID +func (options *InstallVersionOptions) SetVcenterID(vcenterID string) *InstallVersionOptions { + options.VcenterID = core.StringPtr(vcenterID) + return options +} + +// SetVcenterPassword : Allow user to set VcenterPassword +func (options *InstallVersionOptions) SetVcenterPassword(vcenterPassword string) *InstallVersionOptions { + options.VcenterPassword = core.StringPtr(vcenterPassword) + return options +} + +// SetVcenterLocation : Allow user to set VcenterLocation +func (options *InstallVersionOptions) SetVcenterLocation(vcenterLocation string) *InstallVersionOptions { + options.VcenterLocation = core.StringPtr(vcenterLocation) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *InstallVersionOptions) SetHeaders(param map[string]string) *InstallVersionOptions { + options.Headers = param + return options +} + +// Kind : Offering kind. +type Kind struct { + // Unique ID. + ID *string `json:"id,omitempty"` + + // content kind, e.g., helm, vm image. + FormatKind *string `json:"format_kind,omitempty"` + + // target cloud to install, e.g., iks, open_shift_iks. + TargetKind *string `json:"target_kind,omitempty"` + + // Open ended metadata information. + Metadata interface{} `json:"metadata,omitempty"` + + // Installation instruction. + InstallDescription *string `json:"install_description,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // List of features associated with this offering. + AdditionalFeatures []Feature `json:"additional_features,omitempty"` + + // The date and time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date and time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // list of versions. + Versions []Version `json:"versions,omitempty"` + + // list of plans. + Plans []Plan `json:"plans,omitempty"` +} + + +// UnmarshalKind unmarshals an instance of Kind from the specified map of raw messages. +func UnmarshalKind(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Kind) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "format_kind", &obj.FormatKind) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "target_kind", &obj.TargetKind) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "metadata", &obj.Metadata) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "install_description", &obj.InstallDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalModel(m, "additional_features", &obj.AdditionalFeatures, UnmarshalFeature) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + err = core.UnmarshalModel(m, "versions", &obj.Versions, UnmarshalVersion) + if err != nil { + return + } + err = core.UnmarshalModel(m, "plans", &obj.Plans, UnmarshalPlan) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// License : BSS license. +type License struct { + // License ID. + ID *string `json:"id,omitempty"` + + // license name. + Name *string `json:"name,omitempty"` + + // type of license e.g., Apache xxx. + Type *string `json:"type,omitempty"` + + // URL for the license text. + URL *string `json:"url,omitempty"` + + // License description. + Description *string `json:"description,omitempty"` +} + + +// UnmarshalLicense unmarshals an instance of License from the specified map of raw messages. +func UnmarshalLicense(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(License) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "url", &obj.URL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseEntitlement : License entitlement. +type LicenseEntitlement struct { + // Entitlement name. + Name *string `json:"name,omitempty"` + + // Entitlement ID. + ID *string `json:"id,omitempty"` + + // Entitlement CRN. + Crn *string `json:"crn,omitempty"` + + // URL for the BSS entitlement, e.g. /v1/licensing/entitlements/:id. + URL *string `json:"url,omitempty"` + + // Entitlement offering type. + OfferingType *string `json:"offering_type,omitempty"` + + // State of the BSS entitlement, e.g. 'active' or if it's been deleted, 'removed'. + State *string `json:"state,omitempty"` + + // Entitlement is good from this starting date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveFrom *string `json:"effective_from,omitempty"` + + // Entitlement is good until this ending date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveUntil *string `json:"effective_until,omitempty"` + + // Account ID where this entitlement is bound to. + AccountID *string `json:"account_id,omitempty"` + + // Account ID of owner. + OwnerID *string `json:"owner_id,omitempty"` + + // GC ID of the specific offering version. + VersionID *string `json:"version_id,omitempty"` + + // Marketplace offering ID for this license entitlement. + LicenseOfferingID *string `json:"license_offering_id,omitempty"` + + // Specific license entitlement ID from the license provider, eg. D1W3R4. + LicenseID *string `json:"license_id,omitempty"` + + // IBM ID of the owner of this license entitlement. + LicenseOwnerID *string `json:"license_owner_id,omitempty"` + + // Type of license entitlement, e.g. ibm-ppa. + LicenseType *string `json:"license_type,omitempty"` + + // ID of the license provider. + LicenseProviderID *string `json:"license_provider_id,omitempty"` + + // URL for the BSS license provider, e.g. /v1/licensing/license_providers/:license_provider_id. + LicenseProviderURL *string `json:"license_provider_url,omitempty"` + + // Specific license entitlement ID from the license provider, eg. D1W3R4. + LicenseProductID *string `json:"license_product_id,omitempty"` + + // Location of the registry images, eg. cp/cp4d. + NamespaceRepository *string `json:"namespace_repository,omitempty"` + + // API key for access to the license entitlement. + Apikey *string `json:"apikey,omitempty"` + + // IBM ID. + CreateBy *string `json:"create_by,omitempty"` + + // IBM ID. + UpdateBy *string `json:"update_by,omitempty"` + + // Creation date, eg. '2019-07-17T21:21:47.6794935Z'. + CreateAt *string `json:"create_at,omitempty"` + + // Date last updated, eg. '2019-07-17T21:21:47.6794935Z'. + UpdatedAt *string `json:"updated_at,omitempty"` + + // Entitlement history. + History []LicenseEntitlementHistoryItem `json:"history,omitempty"` + + // Array of license offering references. + OfferingList []LicenseOfferingReference `json:"offering_list,omitempty"` +} + + +// UnmarshalLicenseEntitlement unmarshals an instance of LicenseEntitlement from the specified map of raw messages. +func UnmarshalLicenseEntitlement(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseEntitlement) + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "url", &obj.URL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_type", &obj.OfferingType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "state", &obj.State) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "effective_from", &obj.EffectiveFrom) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "effective_until", &obj.EffectiveUntil) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "account_id", &obj.AccountID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "owner_id", &obj.OwnerID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version_id", &obj.VersionID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_offering_id", &obj.LicenseOfferingID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_id", &obj.LicenseID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_owner_id", &obj.LicenseOwnerID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_type", &obj.LicenseType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_provider_id", &obj.LicenseProviderID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_provider_url", &obj.LicenseProviderURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_product_id", &obj.LicenseProductID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "namespace_repository", &obj.NamespaceRepository) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "apikey", &obj.Apikey) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "create_by", &obj.CreateBy) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "update_by", &obj.UpdateBy) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "create_at", &obj.CreateAt) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated_at", &obj.UpdatedAt) + if err != nil { + return + } + err = core.UnmarshalModel(m, "history", &obj.History, UnmarshalLicenseEntitlementHistoryItem) + if err != nil { + return + } + err = core.UnmarshalModel(m, "offering_list", &obj.OfferingList, UnmarshalLicenseOfferingReference) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseEntitlementHistoryItem : LicenseEntitlementHistoryItem struct +type LicenseEntitlementHistoryItem struct { + // Eg. create. + Action *string `json:"action,omitempty"` + + // Eg. IBM ID of user. + User *string `json:"user,omitempty"` + + // Date of action, eg. '2019-07-17T21:21:47.6794935Z'. + Date *string `json:"date,omitempty"` +} + + +// UnmarshalLicenseEntitlementHistoryItem unmarshals an instance of LicenseEntitlementHistoryItem from the specified map of raw messages. +func UnmarshalLicenseEntitlementHistoryItem(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseEntitlementHistoryItem) + err = core.UnmarshalPrimitive(m, "action", &obj.Action) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "user", &obj.User) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "date", &obj.Date) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseEntitlements : Paginated list of license entitlements. +type LicenseEntitlements struct { + // Total number of results. + TotalResults *int64 `json:"total_results,omitempty"` + + // Total number of pages. + TotalPages *int64 `json:"total_pages,omitempty"` + + // Previous URL. + PrevURL *string `json:"prev_url,omitempty"` + + // Next URL. + NextURL *string `json:"next_url,omitempty"` + + // Resulting Entitlement objects. + Resources []LicenseEntitlement `json:"resources,omitempty"` +} + + +// UnmarshalLicenseEntitlements unmarshals an instance of LicenseEntitlements from the specified map of raw messages. +func UnmarshalLicenseEntitlements(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseEntitlements) + err = core.UnmarshalPrimitive(m, "total_results", &obj.TotalResults) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_pages", &obj.TotalPages) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev_url", &obj.PrevURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next_url", &obj.NextURL) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalLicenseEntitlement) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseObject : License information. +type LicenseObject struct { + // License name. + Name *string `json:"name,omitempty"` + + // Type of offering. + OfferingType *string `json:"offering_type,omitempty"` + + // Number of seats allowed for license. + SeatsAllowed *string `json:"seats_allowed,omitempty"` + + // Number of seats used for license. + SeatsUsed *string `json:"seats_used,omitempty"` + + // ID of license owner. + OwnerID *string `json:"owner_id,omitempty"` + + // Marketplace offering ID for this license. + LicenseOfferingID *string `json:"license_offering_id,omitempty"` + + // specific license entitlement ID from the license provider, eg. D1W3R4. + LicenseID *string `json:"license_id,omitempty"` + + // IBM ID of the owner of this license entitlement. + LicenseOwnerID *string `json:"license_owner_id,omitempty"` + + // type of license entitlement, e.g. ibm-ppa. + LicenseType *string `json:"license_type,omitempty"` + + // ID of the license provider. + LicenseProviderID *string `json:"license_provider_id,omitempty"` + + // specific license entitlement ID from the license provider, eg. D1W3R4. + LicenseProductID *string `json:"license_product_id,omitempty"` + + // URL for the BSS license provider, e.g. /v1/licensing/license_providers/:license_provider_id. + LicenseProviderURL *string `json:"license_provider_url,omitempty"` + + // license is good from this starting date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveFrom *string `json:"effective_from,omitempty"` + + // license is good until this ending date. eg. '2019-07-17T21:21:47.6794935Z'. + EffectiveUntil *string `json:"effective_until,omitempty"` + + // If true, this will allow use of this license by all IBMers. + Internal *bool `json:"internal,omitempty"` + + // Array of license offering references. + OfferingList []LicenseOfferingReference `json:"offering_list,omitempty"` +} + + +// UnmarshalLicenseObject unmarshals an instance of LicenseObject from the specified map of raw messages. +func UnmarshalLicenseObject(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseObject) + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_type", &obj.OfferingType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "seats_allowed", &obj.SeatsAllowed) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "seats_used", &obj.SeatsUsed) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "owner_id", &obj.OwnerID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_offering_id", &obj.LicenseOfferingID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_id", &obj.LicenseID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_owner_id", &obj.LicenseOwnerID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_type", &obj.LicenseType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_provider_id", &obj.LicenseProviderID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_product_id", &obj.LicenseProductID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "license_provider_url", &obj.LicenseProviderURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "effective_from", &obj.EffectiveFrom) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "effective_until", &obj.EffectiveUntil) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "internal", &obj.Internal) + if err != nil { + return + } + err = core.UnmarshalModel(m, "offering_list", &obj.OfferingList, UnmarshalLicenseOfferingReference) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseOfferingReference : License offering reference. +type LicenseOfferingReference struct { + // Offering ID. + ID *string `json:"id,omitempty"` + + // Offering name. + Name *string `json:"name,omitempty"` + + // Offering label'. + Label *string `json:"label,omitempty"` + + // URL to offering icon. + OfferingIconURL *string `json:"offering_icon_url,omitempty"` + + // Account ID associated with offering. + AccountID *string `json:"account_id,omitempty"` + + // Catalog ID associated with offering. + CatalogID *string `json:"catalog_id,omitempty"` +} + + +// UnmarshalLicenseOfferingReference unmarshals an instance of LicenseOfferingReference from the specified map of raw messages. +func UnmarshalLicenseOfferingReference(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseOfferingReference) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "label", &obj.Label) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_icon_url", &obj.OfferingIconURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "account_id", &obj.AccountID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_id", &obj.CatalogID) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseProvider : BSS License provider. +type LicenseProvider struct { + // Provider name, eg. IBM Passport Advantage. + Name *string `json:"name,omitempty"` + + // Short description of license provider. + ShortDescription *string `json:"short_description,omitempty"` + + // Provider ID. + ID *string `json:"id,omitempty"` + + // Type of license entitlement, e.g. ibm-ppa. + LicenceType *string `json:"licence_type,omitempty"` + + // Type of offering. + OfferingType *string `json:"offering_type,omitempty"` + + // URL of the license provider for where to create/get a license, e.g. + // https://www.ibm.com/software/passportadvantage/aboutpassport.html. + CreateURL *string `json:"create_url,omitempty"` + + // URL of the license provider for additional info, e.g. https://www.ibm.com/software/passportadvantage. + InfoURL *string `json:"info_url,omitempty"` + + // URL for the BSS license provider, e.g. /v1/licensing/license_providers/:id. + URL *string `json:"url,omitempty"` + + // Provider CRN. + Crn *string `json:"crn,omitempty"` + + // State of license provider. + State *string `json:"state,omitempty"` +} + + +// UnmarshalLicenseProvider unmarshals an instance of LicenseProvider from the specified map of raw messages. +func UnmarshalLicenseProvider(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseProvider) + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "short_description", &obj.ShortDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "licence_type", &obj.LicenceType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_type", &obj.OfferingType) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "create_url", &obj.CreateURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "info_url", &obj.InfoURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "url", &obj.URL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "state", &obj.State) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// LicenseProviders : Paginated list of license providers. +type LicenseProviders struct { + // Total number of results. + TotalResults *int64 `json:"total_results,omitempty"` + + // Total number of pages. + TotalPages *int64 `json:"total_pages,omitempty"` + + // Previous URL. + PrevURL *string `json:"prev_url,omitempty"` + + // Next URL. + NextURL *string `json:"next_url,omitempty"` + + // Resulting License Provider objects. + Resources []LicenseProvider `json:"resources,omitempty"` +} + + +// UnmarshalLicenseProviders unmarshals an instance of LicenseProviders from the specified map of raw messages. +func UnmarshalLicenseProviders(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(LicenseProviders) + err = core.UnmarshalPrimitive(m, "total_results", &obj.TotalResults) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_pages", &obj.TotalPages) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev_url", &obj.PrevURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next_url", &obj.NextURL) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalLicenseProvider) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Licenses : Paginated list of licenses. +type Licenses struct { + // Total number of results. + TotalResults *int64 `json:"total_results,omitempty"` + + // Total number of pages. + TotalPages *int64 `json:"total_pages,omitempty"` + + // Previous URL. + PrevURL *string `json:"prev_url,omitempty"` + + // Next URL. + NextURL *string `json:"next_url,omitempty"` + + // Resulting License objects. + Resources []LicenseObject `json:"resources,omitempty"` +} + + +// UnmarshalLicenses unmarshals an instance of Licenses from the specified map of raw messages. +func UnmarshalLicenses(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Licenses) + err = core.UnmarshalPrimitive(m, "total_results", &obj.TotalResults) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_pages", &obj.TotalPages) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev_url", &obj.PrevURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next_url", &obj.NextURL) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalLicenseObject) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ListCatalogsOptions : The ListCatalogs options. +type ListCatalogsOptions struct { + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListCatalogsOptions : Instantiate ListCatalogsOptions +func (*CatalogManagementV1) NewListCatalogsOptions() *ListCatalogsOptions { + return &ListCatalogsOptions{} +} + +// SetHeaders : Allow user to set Headers +func (options *ListCatalogsOptions) SetHeaders(param map[string]string) *ListCatalogsOptions { + options.Headers = param + return options +} + +// ListClustersOptions : The ListClusters options. +type ListClustersOptions struct { + // number or results to return. + Limit *int64 `json:"limit,omitempty"` + + // number of results to skip before returning values. + Offset *int64 `json:"offset,omitempty"` + + // Kubernetes or OpenShift. Default is kubernetes. + Type *string `json:"type,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListClustersOptions : Instantiate ListClustersOptions +func (*CatalogManagementV1) NewListClustersOptions() *ListClustersOptions { + return &ListClustersOptions{} +} + +// SetLimit : Allow user to set Limit +func (options *ListClustersOptions) SetLimit(limit int64) *ListClustersOptions { + options.Limit = core.Int64Ptr(limit) + return options +} + +// SetOffset : Allow user to set Offset +func (options *ListClustersOptions) SetOffset(offset int64) *ListClustersOptions { + options.Offset = core.Int64Ptr(offset) + return options +} + +// SetType : Allow user to set Type +func (options *ListClustersOptions) SetType(typeVar string) *ListClustersOptions { + options.Type = core.StringPtr(typeVar) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ListClustersOptions) SetHeaders(param map[string]string) *ListClustersOptions { + options.Headers = param + return options +} + +// ListLicenseEntitlementsOptions : The ListLicenseEntitlements options. +type ListLicenseEntitlementsOptions struct { + // The account ID to query for the entitlement. Default is the account from the user's token. + AccountID *string `json:"account_id,omitempty"` + + // The license product ID. If from PPA (Passport Advantage) this is the product Part number(s) which can be one or more + // IDs, eg. D1YGZLL,5737L09. + LicenseProductID *string `json:"license_product_id,omitempty"` + + // The GC ID of the specific offering version. + VersionID *string `json:"version_id,omitempty"` + + // The state of the license entitlement. eg. usually 'active', or if it's been deleted will show as 'removed'. + State *string `json:"state,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListLicenseEntitlementsOptions : Instantiate ListLicenseEntitlementsOptions +func (*CatalogManagementV1) NewListLicenseEntitlementsOptions() *ListLicenseEntitlementsOptions { + return &ListLicenseEntitlementsOptions{} +} + +// SetAccountID : Allow user to set AccountID +func (options *ListLicenseEntitlementsOptions) SetAccountID(accountID string) *ListLicenseEntitlementsOptions { + options.AccountID = core.StringPtr(accountID) + return options +} + +// SetLicenseProductID : Allow user to set LicenseProductID +func (options *ListLicenseEntitlementsOptions) SetLicenseProductID(licenseProductID string) *ListLicenseEntitlementsOptions { + options.LicenseProductID = core.StringPtr(licenseProductID) + return options +} + +// SetVersionID : Allow user to set VersionID +func (options *ListLicenseEntitlementsOptions) SetVersionID(versionID string) *ListLicenseEntitlementsOptions { + options.VersionID = core.StringPtr(versionID) + return options +} + +// SetState : Allow user to set State +func (options *ListLicenseEntitlementsOptions) SetState(state string) *ListLicenseEntitlementsOptions { + options.State = core.StringPtr(state) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ListLicenseEntitlementsOptions) SetHeaders(param map[string]string) *ListLicenseEntitlementsOptions { + options.Headers = param + return options +} + +// ListOfferingsOptions : The ListOfferings options. +type ListOfferingsOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // true - Strip down the content of what is returned. For example don't return the readme. Makes the result much + // smaller. Defaults to false. + Digest *bool `json:"digest,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListOfferingsOptions : Instantiate ListOfferingsOptions +func (*CatalogManagementV1) NewListOfferingsOptions(catalogIdentifier string) *ListOfferingsOptions { + return &ListOfferingsOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ListOfferingsOptions) SetCatalogIdentifier(catalogIdentifier string) *ListOfferingsOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetDigest : Allow user to set Digest +func (options *ListOfferingsOptions) SetDigest(digest bool) *ListOfferingsOptions { + options.Digest = core.BoolPtr(digest) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ListOfferingsOptions) SetHeaders(param map[string]string) *ListOfferingsOptions { + options.Headers = param + return options +} + +// ListOperatorsOptions : The ListOperators options. +type ListOperatorsOptions struct { + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster identification. + ClusterID *string `json:"cluster_id" validate:"required"` + + // Cluster region. + Region *string `json:"region" validate:"required"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListOperatorsOptions : Instantiate ListOperatorsOptions +func (*CatalogManagementV1) NewListOperatorsOptions(xAuthRefreshToken string, clusterID string, region string, versionLocatorID string) *ListOperatorsOptions { + return &ListOperatorsOptions{ + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + ClusterID: core.StringPtr(clusterID), + Region: core.StringPtr(region), + VersionLocatorID: core.StringPtr(versionLocatorID), + } +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *ListOperatorsOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *ListOperatorsOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *ListOperatorsOptions) SetClusterID(clusterID string) *ListOperatorsOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *ListOperatorsOptions) SetRegion(region string) *ListOperatorsOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *ListOperatorsOptions) SetVersionLocatorID(versionLocatorID string) *ListOperatorsOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ListOperatorsOptions) SetHeaders(param map[string]string) *ListOperatorsOptions { + options.Headers = param + return options +} + +// ListVersionsOptions : The ListVersions options. +type ListVersionsOptions struct { + // query, for now only "q=entitlement_key:" is supported. + Q *string `json:"q" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewListVersionsOptions : Instantiate ListVersionsOptions +func (*CatalogManagementV1) NewListVersionsOptions(q string) *ListVersionsOptions { + return &ListVersionsOptions{ + Q: core.StringPtr(q), + } +} + +// SetQ : Allow user to set Q +func (options *ListVersionsOptions) SetQ(q string) *ListVersionsOptions { + options.Q = core.StringPtr(q) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ListVersionsOptions) SetHeaders(param map[string]string) *ListVersionsOptions { + options.Headers = param + return options +} + +// Maintainers : Repo maintainers. +type Maintainers struct { + // Maintainer email address. + Email *string `json:"email,omitempty"` + + // Name of maintainer. + Name *string `json:"name,omitempty"` +} + + +// UnmarshalMaintainers unmarshals an instance of Maintainers from the specified map of raw messages. +func UnmarshalMaintainers(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Maintainers) + err = core.UnmarshalPrimitive(m, "email", &obj.Email) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// NamespaceSearchResult : Paginated list of namespace search results. +type NamespaceSearchResult struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting objects. + Resources []string `json:"resources,omitempty"` +} + + +// UnmarshalNamespaceSearchResult unmarshals an instance of NamespaceSearchResult from the specified map of raw messages. +func UnmarshalNamespaceSearchResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(NamespaceSearchResult) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resources", &obj.Resources) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Offering : Offering information. +type Offering struct { + // unique id. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // The url for this specific offering. + URL *string `json:"url,omitempty"` + + // The crn for this specific offering. + Crn *string `json:"crn,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // The programmatic name of this offering. + Name *string `json:"name,omitempty"` + + // URL for an icon associated with this offering. + OfferingIconURL *string `json:"offering_icon_url,omitempty"` + + // URL for an additional docs with this offering. + OfferingDocsURL *string `json:"offering_docs_url,omitempty"` + + // URL to be displayed in the Consumption UI for getting support on this offering. + OfferingSupportURL *string `json:"offering_support_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // Repository info for offerings. + Rating *Rating `json:"rating,omitempty"` + + // The date and time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date and time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Short description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // Long description in the requested language. + LongDescription *string `json:"long_description,omitempty"` + + // list of features associated with this offering. + Features []Feature `json:"features,omitempty"` + + // Array of kind. + Kinds []Kind `json:"kinds,omitempty"` + + // Is it permitted to request publishing to IBM or Public. + PermitRequestIbmPublicPublish *bool `json:"permit_request_ibm_public_publish,omitempty"` + + // Indicates if this offering has been approved for use by all IBMers. + IbmPublishApproved *bool `json:"ibm_publish_approved,omitempty"` + + // Indicates if this offering has been approved for use by all IBM Cloud users. + PublicPublishApproved *bool `json:"public_publish_approved,omitempty"` + + // The original offering CRN that this publish entry came from. + PublicOriginalCrn *string `json:"public_original_crn,omitempty"` + + // The crn of the public catalog entry of this offering. + PublishPublicCrn *string `json:"publish_public_crn,omitempty"` + + // The portal's approval record ID. + PortalApprovalRecord *string `json:"portal_approval_record,omitempty"` + + // The portal UI URL. + PortalUiURL *string `json:"portal_ui_url,omitempty"` + + // The id of the catalog containing this offering. + CatalogID *string `json:"catalog_id,omitempty"` + + // The name of the catalog. + CatalogName *string `json:"catalog_name,omitempty"` + + // Map of metadata values for this offering. + Metadata interface{} `json:"metadata,omitempty"` + + // A disclaimer for this offering. + Disclaimer *string `json:"disclaimer,omitempty"` + + // Determine if this offering should be displayed in the Consumption UI. + Hidden *bool `json:"hidden,omitempty"` + + // Provider of this offering. + Provider *string `json:"provider,omitempty"` + + // Repository info for offerings. + RepoInfo *RepoInfo `json:"repo_info,omitempty"` +} + + +// UnmarshalOffering unmarshals an instance of Offering from the specified map of raw messages. +func UnmarshalOffering(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Offering) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "_rev", &obj.Rev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "url", &obj.URL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "label", &obj.Label) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_icon_url", &obj.OfferingIconURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_docs_url", &obj.OfferingDocsURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_support_url", &obj.OfferingSupportURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalModel(m, "rating", &obj.Rating, UnmarshalRating) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "short_description", &obj.ShortDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "long_description", &obj.LongDescription) + if err != nil { + return + } + err = core.UnmarshalModel(m, "features", &obj.Features, UnmarshalFeature) + if err != nil { + return + } + err = core.UnmarshalModel(m, "kinds", &obj.Kinds, UnmarshalKind) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "permit_request_ibm_public_publish", &obj.PermitRequestIbmPublicPublish) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "ibm_publish_approved", &obj.IbmPublishApproved) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "public_publish_approved", &obj.PublicPublishApproved) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "public_original_crn", &obj.PublicOriginalCrn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "publish_public_crn", &obj.PublishPublicCrn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "portal_approval_record", &obj.PortalApprovalRecord) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "portal_ui_url", &obj.PortalUiURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_id", &obj.CatalogID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_name", &obj.CatalogName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "metadata", &obj.Metadata) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "disclaimer", &obj.Disclaimer) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "hidden", &obj.Hidden) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "provider", &obj.Provider) + if err != nil { + return + } + err = core.UnmarshalModel(m, "repo_info", &obj.RepoInfo, UnmarshalRepoInfo) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// OfferingSearchResult : Paginated offering search result. +type OfferingSearchResult struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting objects. + Resources []Offering `json:"resources,omitempty"` +} + + +// UnmarshalOfferingSearchResult unmarshals an instance of OfferingSearchResult from the specified map of raw messages. +func UnmarshalOfferingSearchResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(OfferingSearchResult) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalOffering) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// OperatorDeployResult : Operator deploy result. +type OperatorDeployResult struct { + // Status phase. + Phase *string `json:"phase,omitempty"` + + // Status message. + Message *string `json:"message,omitempty"` + + // Operator API path. + Link *string `json:"link,omitempty"` + + // Name of Operator. + Name *string `json:"name,omitempty"` + + // Operator version. + Version *string `json:"version,omitempty"` + + // Kube namespace. + Namespace *string `json:"namespace,omitempty"` + + // Package Operator exists in. + PackageName *string `json:"package_name,omitempty"` + + // Catalog identification. + CatalogID *string `json:"catalog_id,omitempty"` +} + + +// UnmarshalOperatorDeployResult unmarshals an instance of OperatorDeployResult from the specified map of raw messages. +func UnmarshalOperatorDeployResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(OperatorDeployResult) + err = core.UnmarshalPrimitive(m, "phase", &obj.Phase) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "message", &obj.Message) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "link", &obj.Link) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version", &obj.Version) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "namespace", &obj.Namespace) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "package_name", &obj.PackageName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_id", &obj.CatalogID) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Plan : Offering plan. +type Plan struct { + // unique id. + ID *string `json:"id,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // The programmatic name of this offering. + Name *string `json:"name,omitempty"` + + // Short description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // Long description in the requested language. + LongDescription *string `json:"long_description,omitempty"` + + // open ended metadata information. + Metadata interface{} `json:"metadata,omitempty"` + + // list of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // list of features associated with this offering. + AdditionalFeatures []Feature `json:"additional_features,omitempty"` + + // the date'time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // the date'time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // list of deployments. + Deployments []Deployment `json:"deployments,omitempty"` +} + + +// UnmarshalPlan unmarshals an instance of Plan from the specified map of raw messages. +func UnmarshalPlan(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Plan) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "label", &obj.Label) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "short_description", &obj.ShortDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "long_description", &obj.LongDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "metadata", &obj.Metadata) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalModel(m, "additional_features", &obj.AdditionalFeatures, UnmarshalFeature) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + err = core.UnmarshalModel(m, "deployments", &obj.Deployments, UnmarshalDeployment) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// PreinstallVersionOptions : The PreinstallVersion options. +type PreinstallVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Kube namespace. + Namespace *string `json:"namespace,omitempty"` + + // Object containing Helm chart override values. + OverrideValues interface{} `json:"override_values,omitempty"` + + // Entitlement API Key for this offering. + EntitlementApikey *string `json:"entitlement_apikey,omitempty"` + + // Schematics workspace configuration. + Schematics *DeployRequestBodySchematics `json:"schematics,omitempty"` + + // Script. + Script *string `json:"script,omitempty"` + + // Script ID. + ScriptID *string `json:"script_id,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id,omitempty"` + + // VCenter ID. + VcenterID *string `json:"vcenter_id,omitempty"` + + // VCenter Password. + VcenterPassword *string `json:"vcenter_password,omitempty"` + + // VCenter Location. + VcenterLocation *string `json:"vcenter_location,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewPreinstallVersionOptions : Instantiate PreinstallVersionOptions +func (*CatalogManagementV1) NewPreinstallVersionOptions(versionLocID string, xAuthRefreshToken string) *PreinstallVersionOptions { + return &PreinstallVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *PreinstallVersionOptions) SetVersionLocID(versionLocID string) *PreinstallVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *PreinstallVersionOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *PreinstallVersionOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *PreinstallVersionOptions) SetClusterID(clusterID string) *PreinstallVersionOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *PreinstallVersionOptions) SetRegion(region string) *PreinstallVersionOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *PreinstallVersionOptions) SetNamespace(namespace string) *PreinstallVersionOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetOverrideValues : Allow user to set OverrideValues +func (options *PreinstallVersionOptions) SetOverrideValues(overrideValues interface{}) *PreinstallVersionOptions { + options.OverrideValues = overrideValues + return options +} + +// SetEntitlementApikey : Allow user to set EntitlementApikey +func (options *PreinstallVersionOptions) SetEntitlementApikey(entitlementApikey string) *PreinstallVersionOptions { + options.EntitlementApikey = core.StringPtr(entitlementApikey) + return options +} + +// SetSchematics : Allow user to set Schematics +func (options *PreinstallVersionOptions) SetSchematics(schematics *DeployRequestBodySchematics) *PreinstallVersionOptions { + options.Schematics = schematics + return options +} + +// SetScript : Allow user to set Script +func (options *PreinstallVersionOptions) SetScript(script string) *PreinstallVersionOptions { + options.Script = core.StringPtr(script) + return options +} + +// SetScriptID : Allow user to set ScriptID +func (options *PreinstallVersionOptions) SetScriptID(scriptID string) *PreinstallVersionOptions { + options.ScriptID = core.StringPtr(scriptID) + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *PreinstallVersionOptions) SetVersionLocatorID(versionLocatorID string) *PreinstallVersionOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetVcenterID : Allow user to set VcenterID +func (options *PreinstallVersionOptions) SetVcenterID(vcenterID string) *PreinstallVersionOptions { + options.VcenterID = core.StringPtr(vcenterID) + return options +} + +// SetVcenterPassword : Allow user to set VcenterPassword +func (options *PreinstallVersionOptions) SetVcenterPassword(vcenterPassword string) *PreinstallVersionOptions { + options.VcenterPassword = core.StringPtr(vcenterPassword) + return options +} + +// SetVcenterLocation : Allow user to set VcenterLocation +func (options *PreinstallVersionOptions) SetVcenterLocation(vcenterLocation string) *PreinstallVersionOptions { + options.VcenterLocation = core.StringPtr(vcenterLocation) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *PreinstallVersionOptions) SetHeaders(param map[string]string) *PreinstallVersionOptions { + options.Headers = param + return options +} + +// PublicPublishVersionOptions : The PublicPublishVersion options. +type PublicPublishVersionOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewPublicPublishVersionOptions : Instantiate PublicPublishVersionOptions +func (*CatalogManagementV1) NewPublicPublishVersionOptions(versionLocID string) *PublicPublishVersionOptions { + return &PublicPublishVersionOptions{ + VersionLocID: core.StringPtr(versionLocID), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *PublicPublishVersionOptions) SetVersionLocID(versionLocID string) *PublicPublishVersionOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *PublicPublishVersionOptions) SetHeaders(param map[string]string) *PublicPublishVersionOptions { + options.Headers = param + return options +} + +// Rating : Repository info for offerings. +type Rating struct { + // One start rating. + OneStarCount *int64 `json:"one_star_count,omitempty"` + + // Two start rating. + TwoStarCount *int64 `json:"two_star_count,omitempty"` + + // Three start rating. + ThreeStarCount *int64 `json:"three_star_count,omitempty"` + + // Four start rating. + FourStarCount *int64 `json:"four_star_count,omitempty"` +} + + +// UnmarshalRating unmarshals an instance of Rating from the specified map of raw messages. +func UnmarshalRating(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Rating) + err = core.UnmarshalPrimitive(m, "one_star_count", &obj.OneStarCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "two_star_count", &obj.TwoStarCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "three_star_count", &obj.ThreeStarCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "four_star_count", &obj.FourStarCount) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ReloadOfferingOptions : The ReloadOffering options. +type ReloadOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // URL path to zip location. + Zipurl *string `json:"zipurl" validate:"required"` + + // The semver value for this new version. + TargetVersion *string `json:"targetVersion" validate:"required"` + + // Tags array. + Tags []string `json:"tags,omitempty"` + + // Target kinds. Current valid values are 'iks', 'roks', 'vcenter', and 'terraform'. + TargetKinds []string `json:"target_kinds,omitempty"` + + // The type of repository containing this version. Valid values are 'public_git' or 'enterprise_git'. + RepoType *string `json:"repoType,omitempty"` + + // Authentication token used to access the specified zip file. + XAuthToken *string `json:"X-Auth-Token,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReloadOfferingOptions : Instantiate ReloadOfferingOptions +func (*CatalogManagementV1) NewReloadOfferingOptions(catalogIdentifier string, offeringID string, zipurl string, targetVersion string) *ReloadOfferingOptions { + return &ReloadOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + Zipurl: core.StringPtr(zipurl), + TargetVersion: core.StringPtr(targetVersion), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ReloadOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *ReloadOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *ReloadOfferingOptions) SetOfferingID(offeringID string) *ReloadOfferingOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetZipurl : Allow user to set Zipurl +func (options *ReloadOfferingOptions) SetZipurl(zipurl string) *ReloadOfferingOptions { + options.Zipurl = core.StringPtr(zipurl) + return options +} + +// SetTargetVersion : Allow user to set TargetVersion +func (options *ReloadOfferingOptions) SetTargetVersion(targetVersion string) *ReloadOfferingOptions { + options.TargetVersion = core.StringPtr(targetVersion) + return options +} + +// SetTags : Allow user to set Tags +func (options *ReloadOfferingOptions) SetTags(tags []string) *ReloadOfferingOptions { + options.Tags = tags + return options +} + +// SetTargetKinds : Allow user to set TargetKinds +func (options *ReloadOfferingOptions) SetTargetKinds(targetKinds []string) *ReloadOfferingOptions { + options.TargetKinds = targetKinds + return options +} + +// SetRepoType : Allow user to set RepoType +func (options *ReloadOfferingOptions) SetRepoType(repoType string) *ReloadOfferingOptions { + options.RepoType = core.StringPtr(repoType) + return options +} + +// SetXAuthToken : Allow user to set XAuthToken +func (options *ReloadOfferingOptions) SetXAuthToken(xAuthToken string) *ReloadOfferingOptions { + options.XAuthToken = core.StringPtr(xAuthToken) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReloadOfferingOptions) SetHeaders(param map[string]string) *ReloadOfferingOptions { + options.Headers = param + return options +} + +// ReplaceCatalogOptions : The ReplaceCatalog options. +type ReplaceCatalogOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Unique ID. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // Description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // URL for an icon associated with this catalog. + CatalogIconURL *string `json:"catalog_icon_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // The url for this specific catalog. + URL *string `json:"url,omitempty"` + + // CRN associated with the catalog. + Crn *string `json:"crn,omitempty"` + + // URL path to offerings. + OfferingsURL *string `json:"offerings_url,omitempty"` + + // List of features associated with this catalog. + Features []Feature `json:"features,omitempty"` + + // Denotes whether a catalog is disabled. + Disabled *bool `json:"disabled,omitempty"` + + // The date'time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date'time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Resource group id the catalog is owned by. + ResourceGroupID *string `json:"resource_group_id,omitempty"` + + // Account that owns catalog. + OwningAccount *string `json:"owning_account,omitempty"` + + // Filters for account and catalog filters. + CatalogFilters *Filters `json:"catalog_filters,omitempty"` + + // Feature information. + SyndicationSettings *SyndicationResource `json:"syndication_settings,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReplaceCatalogOptions : Instantiate ReplaceCatalogOptions +func (*CatalogManagementV1) NewReplaceCatalogOptions(catalogIdentifier string) *ReplaceCatalogOptions { + return &ReplaceCatalogOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ReplaceCatalogOptions) SetCatalogIdentifier(catalogIdentifier string) *ReplaceCatalogOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetID : Allow user to set ID +func (options *ReplaceCatalogOptions) SetID(id string) *ReplaceCatalogOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetRev : Allow user to set Rev +func (options *ReplaceCatalogOptions) SetRev(rev string) *ReplaceCatalogOptions { + options.Rev = core.StringPtr(rev) + return options +} + +// SetLabel : Allow user to set Label +func (options *ReplaceCatalogOptions) SetLabel(label string) *ReplaceCatalogOptions { + options.Label = core.StringPtr(label) + return options +} + +// SetShortDescription : Allow user to set ShortDescription +func (options *ReplaceCatalogOptions) SetShortDescription(shortDescription string) *ReplaceCatalogOptions { + options.ShortDescription = core.StringPtr(shortDescription) + return options +} + +// SetCatalogIconURL : Allow user to set CatalogIconURL +func (options *ReplaceCatalogOptions) SetCatalogIconURL(catalogIconURL string) *ReplaceCatalogOptions { + options.CatalogIconURL = core.StringPtr(catalogIconURL) + return options +} + +// SetTags : Allow user to set Tags +func (options *ReplaceCatalogOptions) SetTags(tags []string) *ReplaceCatalogOptions { + options.Tags = tags + return options +} + +// SetURL : Allow user to set URL +func (options *ReplaceCatalogOptions) SetURL(url string) *ReplaceCatalogOptions { + options.URL = core.StringPtr(url) + return options +} + +// SetCrn : Allow user to set Crn +func (options *ReplaceCatalogOptions) SetCrn(crn string) *ReplaceCatalogOptions { + options.Crn = core.StringPtr(crn) + return options +} + +// SetOfferingsURL : Allow user to set OfferingsURL +func (options *ReplaceCatalogOptions) SetOfferingsURL(offeringsURL string) *ReplaceCatalogOptions { + options.OfferingsURL = core.StringPtr(offeringsURL) + return options +} + +// SetFeatures : Allow user to set Features +func (options *ReplaceCatalogOptions) SetFeatures(features []Feature) *ReplaceCatalogOptions { + options.Features = features + return options +} + +// SetDisabled : Allow user to set Disabled +func (options *ReplaceCatalogOptions) SetDisabled(disabled bool) *ReplaceCatalogOptions { + options.Disabled = core.BoolPtr(disabled) + return options +} + +// SetCreated : Allow user to set Created +func (options *ReplaceCatalogOptions) SetCreated(created *strfmt.DateTime) *ReplaceCatalogOptions { + options.Created = created + return options +} + +// SetUpdated : Allow user to set Updated +func (options *ReplaceCatalogOptions) SetUpdated(updated *strfmt.DateTime) *ReplaceCatalogOptions { + options.Updated = updated + return options +} + +// SetResourceGroupID : Allow user to set ResourceGroupID +func (options *ReplaceCatalogOptions) SetResourceGroupID(resourceGroupID string) *ReplaceCatalogOptions { + options.ResourceGroupID = core.StringPtr(resourceGroupID) + return options +} + +// SetOwningAccount : Allow user to set OwningAccount +func (options *ReplaceCatalogOptions) SetOwningAccount(owningAccount string) *ReplaceCatalogOptions { + options.OwningAccount = core.StringPtr(owningAccount) + return options +} + +// SetCatalogFilters : Allow user to set CatalogFilters +func (options *ReplaceCatalogOptions) SetCatalogFilters(catalogFilters *Filters) *ReplaceCatalogOptions { + options.CatalogFilters = catalogFilters + return options +} + +// SetSyndicationSettings : Allow user to set SyndicationSettings +func (options *ReplaceCatalogOptions) SetSyndicationSettings(syndicationSettings *SyndicationResource) *ReplaceCatalogOptions { + options.SyndicationSettings = syndicationSettings + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReplaceCatalogOptions) SetHeaders(param map[string]string) *ReplaceCatalogOptions { + options.Headers = param + return options +} + +// ReplaceEnterpriseOptions : The ReplaceEnterprise options. +type ReplaceEnterpriseOptions struct { + // Enterprise identification. + EnterpriseID *string `json:"enterprise_id" validate:"required"` + + // Enterprise identification. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Filters for account and catalog filters. + AccountFilters *Filters `json:"account_filters,omitempty"` + + // Map of account group ids to AccountGroup objects. + AccountGroups *EnterpriseAccountGroups `json:"account_groups,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReplaceEnterpriseOptions : Instantiate ReplaceEnterpriseOptions +func (*CatalogManagementV1) NewReplaceEnterpriseOptions(enterpriseID string) *ReplaceEnterpriseOptions { + return &ReplaceEnterpriseOptions{ + EnterpriseID: core.StringPtr(enterpriseID), + } +} + +// SetEnterpriseID : Allow user to set EnterpriseID +func (options *ReplaceEnterpriseOptions) SetEnterpriseID(enterpriseID string) *ReplaceEnterpriseOptions { + options.EnterpriseID = core.StringPtr(enterpriseID) + return options +} + +// SetID : Allow user to set ID +func (options *ReplaceEnterpriseOptions) SetID(id string) *ReplaceEnterpriseOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetRev : Allow user to set Rev +func (options *ReplaceEnterpriseOptions) SetRev(rev string) *ReplaceEnterpriseOptions { + options.Rev = core.StringPtr(rev) + return options +} + +// SetAccountFilters : Allow user to set AccountFilters +func (options *ReplaceEnterpriseOptions) SetAccountFilters(accountFilters *Filters) *ReplaceEnterpriseOptions { + options.AccountFilters = accountFilters + return options +} + +// SetAccountGroups : Allow user to set AccountGroups +func (options *ReplaceEnterpriseOptions) SetAccountGroups(accountGroups *EnterpriseAccountGroups) *ReplaceEnterpriseOptions { + options.AccountGroups = accountGroups + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReplaceEnterpriseOptions) SetHeaders(param map[string]string) *ReplaceEnterpriseOptions { + options.Headers = param + return options +} + +// ReplaceOfferingIconOptions : The ReplaceOfferingIcon options. +type ReplaceOfferingIconOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // Name of the file name that is being uploaded. + FileName *string `json:"file_name" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReplaceOfferingIconOptions : Instantiate ReplaceOfferingIconOptions +func (*CatalogManagementV1) NewReplaceOfferingIconOptions(catalogIdentifier string, offeringID string, fileName string) *ReplaceOfferingIconOptions { + return &ReplaceOfferingIconOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + FileName: core.StringPtr(fileName), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ReplaceOfferingIconOptions) SetCatalogIdentifier(catalogIdentifier string) *ReplaceOfferingIconOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *ReplaceOfferingIconOptions) SetOfferingID(offeringID string) *ReplaceOfferingIconOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetFileName : Allow user to set FileName +func (options *ReplaceOfferingIconOptions) SetFileName(fileName string) *ReplaceOfferingIconOptions { + options.FileName = core.StringPtr(fileName) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReplaceOfferingIconOptions) SetHeaders(param map[string]string) *ReplaceOfferingIconOptions { + options.Headers = param + return options +} + +// ReplaceOfferingOptions : The ReplaceOffering options. +type ReplaceOfferingOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // unique id. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // The url for this specific offering. + URL *string `json:"url,omitempty"` + + // The crn for this specific offering. + Crn *string `json:"crn,omitempty"` + + // Display Name in the requested language. + Label *string `json:"label,omitempty"` + + // The programmatic name of this offering. + Name *string `json:"name,omitempty"` + + // URL for an icon associated with this offering. + OfferingIconURL *string `json:"offering_icon_url,omitempty"` + + // URL for an additional docs with this offering. + OfferingDocsURL *string `json:"offering_docs_url,omitempty"` + + // URL to be displayed in the Consumption UI for getting support on this offering. + OfferingSupportURL *string `json:"offering_support_url,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // Repository info for offerings. + Rating *Rating `json:"rating,omitempty"` + + // The date and time this catalog was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date and time this catalog was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Short description in the requested language. + ShortDescription *string `json:"short_description,omitempty"` + + // Long description in the requested language. + LongDescription *string `json:"long_description,omitempty"` + + // list of features associated with this offering. + Features []Feature `json:"features,omitempty"` + + // Array of kind. + Kinds []Kind `json:"kinds,omitempty"` + + // Is it permitted to request publishing to IBM or Public. + PermitRequestIbmPublicPublish *bool `json:"permit_request_ibm_public_publish,omitempty"` + + // Indicates if this offering has been approved for use by all IBMers. + IbmPublishApproved *bool `json:"ibm_publish_approved,omitempty"` + + // Indicates if this offering has been approved for use by all IBM Cloud users. + PublicPublishApproved *bool `json:"public_publish_approved,omitempty"` + + // The original offering CRN that this publish entry came from. + PublicOriginalCrn *string `json:"public_original_crn,omitempty"` + + // The crn of the public catalog entry of this offering. + PublishPublicCrn *string `json:"publish_public_crn,omitempty"` + + // The portal's approval record ID. + PortalApprovalRecord *string `json:"portal_approval_record,omitempty"` + + // The portal UI URL. + PortalUiURL *string `json:"portal_ui_url,omitempty"` + + // The id of the catalog containing this offering. + CatalogID *string `json:"catalog_id,omitempty"` + + // The name of the catalog. + CatalogName *string `json:"catalog_name,omitempty"` + + // Map of metadata values for this offering. + Metadata interface{} `json:"metadata,omitempty"` + + // A disclaimer for this offering. + Disclaimer *string `json:"disclaimer,omitempty"` + + // Determine if this offering should be displayed in the Consumption UI. + Hidden *bool `json:"hidden,omitempty"` + + // Provider of this offering. + Provider *string `json:"provider,omitempty"` + + // Repository info for offerings. + RepoInfo *RepoInfo `json:"repo_info,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReplaceOfferingOptions : Instantiate ReplaceOfferingOptions +func (*CatalogManagementV1) NewReplaceOfferingOptions(catalogIdentifier string, offeringID string) *ReplaceOfferingOptions { + return &ReplaceOfferingOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *ReplaceOfferingOptions) SetCatalogIdentifier(catalogIdentifier string) *ReplaceOfferingOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *ReplaceOfferingOptions) SetOfferingID(offeringID string) *ReplaceOfferingOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetID : Allow user to set ID +func (options *ReplaceOfferingOptions) SetID(id string) *ReplaceOfferingOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetRev : Allow user to set Rev +func (options *ReplaceOfferingOptions) SetRev(rev string) *ReplaceOfferingOptions { + options.Rev = core.StringPtr(rev) + return options +} + +// SetURL : Allow user to set URL +func (options *ReplaceOfferingOptions) SetURL(url string) *ReplaceOfferingOptions { + options.URL = core.StringPtr(url) + return options +} + +// SetCrn : Allow user to set Crn +func (options *ReplaceOfferingOptions) SetCrn(crn string) *ReplaceOfferingOptions { + options.Crn = core.StringPtr(crn) + return options +} + +// SetLabel : Allow user to set Label +func (options *ReplaceOfferingOptions) SetLabel(label string) *ReplaceOfferingOptions { + options.Label = core.StringPtr(label) + return options +} + +// SetName : Allow user to set Name +func (options *ReplaceOfferingOptions) SetName(name string) *ReplaceOfferingOptions { + options.Name = core.StringPtr(name) + return options +} + +// SetOfferingIconURL : Allow user to set OfferingIconURL +func (options *ReplaceOfferingOptions) SetOfferingIconURL(offeringIconURL string) *ReplaceOfferingOptions { + options.OfferingIconURL = core.StringPtr(offeringIconURL) + return options +} + +// SetOfferingDocsURL : Allow user to set OfferingDocsURL +func (options *ReplaceOfferingOptions) SetOfferingDocsURL(offeringDocsURL string) *ReplaceOfferingOptions { + options.OfferingDocsURL = core.StringPtr(offeringDocsURL) + return options +} + +// SetOfferingSupportURL : Allow user to set OfferingSupportURL +func (options *ReplaceOfferingOptions) SetOfferingSupportURL(offeringSupportURL string) *ReplaceOfferingOptions { + options.OfferingSupportURL = core.StringPtr(offeringSupportURL) + return options +} + +// SetTags : Allow user to set Tags +func (options *ReplaceOfferingOptions) SetTags(tags []string) *ReplaceOfferingOptions { + options.Tags = tags + return options +} + +// SetRating : Allow user to set Rating +func (options *ReplaceOfferingOptions) SetRating(rating *Rating) *ReplaceOfferingOptions { + options.Rating = rating + return options +} + +// SetCreated : Allow user to set Created +func (options *ReplaceOfferingOptions) SetCreated(created *strfmt.DateTime) *ReplaceOfferingOptions { + options.Created = created + return options +} + +// SetUpdated : Allow user to set Updated +func (options *ReplaceOfferingOptions) SetUpdated(updated *strfmt.DateTime) *ReplaceOfferingOptions { + options.Updated = updated + return options +} + +// SetShortDescription : Allow user to set ShortDescription +func (options *ReplaceOfferingOptions) SetShortDescription(shortDescription string) *ReplaceOfferingOptions { + options.ShortDescription = core.StringPtr(shortDescription) + return options +} + +// SetLongDescription : Allow user to set LongDescription +func (options *ReplaceOfferingOptions) SetLongDescription(longDescription string) *ReplaceOfferingOptions { + options.LongDescription = core.StringPtr(longDescription) + return options +} + +// SetFeatures : Allow user to set Features +func (options *ReplaceOfferingOptions) SetFeatures(features []Feature) *ReplaceOfferingOptions { + options.Features = features + return options +} + +// SetKinds : Allow user to set Kinds +func (options *ReplaceOfferingOptions) SetKinds(kinds []Kind) *ReplaceOfferingOptions { + options.Kinds = kinds + return options +} + +// SetPermitRequestIbmPublicPublish : Allow user to set PermitRequestIbmPublicPublish +func (options *ReplaceOfferingOptions) SetPermitRequestIbmPublicPublish(permitRequestIbmPublicPublish bool) *ReplaceOfferingOptions { + options.PermitRequestIbmPublicPublish = core.BoolPtr(permitRequestIbmPublicPublish) + return options +} + +// SetIbmPublishApproved : Allow user to set IbmPublishApproved +func (options *ReplaceOfferingOptions) SetIbmPublishApproved(ibmPublishApproved bool) *ReplaceOfferingOptions { + options.IbmPublishApproved = core.BoolPtr(ibmPublishApproved) + return options +} + +// SetPublicPublishApproved : Allow user to set PublicPublishApproved +func (options *ReplaceOfferingOptions) SetPublicPublishApproved(publicPublishApproved bool) *ReplaceOfferingOptions { + options.PublicPublishApproved = core.BoolPtr(publicPublishApproved) + return options +} + +// SetPublicOriginalCrn : Allow user to set PublicOriginalCrn +func (options *ReplaceOfferingOptions) SetPublicOriginalCrn(publicOriginalCrn string) *ReplaceOfferingOptions { + options.PublicOriginalCrn = core.StringPtr(publicOriginalCrn) + return options +} + +// SetPublishPublicCrn : Allow user to set PublishPublicCrn +func (options *ReplaceOfferingOptions) SetPublishPublicCrn(publishPublicCrn string) *ReplaceOfferingOptions { + options.PublishPublicCrn = core.StringPtr(publishPublicCrn) + return options +} + +// SetPortalApprovalRecord : Allow user to set PortalApprovalRecord +func (options *ReplaceOfferingOptions) SetPortalApprovalRecord(portalApprovalRecord string) *ReplaceOfferingOptions { + options.PortalApprovalRecord = core.StringPtr(portalApprovalRecord) + return options +} + +// SetPortalUiURL : Allow user to set PortalUiURL +func (options *ReplaceOfferingOptions) SetPortalUiURL(portalUiURL string) *ReplaceOfferingOptions { + options.PortalUiURL = core.StringPtr(portalUiURL) + return options +} + +// SetCatalogID : Allow user to set CatalogID +func (options *ReplaceOfferingOptions) SetCatalogID(catalogID string) *ReplaceOfferingOptions { + options.CatalogID = core.StringPtr(catalogID) + return options +} + +// SetCatalogName : Allow user to set CatalogName +func (options *ReplaceOfferingOptions) SetCatalogName(catalogName string) *ReplaceOfferingOptions { + options.CatalogName = core.StringPtr(catalogName) + return options +} + +// SetMetadata : Allow user to set Metadata +func (options *ReplaceOfferingOptions) SetMetadata(metadata interface{}) *ReplaceOfferingOptions { + options.Metadata = metadata + return options +} + +// SetDisclaimer : Allow user to set Disclaimer +func (options *ReplaceOfferingOptions) SetDisclaimer(disclaimer string) *ReplaceOfferingOptions { + options.Disclaimer = core.StringPtr(disclaimer) + return options +} + +// SetHidden : Allow user to set Hidden +func (options *ReplaceOfferingOptions) SetHidden(hidden bool) *ReplaceOfferingOptions { + options.Hidden = core.BoolPtr(hidden) + return options +} + +// SetProvider : Allow user to set Provider +func (options *ReplaceOfferingOptions) SetProvider(provider string) *ReplaceOfferingOptions { + options.Provider = core.StringPtr(provider) + return options +} + +// SetRepoInfo : Allow user to set RepoInfo +func (options *ReplaceOfferingOptions) SetRepoInfo(repoInfo *RepoInfo) *ReplaceOfferingOptions { + options.RepoInfo = repoInfo + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReplaceOfferingOptions) SetHeaders(param map[string]string) *ReplaceOfferingOptions { + options.Headers = param + return options +} + +// ReplaceOperatorOptions : The ReplaceOperator options. +type ReplaceOperatorOptions struct { + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Kube namespaces to deploy Operator(s) to. + Namespaces []string `json:"namespaces,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewReplaceOperatorOptions : Instantiate ReplaceOperatorOptions +func (*CatalogManagementV1) NewReplaceOperatorOptions(xAuthRefreshToken string) *ReplaceOperatorOptions { + return &ReplaceOperatorOptions{ + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *ReplaceOperatorOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *ReplaceOperatorOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *ReplaceOperatorOptions) SetClusterID(clusterID string) *ReplaceOperatorOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *ReplaceOperatorOptions) SetRegion(region string) *ReplaceOperatorOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespaces : Allow user to set Namespaces +func (options *ReplaceOperatorOptions) SetNamespaces(namespaces []string) *ReplaceOperatorOptions { + options.Namespaces = namespaces + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *ReplaceOperatorOptions) SetVersionLocatorID(versionLocatorID string) *ReplaceOperatorOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ReplaceOperatorOptions) SetHeaders(param map[string]string) *ReplaceOperatorOptions { + options.Headers = param + return options +} + +// RepoInfo : Repository info for offerings. +type RepoInfo struct { + // Token for private repos. + Token *string `json:"token,omitempty"` + + // Public or enterprise GitHub. + Type *string `json:"type,omitempty"` +} + + +// UnmarshalRepoInfo unmarshals an instance of RepoInfo from the specified map of raw messages. +func UnmarshalRepoInfo(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(RepoInfo) + err = core.UnmarshalPrimitive(m, "token", &obj.Token) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Resource : Resource requirements. +type Resource struct { + // Type of requirement. + Type *string `json:"type,omitempty"` + + // mem, disk, cores, and nodes can be parsed as an int. targetVersion will be a semver range value. + Value interface{} `json:"value,omitempty"` +} + +// Constants associated with the Resource.Type property. +// Type of requirement. +const ( + Resource_Type_Cores = "cores" + Resource_Type_Disk = "disk" + Resource_Type_Mem = "mem" + Resource_Type_Nodes = "nodes" + Resource_Type_Targetversion = "targetVersion" +) + + +// UnmarshalResource unmarshals an instance of Resource from the specified map of raw messages. +func UnmarshalResource(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Resource) + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "value", &obj.Value) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ResourceGroup : Resource group details. +type ResourceGroup struct { + // Resource Group ID. + ID *string `json:"id,omitempty"` + + // Provider name, eg. IBM Passport Advantage. + Name *string `json:"name,omitempty"` + + // Provider CRN. + Crn *string `json:"crn,omitempty"` + + // Account ID for this Resource Group. + AccountID *string `json:"account_id,omitempty"` + + // State of this Resource Group. + State *string `json:"state,omitempty"` + + // Indicates if this Resource Group is active or not. + Default *bool `json:"default,omitempty"` +} + + +// UnmarshalResourceGroup unmarshals an instance of ResourceGroup from the specified map of raw messages. +func UnmarshalResourceGroup(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ResourceGroup) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "account_id", &obj.AccountID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "state", &obj.State) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "default", &obj.Default) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ResourceGroups : Resource groups details. +type ResourceGroups struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting Resource Group objects. + Resources []ResourceGroup `json:"resources,omitempty"` +} + + +// UnmarshalResourceGroups unmarshals an instance of ResourceGroups from the specified map of raw messages. +func UnmarshalResourceGroups(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(ResourceGroups) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalResourceGroup) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspace : Schematics workspace information. +type SchematicsWorkspace struct { + // Workspace ID. + ID *string `json:"id,omitempty"` + + // Workspace name. + Name *string `json:"name,omitempty"` + + // Workspace types. + Type []string `json:"type,omitempty"` + + // Workspace description. + Description *string `json:"description,omitempty"` + + // Workspace tags. + Tags []string `json:"tags,omitempty"` + + // Workspace creation date and time. + CreatedAt *strfmt.DateTime `json:"created_at,omitempty"` + + // Email address of user that created the ID. + CreatedBy *string `json:"created_by,omitempty"` + + // Workspace apply status. + Status *string `json:"status,omitempty"` + + // Workspace frozen/locked status. + WorkspaceStatus *SchematicsWorkspaceWorkspaceStatus `json:"workspace_status,omitempty"` + + // Template reference. + TemplateRef *string `json:"template_ref,omitempty"` + + // Template repository. + TemplateRepo *SchematicsWorkspaceTemplateRepo `json:"template_repo,omitempty"` + + // Map of template data. + TemplateData []interface{} `json:"template_data,omitempty"` + + // Data describing runtime. + RuntimeData *SchematicsWorkspaceRuntimeData `json:"runtime_data,omitempty"` + + // Map of shared data. + SharedData interface{} `json:"shared_data,omitempty"` + + // Catalog reference. + CatalogRef *SchematicsWorkspaceCatalogRef `json:"catalog_ref,omitempty"` +} + + +// UnmarshalSchematicsWorkspace unmarshals an instance of SchematicsWorkspace from the specified map of raw messages. +func UnmarshalSchematicsWorkspace(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspace) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "description", &obj.Description) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created_at", &obj.CreatedAt) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created_by", &obj.CreatedBy) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "status", &obj.Status) + if err != nil { + return + } + err = core.UnmarshalModel(m, "workspace_status", &obj.WorkspaceStatus, UnmarshalSchematicsWorkspaceWorkspaceStatus) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "template_ref", &obj.TemplateRef) + if err != nil { + return + } + err = core.UnmarshalModel(m, "template_repo", &obj.TemplateRepo, UnmarshalSchematicsWorkspaceTemplateRepo) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "template_data", &obj.TemplateData) + if err != nil { + return + } + err = core.UnmarshalModel(m, "runtime_data", &obj.RuntimeData, UnmarshalSchematicsWorkspaceRuntimeData) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "shared_data", &obj.SharedData) + if err != nil { + return + } + err = core.UnmarshalModel(m, "catalog_ref", &obj.CatalogRef, UnmarshalSchematicsWorkspaceCatalogRef) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspaceCatalogRef : Catalog reference. +type SchematicsWorkspaceCatalogRef struct { + // Version locator ID. + ItemID *string `json:"item_id,omitempty"` + + // The name of the offering that generated this Blueprint. + ItemName *string `json:"item_name,omitempty"` + + // Relative Dashboard URL for content that generated this Blueprint. + ItemURL *string `json:"item_url,omitempty"` +} + + +// UnmarshalSchematicsWorkspaceCatalogRef unmarshals an instance of SchematicsWorkspaceCatalogRef from the specified map of raw messages. +func UnmarshalSchematicsWorkspaceCatalogRef(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspaceCatalogRef) + err = core.UnmarshalPrimitive(m, "item_id", &obj.ItemID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "item_name", &obj.ItemName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "item_url", &obj.ItemURL) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspaceRuntimeData : Data describing runtime. +type SchematicsWorkspaceRuntimeData struct { + // Runtime ID. + ID *string `json:"id,omitempty"` + + // Engine name. + EngineName *string `json:"engine_name,omitempty"` + + // Engine version. + EngineVersion *string `json:"engine_version,omitempty"` + + // URL path to state store. + StateStoreURL *string `json:"state_store_url,omitempty"` + + // URL path to log store. + LogStoreURL *string `json:"log_store_url,omitempty"` +} + + +// UnmarshalSchematicsWorkspaceRuntimeData unmarshals an instance of SchematicsWorkspaceRuntimeData from the specified map of raw messages. +func UnmarshalSchematicsWorkspaceRuntimeData(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspaceRuntimeData) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "engine_name", &obj.EngineName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "engine_version", &obj.EngineVersion) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "state_store_url", &obj.StateStoreURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "log_store_url", &obj.LogStoreURL) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspaceSearchResult : Result of schematics workspace search. +type SchematicsWorkspaceSearchResult struct { + // The offset (origin 0) of the first resource in this page of search results. + Offset *int64 `json:"offset,omitempty"` + + // The maximum number of resources returned in each page of search results. + Limit *int64 `json:"limit,omitempty"` + + // The overall total number of resources in the search result set. + TotalCount *int64 `json:"total_count,omitempty"` + + // The number of resources returned in this page of search results. + ResourceCount *int64 `json:"resource_count,omitempty"` + + // A URL for retrieving the first page of search results. + First *string `json:"first,omitempty"` + + // A URL for retrieving the last page of search results. + Last *string `json:"last,omitempty"` + + // A URL for retrieving the previous page of search results. + Prev *string `json:"prev,omitempty"` + + // A URL for retrieving the next page of search results. + Next *string `json:"next,omitempty"` + + // Resulting objects. + Resources []SchematicsWorkspace `json:"resources,omitempty"` +} + + +// UnmarshalSchematicsWorkspaceSearchResult unmarshals an instance of SchematicsWorkspaceSearchResult from the specified map of raw messages. +func UnmarshalSchematicsWorkspaceSearchResult(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspaceSearchResult) + err = core.UnmarshalPrimitive(m, "offset", &obj.Offset) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "limit", &obj.Limit) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "total_count", &obj.TotalCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_count", &obj.ResourceCount) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "first", &obj.First) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last", &obj.Last) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "prev", &obj.Prev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "next", &obj.Next) + if err != nil { + return + } + err = core.UnmarshalModel(m, "resources", &obj.Resources, UnmarshalSchematicsWorkspace) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspaceTemplateRepo : Template repository. +type SchematicsWorkspaceTemplateRepo struct { + // The fully qualified path of the tgz used in the deploy. + RepoURL *string `json:"repo_url,omitempty"` + + // Name of chart. + ChartName *string `json:"chart_name,omitempty"` + + // Name of script. + ScriptName *string `json:"script_name,omitempty"` + + // Name of uninstall script. + UninstallScriptName *string `json:"uninstall_script_name,omitempty"` + + // Name of folder. + FolderName *string `json:"folder_name,omitempty"` + + // Digest of project. + RepoShaValue *string `json:"repo_sha_value,omitempty"` +} + + +// UnmarshalSchematicsWorkspaceTemplateRepo unmarshals an instance of SchematicsWorkspaceTemplateRepo from the specified map of raw messages. +func UnmarshalSchematicsWorkspaceTemplateRepo(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspaceTemplateRepo) + err = core.UnmarshalPrimitive(m, "repo_url", &obj.RepoURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "chart_name", &obj.ChartName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "script_name", &obj.ScriptName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "uninstall_script_name", &obj.UninstallScriptName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "folder_name", &obj.FolderName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "repo_sha_value", &obj.RepoShaValue) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SchematicsWorkspaceWorkspaceStatus : Workspace frozen/locked status. +type SchematicsWorkspaceWorkspaceStatus struct { + // Workspace frozen state. + Frozen *bool `json:"frozen,omitempty"` + + // Workspace locked state. + Locked *bool `json:"locked,omitempty"` +} + + +// UnmarshalSchematicsWorkspaceWorkspaceStatus unmarshals an instance of SchematicsWorkspaceWorkspaceStatus from the specified map of raw messages. +func UnmarshalSchematicsWorkspaceWorkspaceStatus(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SchematicsWorkspaceWorkspaceStatus) + err = core.UnmarshalPrimitive(m, "frozen", &obj.Frozen) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "locked", &obj.Locked) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// Script : Script information. +type Script struct { + // Instruction on step and by whom (role) that are needed to take place to prepare the target for installing this + // version. + Instructions *string `json:"instructions,omitempty"` + + // Optional script that needs to be run post any pre-condition script. + Script *string `json:"script,omitempty"` + + // Optional iam permissions that are required on the target cluster to run this script. + ScriptPermission *string `json:"script_permission,omitempty"` + + // Optional script that if run will remove the installed version. + DeleteScript *string `json:"delete_script,omitempty"` + + // Optional value indicating if this script is scoped to a namespace or the entire cluster. + Scope *string `json:"scope,omitempty"` +} + + +// UnmarshalScript unmarshals an instance of Script from the specified map of raw messages. +func UnmarshalScript(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Script) + err = core.UnmarshalPrimitive(m, "instructions", &obj.Instructions) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "script", &obj.Script) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "script_permission", &obj.ScriptPermission) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "delete_script", &obj.DeleteScript) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "scope", &obj.Scope) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SearchLicenseOfferingsOptions : The SearchLicenseOfferings options. +type SearchLicenseOfferingsOptions struct { + // query, for now only "q=entitlement_key:" is supported. + Q *string `json:"q" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewSearchLicenseOfferingsOptions : Instantiate SearchLicenseOfferingsOptions +func (*CatalogManagementV1) NewSearchLicenseOfferingsOptions(q string) *SearchLicenseOfferingsOptions { + return &SearchLicenseOfferingsOptions{ + Q: core.StringPtr(q), + } +} + +// SetQ : Allow user to set Q +func (options *SearchLicenseOfferingsOptions) SetQ(q string) *SearchLicenseOfferingsOptions { + options.Q = core.StringPtr(q) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *SearchLicenseOfferingsOptions) SetHeaders(param map[string]string) *SearchLicenseOfferingsOptions { + options.Headers = param + return options +} + +// SearchLicenseVersionsOptions : The SearchLicenseVersions options. +type SearchLicenseVersionsOptions struct { + // query, for now only "q=entitlement_key:" is supported. + Q *string `json:"q" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewSearchLicenseVersionsOptions : Instantiate SearchLicenseVersionsOptions +func (*CatalogManagementV1) NewSearchLicenseVersionsOptions(q string) *SearchLicenseVersionsOptions { + return &SearchLicenseVersionsOptions{ + Q: core.StringPtr(q), + } +} + +// SetQ : Allow user to set Q +func (options *SearchLicenseVersionsOptions) SetQ(q string) *SearchLicenseVersionsOptions { + options.Q = core.StringPtr(q) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *SearchLicenseVersionsOptions) SetHeaders(param map[string]string) *SearchLicenseVersionsOptions { + options.Headers = param + return options +} + +// State : Offering state. +type State struct { + // one of: new, validated, account-published, ibm-published, public-published. + Current *string `json:"current,omitempty"` + + // Date and time of current request. + CurrentEntered *strfmt.DateTime `json:"current_entered,omitempty"` + + // one of: new, validated, account-published, ibm-published, public-published. + Pending *string `json:"pending,omitempty"` + + // Date and time of pending request. + PendingRequested *strfmt.DateTime `json:"pending_requested,omitempty"` + + // one of: new, validated, account-published, ibm-published, public-published. + Previous *string `json:"previous,omitempty"` +} + + +// UnmarshalState unmarshals an instance of State from the specified map of raw messages. +func UnmarshalState(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(State) + err = core.UnmarshalPrimitive(m, "current", &obj.Current) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "current_entered", &obj.CurrentEntered) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "pending", &obj.Pending) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "pending_requested", &obj.PendingRequested) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "previous", &obj.Previous) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SyndicationAuthorization : Feature information. +type SyndicationAuthorization struct { + // Array of syndicated namespaces. + Token *string `json:"token,omitempty"` + + // Date and time last updated. + LastRun *strfmt.DateTime `json:"last_run,omitempty"` +} + + +// UnmarshalSyndicationAuthorization unmarshals an instance of SyndicationAuthorization from the specified map of raw messages. +func UnmarshalSyndicationAuthorization(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SyndicationAuthorization) + err = core.UnmarshalPrimitive(m, "token", &obj.Token) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last_run", &obj.LastRun) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SyndicationCluster : Feature information. +type SyndicationCluster struct { + // Cluster region. + Region *string `json:"region,omitempty"` + + // Cluster ID. + ID *string `json:"id,omitempty"` + + // Cluster name. + Name *string `json:"name,omitempty"` + + // Resource group ID. + ResourceGroupName *string `json:"resource_group_name,omitempty"` + + // Syndication type. + Type *string `json:"type,omitempty"` + + // Syndicated namespaces. + Namespaces []string `json:"namespaces,omitempty"` + + // Syndicated to all namespaces on cluster. + AllNamespaces *bool `json:"all_namespaces,omitempty"` +} + + +// UnmarshalSyndicationCluster unmarshals an instance of SyndicationCluster from the specified map of raw messages. +func UnmarshalSyndicationCluster(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SyndicationCluster) + err = core.UnmarshalPrimitive(m, "region", &obj.Region) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "name", &obj.Name) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "resource_group_name", &obj.ResourceGroupName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "type", &obj.Type) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "namespaces", &obj.Namespaces) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "all_namespaces", &obj.AllNamespaces) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SyndicationHistory : Feature information. +type SyndicationHistory struct { + // Array of syndicated namespaces. + Namespaces []string `json:"namespaces,omitempty"` + + // Array of syndicated namespaces. + Clusters []SyndicationCluster `json:"clusters,omitempty"` + + // Date and time last syndicated. + LastRun *strfmt.DateTime `json:"last_run,omitempty"` +} + + +// UnmarshalSyndicationHistory unmarshals an instance of SyndicationHistory from the specified map of raw messages. +func UnmarshalSyndicationHistory(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SyndicationHistory) + err = core.UnmarshalPrimitive(m, "namespaces", &obj.Namespaces) + if err != nil { + return + } + err = core.UnmarshalModel(m, "clusters", &obj.Clusters, UnmarshalSyndicationCluster) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last_run", &obj.LastRun) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// SyndicationResource : Feature information. +type SyndicationResource struct { + // Remove related components. + RemoveRelatedComponents *bool `json:"remove_related_components,omitempty"` + + // Syndication clusters. + Clusters []SyndicationCluster `json:"clusters,omitempty"` + + // Feature information. + History *SyndicationHistory `json:"history,omitempty"` + + // Feature information. + Authorization *SyndicationAuthorization `json:"authorization,omitempty"` +} + + +// UnmarshalSyndicationResource unmarshals an instance of SyndicationResource from the specified map of raw messages. +func UnmarshalSyndicationResource(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(SyndicationResource) + err = core.UnmarshalPrimitive(m, "remove_related_components", &obj.RemoveRelatedComponents) + if err != nil { + return + } + err = core.UnmarshalModel(m, "clusters", &obj.Clusters, UnmarshalSyndicationCluster) + if err != nil { + return + } + err = core.UnmarshalModel(m, "history", &obj.History, UnmarshalSyndicationHistory) + if err != nil { + return + } + err = core.UnmarshalModel(m, "authorization", &obj.Authorization, UnmarshalSyndicationAuthorization) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// UpdateCatalogAccountOptions : The UpdateCatalogAccount options. +type UpdateCatalogAccountOptions struct { + // Account identification. + ID *string `json:"id,omitempty"` + + // Filters for account and catalog filters. + AccountFilters *Filters `json:"account_filters,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewUpdateCatalogAccountOptions : Instantiate UpdateCatalogAccountOptions +func (*CatalogManagementV1) NewUpdateCatalogAccountOptions() *UpdateCatalogAccountOptions { + return &UpdateCatalogAccountOptions{} +} + +// SetID : Allow user to set ID +func (options *UpdateCatalogAccountOptions) SetID(id string) *UpdateCatalogAccountOptions { + options.ID = core.StringPtr(id) + return options +} + +// SetAccountFilters : Allow user to set AccountFilters +func (options *UpdateCatalogAccountOptions) SetAccountFilters(accountFilters *Filters) *UpdateCatalogAccountOptions { + options.AccountFilters = accountFilters + return options +} + +// SetHeaders : Allow user to set Headers +func (options *UpdateCatalogAccountOptions) SetHeaders(param map[string]string) *UpdateCatalogAccountOptions { + options.Headers = param + return options +} + +// UpdateOfferingIbmOptions : The UpdateOfferingIbm options. +type UpdateOfferingIbmOptions struct { + // Catalog identifier. + CatalogIdentifier *string `json:"catalog_identifier" validate:"required"` + + // Offering identification. + OfferingID *string `json:"offering_id" validate:"required"` + + // Type of approval, ibm or public. + ApprovalType *string `json:"approval_type" validate:"required"` + + // Approve (true) or disapprove (false). + Approved *string `json:"approved" validate:"required"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// Constants associated with the UpdateOfferingIbmOptions.ApprovalType property. +// Type of approval, ibm or public. +const ( + UpdateOfferingIbmOptions_ApprovalType_Ibm = "ibm" + UpdateOfferingIbmOptions_ApprovalType_Public = "public" +) + +// Constants associated with the UpdateOfferingIbmOptions.Approved property. +// Approve (true) or disapprove (false). +const ( + UpdateOfferingIbmOptions_Approved_False = "false" + UpdateOfferingIbmOptions_Approved_True = "true" +) + +// NewUpdateOfferingIbmOptions : Instantiate UpdateOfferingIbmOptions +func (*CatalogManagementV1) NewUpdateOfferingIbmOptions(catalogIdentifier string, offeringID string, approvalType string, approved string) *UpdateOfferingIbmOptions { + return &UpdateOfferingIbmOptions{ + CatalogIdentifier: core.StringPtr(catalogIdentifier), + OfferingID: core.StringPtr(offeringID), + ApprovalType: core.StringPtr(approvalType), + Approved: core.StringPtr(approved), + } +} + +// SetCatalogIdentifier : Allow user to set CatalogIdentifier +func (options *UpdateOfferingIbmOptions) SetCatalogIdentifier(catalogIdentifier string) *UpdateOfferingIbmOptions { + options.CatalogIdentifier = core.StringPtr(catalogIdentifier) + return options +} + +// SetOfferingID : Allow user to set OfferingID +func (options *UpdateOfferingIbmOptions) SetOfferingID(offeringID string) *UpdateOfferingIbmOptions { + options.OfferingID = core.StringPtr(offeringID) + return options +} + +// SetApprovalType : Allow user to set ApprovalType +func (options *UpdateOfferingIbmOptions) SetApprovalType(approvalType string) *UpdateOfferingIbmOptions { + options.ApprovalType = core.StringPtr(approvalType) + return options +} + +// SetApproved : Allow user to set Approved +func (options *UpdateOfferingIbmOptions) SetApproved(approved string) *UpdateOfferingIbmOptions { + options.Approved = core.StringPtr(approved) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *UpdateOfferingIbmOptions) SetHeaders(param map[string]string) *UpdateOfferingIbmOptions { + options.Headers = param + return options +} + +// Validation : Validation response. +type Validation struct { + // Date and time of last successful validation. + Validated *strfmt.DateTime `json:"validated,omitempty"` + + // Date and time of last validation was requested. + Requested *strfmt.DateTime `json:"requested,omitempty"` + + // Current validation state - , in_progress, valid, invalid, expired. + State *string `json:"state,omitempty"` + + // Last operation (e.g. submit_deployment, generate_installer, install_offering. + LastOperation *string `json:"last_operation,omitempty"` + + // Validation target information (e.g. cluster_id, region, namespace, etc). Values will vary by Content type. + Target interface{} `json:"target,omitempty"` +} + + +// UnmarshalValidation unmarshals an instance of Validation from the specified map of raw messages. +func UnmarshalValidation(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Validation) + err = core.UnmarshalPrimitive(m, "validated", &obj.Validated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "requested", &obj.Requested) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "state", &obj.State) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "last_operation", &obj.LastOperation) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "target", &obj.Target) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// ValidationInstallOptions : The ValidationInstall options. +type ValidationInstallOptions struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocID *string `json:"version_loc_id" validate:"required"` + + // IAM Refresh token. + XAuthRefreshToken *string `json:"X-Auth-Refresh-Token" validate:"required"` + + // Cluster ID. + ClusterID *string `json:"cluster_id,omitempty"` + + // Cluster region. + Region *string `json:"region,omitempty"` + + // Kube namespace. + Namespace *string `json:"namespace,omitempty"` + + // Object containing Helm chart override values. + OverrideValues interface{} `json:"override_values,omitempty"` + + // Entitlement API Key for this offering. + EntitlementApikey *string `json:"entitlement_apikey,omitempty"` + + // Schematics workspace configuration. + Schematics *DeployRequestBodySchematics `json:"schematics,omitempty"` + + // Script. + Script *string `json:"script,omitempty"` + + // Script ID. + ScriptID *string `json:"script_id,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocatorID *string `json:"version_locator_id,omitempty"` + + // VCenter ID. + VcenterID *string `json:"vcenter_id,omitempty"` + + // VCenter Password. + VcenterPassword *string `json:"vcenter_password,omitempty"` + + // VCenter Location. + VcenterLocation *string `json:"vcenter_location,omitempty"` + + // Allows users to set headers on API requests + Headers map[string]string +} + +// NewValidationInstallOptions : Instantiate ValidationInstallOptions +func (*CatalogManagementV1) NewValidationInstallOptions(versionLocID string, xAuthRefreshToken string) *ValidationInstallOptions { + return &ValidationInstallOptions{ + VersionLocID: core.StringPtr(versionLocID), + XAuthRefreshToken: core.StringPtr(xAuthRefreshToken), + } +} + +// SetVersionLocID : Allow user to set VersionLocID +func (options *ValidationInstallOptions) SetVersionLocID(versionLocID string) *ValidationInstallOptions { + options.VersionLocID = core.StringPtr(versionLocID) + return options +} + +// SetXAuthRefreshToken : Allow user to set XAuthRefreshToken +func (options *ValidationInstallOptions) SetXAuthRefreshToken(xAuthRefreshToken string) *ValidationInstallOptions { + options.XAuthRefreshToken = core.StringPtr(xAuthRefreshToken) + return options +} + +// SetClusterID : Allow user to set ClusterID +func (options *ValidationInstallOptions) SetClusterID(clusterID string) *ValidationInstallOptions { + options.ClusterID = core.StringPtr(clusterID) + return options +} + +// SetRegion : Allow user to set Region +func (options *ValidationInstallOptions) SetRegion(region string) *ValidationInstallOptions { + options.Region = core.StringPtr(region) + return options +} + +// SetNamespace : Allow user to set Namespace +func (options *ValidationInstallOptions) SetNamespace(namespace string) *ValidationInstallOptions { + options.Namespace = core.StringPtr(namespace) + return options +} + +// SetOverrideValues : Allow user to set OverrideValues +func (options *ValidationInstallOptions) SetOverrideValues(overrideValues interface{}) *ValidationInstallOptions { + options.OverrideValues = overrideValues + return options +} + +// SetEntitlementApikey : Allow user to set EntitlementApikey +func (options *ValidationInstallOptions) SetEntitlementApikey(entitlementApikey string) *ValidationInstallOptions { + options.EntitlementApikey = core.StringPtr(entitlementApikey) + return options +} + +// SetSchematics : Allow user to set Schematics +func (options *ValidationInstallOptions) SetSchematics(schematics *DeployRequestBodySchematics) *ValidationInstallOptions { + options.Schematics = schematics + return options +} + +// SetScript : Allow user to set Script +func (options *ValidationInstallOptions) SetScript(script string) *ValidationInstallOptions { + options.Script = core.StringPtr(script) + return options +} + +// SetScriptID : Allow user to set ScriptID +func (options *ValidationInstallOptions) SetScriptID(scriptID string) *ValidationInstallOptions { + options.ScriptID = core.StringPtr(scriptID) + return options +} + +// SetVersionLocatorID : Allow user to set VersionLocatorID +func (options *ValidationInstallOptions) SetVersionLocatorID(versionLocatorID string) *ValidationInstallOptions { + options.VersionLocatorID = core.StringPtr(versionLocatorID) + return options +} + +// SetVcenterID : Allow user to set VcenterID +func (options *ValidationInstallOptions) SetVcenterID(vcenterID string) *ValidationInstallOptions { + options.VcenterID = core.StringPtr(vcenterID) + return options +} + +// SetVcenterPassword : Allow user to set VcenterPassword +func (options *ValidationInstallOptions) SetVcenterPassword(vcenterPassword string) *ValidationInstallOptions { + options.VcenterPassword = core.StringPtr(vcenterPassword) + return options +} + +// SetVcenterLocation : Allow user to set VcenterLocation +func (options *ValidationInstallOptions) SetVcenterLocation(vcenterLocation string) *ValidationInstallOptions { + options.VcenterLocation = core.StringPtr(vcenterLocation) + return options +} + +// SetHeaders : Allow user to set Headers +func (options *ValidationInstallOptions) SetHeaders(param map[string]string) *ValidationInstallOptions { + options.Headers = param + return options +} + +// Version : Offering version information. +type Version struct { + // Unique ID. + ID *string `json:"id,omitempty"` + + // Cloudant revision. + Rev *string `json:"_rev,omitempty"` + + // Version's CRN. + Crn *string `json:"crn,omitempty"` + + // Version of content type. + Version *string `json:"version,omitempty"` + + // hash of the content. + Sha *string `json:"sha,omitempty"` + + // The date and time this version was created. + Created *strfmt.DateTime `json:"created,omitempty"` + + // The date and time this version was last updated. + Updated *strfmt.DateTime `json:"updated,omitempty"` + + // Offering ID. + OfferingID *string `json:"offering_id,omitempty"` + + // Catalog ID. + CatalogID *string `json:"catalog_id,omitempty"` + + // Kind ID. + KindID *string `json:"kind_id,omitempty"` + + // List of tags associated with this catalog. + Tags []string `json:"tags,omitempty"` + + // Content's repo URL. + RepoURL *string `json:"repo_url,omitempty"` + + // Content's source URL (e.g git repo). + SourceURL *string `json:"source_url,omitempty"` + + // File used to on-board this version. + TgzURL *string `json:"tgz_url,omitempty"` + + // List of user solicited overrides. + Configuration []Configuration `json:"configuration,omitempty"` + + // Open ended metadata information. + Metadata interface{} `json:"metadata,omitempty"` + + // Validation response. + Validation *Validation `json:"validation,omitempty"` + + // Resource requirments for installation. + RequiredResources []Resource `json:"required_resources,omitempty"` + + // Denotes if single instance can be deployed to a given cluster. + SingleInstance *bool `json:"single_instance,omitempty"` + + // Script information. + Install *Script `json:"install,omitempty"` + + // Optional pre-install instructions. + PreInstall []Script `json:"pre_install,omitempty"` + + // Entitlement license info. + Entitlement *VersionEntitlement `json:"entitlement,omitempty"` + + // List of licenses the product was built with. + Licenses []License `json:"licenses,omitempty"` + + // If set, denotes a url to a YAML file with list of container images used by this version. + ImageManifestURL *string `json:"image_manifest_url,omitempty"` + + // read only field, indicating if this version is deprecated. + Deprecated *bool `json:"deprecated,omitempty"` + + // Version of the package used to create this version. + PackageVersion *string `json:"package_version,omitempty"` + + // Offering state. + State *State `json:"state,omitempty"` + + // A dotted value of `catalogID`.`versionID`. + VersionLocator *string `json:"version_locator,omitempty"` + + // Console URL. + ConsoleURL *string `json:"console_url,omitempty"` + + // Long description for version. + LongDescription *string `json:"long_description,omitempty"` + + // Whitelisted accounts for version. + WhitelistedAccounts []string `json:"whitelisted_accounts,omitempty"` +} + + +// UnmarshalVersion unmarshals an instance of Version from the specified map of raw messages. +func UnmarshalVersion(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(Version) + err = core.UnmarshalPrimitive(m, "id", &obj.ID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "_rev", &obj.Rev) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "crn", &obj.Crn) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version", &obj.Version) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "sha", &obj.Sha) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "created", &obj.Created) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "updated", &obj.Updated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "offering_id", &obj.OfferingID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "catalog_id", &obj.CatalogID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "kind_id", &obj.KindID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tags", &obj.Tags) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "repo_url", &obj.RepoURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "source_url", &obj.SourceURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "tgz_url", &obj.TgzURL) + if err != nil { + return + } + err = core.UnmarshalModel(m, "configuration", &obj.Configuration, UnmarshalConfiguration) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "metadata", &obj.Metadata) + if err != nil { + return + } + err = core.UnmarshalModel(m, "validation", &obj.Validation, UnmarshalValidation) + if err != nil { + return + } + err = core.UnmarshalModel(m, "required_resources", &obj.RequiredResources, UnmarshalResource) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "single_instance", &obj.SingleInstance) + if err != nil { + return + } + err = core.UnmarshalModel(m, "install", &obj.Install, UnmarshalScript) + if err != nil { + return + } + err = core.UnmarshalModel(m, "pre_install", &obj.PreInstall, UnmarshalScript) + if err != nil { + return + } + err = core.UnmarshalModel(m, "entitlement", &obj.Entitlement, UnmarshalVersionEntitlement) + if err != nil { + return + } + err = core.UnmarshalModel(m, "licenses", &obj.Licenses, UnmarshalLicense) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "image_manifest_url", &obj.ImageManifestURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "deprecated", &obj.Deprecated) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "package_version", &obj.PackageVersion) + if err != nil { + return + } + err = core.UnmarshalModel(m, "state", &obj.State, UnmarshalState) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version_locator", &obj.VersionLocator) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "console_url", &obj.ConsoleURL) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "long_description", &obj.LongDescription) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "whitelisted_accounts", &obj.WhitelistedAccounts) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// VersionEntitlement : Entitlement license info. +type VersionEntitlement struct { + // Provider name. + ProviderName *string `json:"provider_name,omitempty"` + + // Provider ID. + ProviderID *string `json:"provider_id,omitempty"` + + // Product ID. + ProductID *string `json:"product_id,omitempty"` + + // list of license entitlement part numbers, eg. D1YGZLL,D1ZXILL. + PartNumbers []string `json:"part_numbers,omitempty"` + + // Image repository name. + ImageRepoName *string `json:"image_repo_name,omitempty"` +} + + +// UnmarshalVersionEntitlement unmarshals an instance of VersionEntitlement from the specified map of raw messages. +func UnmarshalVersionEntitlement(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(VersionEntitlement) + err = core.UnmarshalPrimitive(m, "provider_name", &obj.ProviderName) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "provider_id", &obj.ProviderID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "product_id", &obj.ProductID) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "part_numbers", &obj.PartNumbers) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "image_repo_name", &obj.ImageRepoName) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} + +// VersionUpdateDescriptor : Indicates if the current version can be upgraded to the version identified by the descriptor. +type VersionUpdateDescriptor struct { + // A dotted value of `catalogID`.`versionID`. + VersionLocator *string `json:"version_locator,omitempty"` + + // the version number of this version. + Version *string `json:"version,omitempty"` + + // Offering state. + State *State `json:"state,omitempty"` + + // Resource requirments for installation. + RequiredResources []Resource `json:"required_resources,omitempty"` + + // Version of package. + PackageVersion *string `json:"package_version,omitempty"` + + // true if the current version can be upgraded to this version, false otherwise. + CanUpdate *bool `json:"can_update,omitempty"` + + // If can_update is false, this map will contain messages for each failed check, otherwise it will be omitted. + // Possible keys include nodes, cores, mem, disk, targetVersion, and install-permission-check. + Messages interface{} `json:"messages,omitempty"` +} + + +// UnmarshalVersionUpdateDescriptor unmarshals an instance of VersionUpdateDescriptor from the specified map of raw messages. +func UnmarshalVersionUpdateDescriptor(m map[string]json.RawMessage, result interface{}) (err error) { + obj := new(VersionUpdateDescriptor) + err = core.UnmarshalPrimitive(m, "version_locator", &obj.VersionLocator) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "version", &obj.Version) + if err != nil { + return + } + err = core.UnmarshalModel(m, "state", &obj.State, UnmarshalState) + if err != nil { + return + } + err = core.UnmarshalModel(m, "required_resources", &obj.RequiredResources, UnmarshalResource) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "package_version", &obj.PackageVersion) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "can_update", &obj.CanUpdate) + if err != nil { + return + } + err = core.UnmarshalPrimitive(m, "messages", &obj.Messages) + if err != nil { + return + } + reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj)) + return +} diff --git a/catalogmanagementv1/catalog_management_v1_integration_test.go b/catalogmanagementv1/catalog_management_v1_integration_test.go new file mode 100644 index 00000000..16d607fc --- /dev/null +++ b/catalogmanagementv1/catalog_management_v1_integration_test.go @@ -0,0 +1,1080 @@ +// +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 catalogmanagementv1_test + +import ( + "fmt" + "github.com/IBM/platform-services-go-sdk/catalogmanagementv1" + "os" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +const ( + externalConfigFile = "../catalog_mgmt.env" + expectedAccount = "67d27f28d43948b2b3bda9138f251a13" + expectedLabel = "integration-test" + expectedShortDesc = "test" + expectedURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s" + expectedOfferingsURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings" + fakeName = "bogus" + fakeVersionLocator = "bogus.bogus" + expectedOfferingName = "test-offering" + expectedOfferingURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings/%s" +) + +var ( + service *catalogmanagementv1.CatalogManagementV1 + configLoaded bool = false +) + +func shouldSkipTest() { + if !configLoaded { + Skip("External configuration is not available, skipping...") + } +} + +var _ = Describe("Catalog Management - Integration Tests", func() { + It("Successfully load the configuration", func() { + if _, err := os.Stat(externalConfigFile); err == nil { + if err = os.Setenv("IBM_CREDENTIALS_FILE", externalConfigFile); err == nil { + configLoaded = true + } + } + + if !configLoaded { + Skip("External configuration could not be loaded, skipping...") + } + }) + + It(`Successfully created CatalogManagementV1 service instance`, func() { + var err error + + shouldSkipTest() + + service, err = catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig( + &catalogmanagementv1.CatalogManagementV1Options{}, + ) + + Expect(err).To(BeNil()) + Expect(service).ToNot(BeNil()) + }) + + Describe("Run integration tests", func() { + JustBeforeEach(func() { + shouldSkipTest() + + listResult, _, _ := service.ListCatalogs(service.NewListCatalogsOptions()) + if listResult != nil && listResult.Resources != nil { + for _, resource := range listResult.Resources { + service.DeleteCatalog(service.NewDeleteCatalogOptions(*resource.ID)) + } + } + }) + + JustAfterEach(func() { + shouldSkipTest() + + listResult, _, _ := service.ListCatalogs(service.NewListCatalogsOptions()) + if listResult != nil && listResult.Resources != nil { + for _, resource := range listResult.Resources { + service.DeleteCatalog(service.NewDeleteCatalogOptions(*resource.ID)) + } + } + }) + + It("Get catalog account", func() { + shouldSkipTest() + + options := service.NewGetCatalogAccountOptions() + result, response, err := service.GetCatalogAccount(options) + + Expect(err).To(BeNil()) + Expect(response.StatusCode).To(Equal(200)) + Expect(*result.ID).To(Equal(expectedAccount)) + Expect(*result.AccountFilters.IncludeAll).To(BeTrue()) + Expect(len(result.AccountFilters.CategoryFilters)).To(BeZero()) + Expect(result.AccountFilters.IdFilters.Include).To(BeNil()) + Expect(result.AccountFilters.IdFilters.Exclude).To(BeNil()) + }) + + It("Get catalog account filters", func() { + shouldSkipTest() + + options := service.NewGetCatalogAccountFiltersOptions() + result, response, err := service.GetCatalogAccountFilters(options) + + Expect(err).To(BeNil()) + Expect(response.StatusCode).To(Equal(200)) + Expect(len(result.AccountFilters)).To(Equal(1)) + Expect(*result.AccountFilters[0].IncludeAll).To(BeTrue()) + Expect(len(result.AccountFilters[0].CategoryFilters)).To(BeZero()) + Expect(result.AccountFilters[0].IdFilters.Include).To(BeNil()) + Expect(result.AccountFilters[0].IdFilters.Exclude).To(BeNil()) + Expect(len(result.CatalogFilters)).To(BeZero()) + }) + + It("Get list of catalogs", func() { + const ( + expectedTotalCount int64 = 1 + expectedResourceCount = 1 + ) + + shouldSkipTest() + + createOptions := service.NewCreateCatalogOptions() + createOptions.SetLabel(expectedLabel) + createOptions.SetShortDescription(expectedShortDesc) + createResult, _, _ := service.CreateCatalog(createOptions) + + listOptions := service.NewListCatalogsOptions() + listResult, listResponse, err := service.ListCatalogs(listOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(*createResult.ID)) + + Expect(err).To(BeNil()) + Expect(listResponse.StatusCode).To(Equal(200)) + Expect(*listResult.Offset).To(BeZero()) + Expect(*listResult.Limit).To(BeZero()) + Expect(*listResult.TotalCount).To(Equal(expectedTotalCount)) + Expect(listResult.Last).To(BeNil()) + Expect(listResult.Prev).To(BeNil()) + Expect(listResult.Next).To(BeNil()) + Expect(len(listResult.Resources)).To(Equal(expectedResourceCount)) + + Expect(*listResult.Resources[0].Label).To(Equal(expectedLabel)) + Expect(*listResult.Resources[0].ShortDescription).To(Equal(expectedShortDesc)) + Expect(*listResult.Resources[0].URL).To(Equal(fmt.Sprintf(expectedURL, *createResult.ID))) + Expect(*listResult.Resources[0].OfferingsURL).To(Equal(fmt.Sprintf(expectedOfferingsURL, *createResult.ID))) + Expect(*listResult.Resources[0].OwningAccount).To(Equal(expectedAccount)) + Expect(*listResult.Resources[0].CatalogFilters.IncludeAll).To(BeFalse()) + Expect(len(listResult.Resources[0].CatalogFilters.CategoryFilters)).To(BeZero()) + Expect(listResult.Resources[0].CatalogFilters.IdFilters.Include).To(BeNil()) + Expect(listResult.Resources[0].CatalogFilters.IdFilters.Exclude).To(BeNil()) + }) + + It("Create a catalog", func() { + shouldSkipTest() + + options := service.NewCreateCatalogOptions() + options.SetLabel(expectedLabel) + options.SetShortDescription(expectedShortDesc) + result, response, err := service.CreateCatalog(options) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(*result.ID)) + + Expect(err).To(BeNil()) + Expect(response.StatusCode).To(Equal(201)) + Expect(*result.Label).To(Equal(expectedLabel)) + Expect(*result.ShortDescription).To(Equal(expectedShortDesc)) + Expect(*result.URL).To(Equal(fmt.Sprintf(expectedURL, *result.ID))) + Expect(*result.OfferingsURL).To(Equal(fmt.Sprintf(expectedOfferingsURL, *result.ID))) + Expect(*result.OwningAccount).To(Equal(expectedAccount)) + Expect(*result.CatalogFilters.IncludeAll).To(BeFalse()) + Expect(len(result.CatalogFilters.CategoryFilters)).To(BeZero()) + Expect(result.CatalogFilters.IdFilters.Include).To(BeNil()) + Expect(result.CatalogFilters.IdFilters.Exclude).To(BeNil()) + }) + + It("Get a catalog", func() { + shouldSkipTest() + + createOptions := service.NewCreateCatalogOptions() + createOptions.SetLabel(expectedLabel) + createOptions.SetShortDescription(expectedShortDesc) + createResult, _, err := service.CreateCatalog(createOptions) + + Expect(err).To(BeNil()) + + id := *createResult.ID + + getOptions := service.NewGetCatalogOptions(id) + getResult, getResponse, err := service.GetCatalog(getOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(id)) + + Expect(err).To(BeNil()) + Expect(getResponse.StatusCode).To(Equal(200)) + Expect(*getResult.Label).To(Equal(expectedLabel)) + Expect(*getResult.ShortDescription).To(Equal(expectedShortDesc)) + Expect(*getResult.URL).To(Equal(fmt.Sprintf(expectedURL, id))) + Expect(*getResult.OfferingsURL).To(Equal(fmt.Sprintf(expectedOfferingsURL, id))) + Expect(*getResult.OwningAccount).To(Equal(expectedAccount)) + Expect(*getResult.CatalogFilters.IncludeAll).To(BeFalse()) + Expect(len(getResult.CatalogFilters.CategoryFilters)).To(BeZero()) + Expect(getResult.CatalogFilters.IdFilters.Include).To(BeNil()) + Expect(getResult.CatalogFilters.IdFilters.Exclude).To(BeNil()) + }) + + It("Fail to get a catalog that does not exist", func() { + shouldSkipTest() + + id := fakeName + getOptions := service.NewGetCatalogOptions(id) + _, getResponse, err := service.GetCatalog(getOptions) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(404)) + }) + + It("Update a catalog", func() { + const ( + expectedLabelUpdated = "test2" + expectedShortDescUpdated = "integration-test-update" + ) + + shouldSkipTest() + + createOptions := service.NewCreateCatalogOptions() + createOptions.SetLabel(expectedLabel) + createOptions.SetShortDescription(expectedShortDesc) + createResult, _, err := service.CreateCatalog(createOptions) + + Expect(err).To(BeNil()) + + id := *createResult.ID + + replaceOptions := service.NewReplaceCatalogOptions(id) + replaceOptions.SetCatalogIdentifier(id) + replaceOptions.SetID(id) + replaceOptions.SetLabel(expectedLabelUpdated) + replaceOptions.SetShortDescription(expectedShortDescUpdated) + replaceResult, replaceResponse, err := service.ReplaceCatalog(replaceOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(id)) + + Expect(err).To(BeNil()) + Expect(replaceResponse.StatusCode).To(Equal(200)) + Expect(*replaceResult.Label).To(Equal(expectedLabelUpdated)) + Expect(*replaceResult.ShortDescription).To(Equal(expectedShortDescUpdated)) + Expect(*replaceResult.URL).To(Equal(fmt.Sprintf(expectedURL, id))) + Expect(*replaceResult.OfferingsURL).To(Equal(fmt.Sprintf(expectedOfferingsURL, id))) + Expect(*replaceResult.OwningAccount).To(Equal(expectedAccount)) + Expect(*replaceResult.CatalogFilters.IncludeAll).To(BeTrue()) + Expect(len(replaceResult.CatalogFilters.CategoryFilters)).To(BeZero()) + Expect(replaceResult.CatalogFilters.IdFilters.Include).To(BeNil()) + Expect(replaceResult.CatalogFilters.IdFilters.Exclude).To(BeNil()) + }) + + It("Fail to update a catalog that does not exist", func() { + shouldSkipTest() + + id := fakeName + replaceOptions := service.NewReplaceCatalogOptions(id) + replaceOptions.SetCatalogIdentifier(id) + replaceOptions.SetID(id) + _, replaceResponse, err := service.ReplaceCatalog(replaceOptions) + + Expect(err).ToNot(BeNil()) + Expect(replaceResponse.StatusCode).To(Equal(404)) + }) + + It("Delete a catalog", func() { + shouldSkipTest() + + createOptions := service.NewCreateCatalogOptions() + createOptions.SetLabel(expectedLabel) + createOptions.SetShortDescription(expectedShortDesc) + createResult, _, err := service.CreateCatalog(createOptions) + + Expect(err).To(BeNil()) + + id := *createResult.ID + + deleteResponse, deleteErr := service.DeleteCatalog(service.NewDeleteCatalogOptions(id)) + Expect(deleteErr).To(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(200)) + + getOptions := service.NewGetCatalogOptions(id) + _, getResponse, getErr := service.GetCatalog(getOptions) + + Expect(getErr).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(403)) + }) + + It("Fail to delete a catalog that does not exist", func() { + shouldSkipTest() + + id := fakeName + deleteResponse, deleteErr := service.DeleteCatalog(service.NewDeleteCatalogOptions(id)) + + Expect(deleteErr).To(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(200)) + }) + + It("Create an offering", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewCreateOfferingOptions(catalogID) + offeringOptions.SetName(expectedOfferingName) + offeringOptions.SetLabel(expectedLabel) + offeringResult, offeringResponse, err := service.CreateOffering(offeringOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + Expect(offeringResponse.StatusCode).To(Equal(201)) + Expect(*offeringResult.Name).To(Equal(expectedOfferingName)) + Expect(*offeringResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*offeringResult.Label).To(Equal(expectedLabel)) + }) + + It("Get an offering", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewCreateOfferingOptions(catalogID) + offeringOptions.SetName(expectedOfferingName) + offeringOptions.SetLabel(expectedLabel) + offeringResult, _, err := service.CreateOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + getOptions := service.NewGetOfferingOptions(catalogID, offeringID) + getResult, getResponse, err := service.GetOffering(getOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(getResponse.StatusCode).To(Equal(200)) + Expect(*getResult.Name).To(Equal(expectedOfferingName)) + Expect(*getResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*getResult.Label).To(Equal(expectedLabel)) + }) + + It("Fail to get an offering that does not exist", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + offeringID := fakeName + + getOptions := service.NewGetOfferingOptions(catalogID, offeringID) + _, getResponse, err := service.GetOffering(getOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(404)) + + _, getResponse, err = service.GetOffering(getOptions) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(403)) + }) + + It("List offerings", func() { + const ( + expectedLimit int64 = 100 + expectedTotalCount int64 = 1 + expectedResourceCount int64 = 1 + expectedResouceLen = 1 + expectedFirst = "/api/v1-beta/catalogs/%s/offerings?limit=100&sort=label" + expectedLast = "/api/v1-beta/catalogs/%s/offerings?limit=100&sort=label" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewCreateOfferingOptions(catalogID) + offeringOptions.SetName(expectedOfferingName) + offeringOptions.SetLabel(expectedLabel) + offeringResult, _, err := service.CreateOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + listOptions := service.NewListOfferingsOptions(catalogID) + listResult, listResponse, err := service.ListOfferings(listOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(listResponse.StatusCode).To(Equal(200)) + Expect(*listResult.Offset).To(BeZero()) + Expect(*listResult.Limit).To(Equal(expectedLimit)) + Expect(*listResult.TotalCount).To(Equal(expectedTotalCount)) + Expect(*listResult.ResourceCount).To(Equal(expectedResourceCount)) + Expect(*listResult.First).To(Equal(fmt.Sprintf(expectedFirst, catalogID))) + Expect(*listResult.Last).To(Equal(fmt.Sprintf(expectedLast, catalogID))) + Expect(len(listResult.Resources)).To(Equal(expectedResouceLen)) + + Expect(*listResult.Resources[0].ID).To(Equal(offeringID)) + Expect(*listResult.Resources[0].URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*listResult.Resources[0].Label).To(Equal(expectedLabel)) + Expect(*listResult.Resources[0].Name).To(Equal(expectedOfferingName)) + Expect(*listResult.Resources[0].CatalogID).To(Equal(catalogID)) + Expect(*listResult.Resources[0].CatalogName).To(Equal(expectedLabel)) + + }) + + It("Delete an offering", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewCreateOfferingOptions(catalogID) + offeringOptions.SetName(expectedOfferingName) + offeringOptions.SetLabel(expectedLabel) + offeringResult, _, err := service.CreateOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + deleteResponse, err := service.DeleteOffering(service.NewDeleteOfferingOptions(catalogID, offeringID)) + Expect(err).To(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(200)) + + _, getResponse, err := service.GetOffering(service.NewGetOfferingOptions(catalogID, offeringID)) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(404)) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + }) + + It("Fail to delete an offering that does not exist", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + offeringID := fakeName + + deleteResponse, err := service.DeleteOffering(service.NewDeleteOfferingOptions(catalogID, offeringID)) + Expect(err).To(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(200)) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + deleteResponse, err = service.DeleteOffering(service.NewDeleteOfferingOptions(catalogID, offeringID)) + Expect(err).ToNot(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(403)) + }) + + It("Update an offering", func() { + const ( + expectedLabelUpdate = "test-update" + expectedShortDesc = "test-desc" + expectedShortDescUpdate = "test-desc-update" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewCreateOfferingOptions(catalogID) + offeringOptions.SetName(expectedOfferingName) + offeringOptions.SetLabel(expectedLabel) + offeringOptions.SetShortDescription(expectedShortDesc) + offeringResult, _, err := service.CreateOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + rev := *offeringResult.Rev + + updateOptions := service.NewReplaceOfferingOptions(catalogID, offeringID) + updateOptions.SetID(offeringID) + updateOptions.SetLabel(expectedLabelUpdate) + updateOptions.SetShortDescription(expectedShortDescUpdate) + updateOptions.SetRev(rev) + updateResult, updateResponse, err := service.ReplaceOffering(updateOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(updateResponse.StatusCode).To(Equal(200)) + Expect(*updateResult.ShortDescription).To(Equal(expectedShortDescUpdate)) + Expect(*updateResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*updateResult.Label).To(Equal(expectedLabelUpdate)) + }) + + It("Fail to update an offering that does not exist", func() { + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + offeringID := fakeName + rev := fakeName + + updateOptions := service.NewReplaceOfferingOptions(catalogID, offeringID) + updateOptions.SetID(offeringID) + updateOptions.SetRev(rev) + _, updateResponse, err := service.ReplaceOffering(updateOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).ToNot(BeNil()) + Expect(updateResponse.StatusCode).To(Equal(404)) + + _, updateResponse, err = service.ReplaceOffering(updateOptions) + Expect(err).ToNot(BeNil()) + Expect(updateResponse.StatusCode).To(Equal(403)) + }) + + It("Get list of offerings for consumption", func() { + shouldSkipTest() + + options := service.NewGetConsumptionOfferingsOptions() + result, response, err := service.GetConsumptionOfferings(options) + + Expect(err).To(BeNil()) + Expect(response.StatusCode).To(Equal(200)) + Expect(*result.Offset).To(BeZero()) + Expect(*result.Limit).To(BeZero()) + Expect(*result.TotalCount).ToNot(BeZero()) + Expect(result.Last).To(BeNil()) + Expect(result.Prev).To(BeNil()) + Expect(result.Next).To(BeNil()) + Expect(len(result.Resources)).ToNot(BeZero()) + }) + + It("Import an offering", func() { + const ( + expectedOfferingName = "jenkins-operator" + expectedOfferingLabel = "Jenkins Operator" + expectedOfferingTargetKind = "roks" + expectedOfferingVersion = "0.4.0" + expectedOfferingVersions = 1 + expectedOfferingKinds = 1 + expectedOfferingShortDesc = "Kubernetes native operator which fully manages Jenkins on Openshift." + expectedOfferingURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings/%s" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, offeringResponse, err := service.ImportOffering(offeringOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + Expect(offeringResponse.StatusCode).To(Equal(201)) + Expect(*offeringResult.Name).To(Equal(expectedOfferingName)) + Expect(*offeringResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*offeringResult.Label).To(Equal(expectedOfferingLabel)) + Expect(*offeringResult.ShortDescription).To(Equal(expectedOfferingShortDesc)) + Expect(*offeringResult.CatalogName).To(Equal(expectedLabel)) + Expect(*offeringResult.CatalogID).To(Equal(catalogID)) + Expect(len(offeringResult.Kinds)).To(Equal(expectedOfferingKinds)) + Expect(*offeringResult.Kinds[0].TargetKind).To(Equal(expectedOfferingTargetKind)) + Expect(len(offeringResult.Kinds[0].Versions)).To(Equal(expectedOfferingVersions)) + Expect(*offeringResult.Kinds[0].Versions[0].Version).To(Equal(expectedOfferingVersion)) + Expect(*offeringResult.Kinds[0].Versions[0].TgzURL).To(Equal(expectedOfferingZipURL)) + }) + + It("Import new version to offering", func() { + const ( + expectedOfferingName = "jenkins-operator" + expectedOfferingLabel = "Jenkins Operator" + expectedOfferingTargetKind = "roks" + expectedOfferingKinds = 1 + expectedOfferingVersions = 2 + expectedOfferingVersion1 = "0.3.31" + expectedOfferingVersion2 = "0.4.0" + expectedOfferingShortDesc = "Kubernetes native operator which fully manages Jenkins on Openshift." + expectedOfferingURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings/%s" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.3.31/jenkins-operator.v0.3.31.clusterserviceversion.yaml" + expectedOfferingZipURLUpdate = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + importOptions := service.NewImportOfferingVersionOptions(catalogID, offeringID, expectedOfferingZipURLUpdate) + importResult, importResponse, err := service.ImportOfferingVersion(importOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(importResponse.StatusCode).To(Equal(201)) + Expect(*importResult.Name).To(Equal(expectedOfferingName)) + Expect(*importResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*importResult.Label).To(Equal(expectedOfferingLabel)) + Expect(*importResult.ShortDescription).To(Equal(expectedOfferingShortDesc)) + Expect(*importResult.CatalogName).To(Equal(expectedLabel)) + Expect(*importResult.CatalogID).To(Equal(catalogID)) + Expect(len(importResult.Kinds)).To(Equal(expectedOfferingKinds)) + Expect(*importResult.Kinds[0].TargetKind).To(Equal(expectedOfferingTargetKind)) + Expect(len(importResult.Kinds[0].Versions)).To(Equal(expectedOfferingVersions)) + Expect(*importResult.Kinds[0].Versions[0].Version).To(Equal(expectedOfferingVersion1)) + Expect(*importResult.Kinds[0].Versions[0].TgzURL).To(Equal(expectedOfferingZipURL)) + Expect(*importResult.Kinds[0].Versions[1].Version).To(Equal(expectedOfferingVersion2)) + Expect(*importResult.Kinds[0].Versions[1].TgzURL).To(Equal(expectedOfferingZipURLUpdate)) + }) + + It("Fail to import new version to offering that does not exist", func() { + const expectedOfferingZipURLUpdate = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringID := fakeName + + importOptions := service.NewImportOfferingVersionOptions(catalogID, offeringID, expectedOfferingZipURLUpdate) + _, importResponse, err := service.ImportOfferingVersion(importOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).ToNot(BeNil()) + Expect(importResponse.StatusCode).To(Equal(404)) + + _, importResponse, err = service.ImportOfferingVersion(importOptions) + Expect(err).ToNot(BeNil()) + Expect(importResponse.StatusCode).To(Equal(403)) + }) + + It("Reload an offering", func() { + const ( + expectedOfferingName = "jenkins-operator" + expectedOfferingLabel = "Jenkins Operator" + expectedOfferingTargetKind = "roks" + expectedOfferingVersion = "0.4.0" + expectedOfferingVersions = 1 + expectedOfferingKinds = 1 + expectedOfferingShortDesc = "Kubernetes native operator which fully manages Jenkins on Openshift." + expectedOfferingURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings/%s" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + + reloadOptions := service.NewReloadOfferingOptions(catalogID, offeringID, expectedOfferingZipURL, expectedOfferingVersion) + reloadResult, reloadResponse, err := service.ReloadOffering(reloadOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(reloadResponse.StatusCode).To(Equal(200)) + Expect(*reloadResult.Name).To(Equal(expectedOfferingName)) + Expect(*reloadResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*reloadResult.Label).To(Equal(expectedOfferingLabel)) + Expect(*reloadResult.ShortDescription).To(Equal(expectedOfferingShortDesc)) + Expect(*reloadResult.CatalogName).To(Equal(expectedLabel)) + Expect(*reloadResult.CatalogID).To(Equal(catalogID)) + Expect(len(reloadResult.Kinds)).To(Equal(expectedOfferingKinds)) + Expect(*reloadResult.Kinds[0].TargetKind).To(Equal(expectedOfferingTargetKind)) + Expect(len(reloadResult.Kinds[0].Versions)).To(Equal(expectedOfferingVersions)) + Expect(*reloadResult.Kinds[0].Versions[0].Version).To(Equal(expectedOfferingVersion)) + Expect(*reloadResult.Kinds[0].Versions[0].TgzURL).To(Equal(expectedOfferingZipURL)) + }) + + It("Fail to reload an offering that does not exist", func() { + const ( + expectedOfferingVersion = "0.4.0" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + offeringID := fakeName + + reloadOptions := service.NewReloadOfferingOptions(catalogID, offeringID, expectedOfferingZipURL, expectedOfferingVersion) + _, reloadResponse, err := service.ReloadOffering(reloadOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).ToNot(BeNil()) + Expect(reloadResponse.StatusCode).To(Equal(404)) + + _, reloadResponse, err = service.ReloadOffering(reloadOptions) + Expect(err).ToNot(BeNil()) + Expect(reloadResponse.StatusCode).To(Equal(403)) + }) + + It("Get a version", func() { + const ( + expectedOfferingName = "jenkins-operator" + expectedOfferingLabel = "Jenkins Operator" + expectedOfferingTargetKind = "roks" + expectedOfferingVersion = "0.4.0" + expectedOfferingVersions = 1 + expectedOfferingKinds = 1 + expectedOfferingShortDesc = "Kubernetes native operator which fully manages Jenkins on Openshift." + expectedOfferingURL = "https://cm.globalcatalog.test.cloud.ibm.com/api/v1-beta/catalogs/%s/offerings/%s" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + versionLocator := *offeringResult.Kinds[0].Versions[0].VersionLocator + + versionOptions := service.NewGetVersionOptions(versionLocator) + versionResult, versionResponse, err := service.GetVersion(versionOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(versionResponse.StatusCode).To(Equal(200)) + Expect(*versionResult.Name).To(Equal(expectedOfferingName)) + Expect(*versionResult.URL).To(Equal(fmt.Sprintf(expectedOfferingURL, catalogID, offeringID))) + Expect(*versionResult.Label).To(Equal(expectedOfferingLabel)) + Expect(*versionResult.ShortDescription).To(Equal(expectedOfferingShortDesc)) + Expect(*versionResult.CatalogName).To(Equal(expectedLabel)) + Expect(*versionResult.CatalogID).To(Equal(catalogID)) + Expect(len(versionResult.Kinds)).To(Equal(expectedOfferingKinds)) + Expect(*versionResult.Kinds[0].TargetKind).To(Equal(expectedOfferingTargetKind)) + Expect(len(versionResult.Kinds[0].Versions)).To(Equal(expectedOfferingVersions)) + Expect(*versionResult.Kinds[0].Versions[0].Version).To(Equal(expectedOfferingVersion)) + Expect(*versionResult.Kinds[0].Versions[0].TgzURL).To(Equal(expectedOfferingZipURL)) + }) + + It("Fail to get a version that does not exist", func() { + shouldSkipTest() + + versionOptions := service.NewGetVersionOptions(fakeVersionLocator) + _, versionResponse, err := service.GetVersion(versionOptions) + + Expect(err).ToNot(BeNil()) + Expect(versionResponse.StatusCode).To(Equal(404)) + }) + + It("Delete a version", func() { + const expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + versionLocator := *offeringResult.Kinds[0].Versions[0].VersionLocator + + deleteOptions := service.NewDeleteVersionOptions(versionLocator) + deleteResponse, err := service.DeleteVersion(deleteOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(200)) + }) + + It("Failed to delete a version that does not exist", func() { + shouldSkipTest() + + deleteOptions := service.NewDeleteVersionOptions(fakeVersionLocator) + deleteResponse, err := service.DeleteVersion(deleteOptions) + + Expect(err).ToNot(BeNil()) + Expect(deleteResponse.StatusCode).To(Equal(404)) + }) + + It("Get version about", func() { + const expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + versionLocator := *offeringResult.Kinds[0].Versions[0].VersionLocator + + getOptions := service.NewGetVersionAboutOptions(versionLocator) + getResult, getResponse, err := service.GetVersionAbout(getOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(getResponse.StatusCode).To(Equal(200)) + Expect(len(*getResult)).ToNot(BeZero()) + }) + + It("Fail to get version about for a version that does not exist", func() { + shouldSkipTest() + + getOptions := service.NewGetVersionAboutOptions(fakeVersionLocator) + _, getResponse, err := service.GetVersionAbout(getOptions) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(404)) + }) + + It("Get version updates", func() { + const ( + expectedOfferingUpdates = 1 + expectedOfferingVersion2 = "0.4.0" + expectedOfferingZipURL = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.3.31/jenkins-operator.v0.3.31.clusterserviceversion.yaml" + expectedOfferingZipURLUpdate = "https://github.com/operator-framework/community-operators/blob/master/community-operators/jenkins-operator/0.4.0/jenkins-operator.v0.4.0.clusterserviceversion.yaml" + ) + + shouldSkipTest() + + catalogOptions := service.NewCreateCatalogOptions() + catalogOptions.SetLabel(expectedLabel) + catalogResult, _, err := service.CreateCatalog(catalogOptions) + + Expect(err).To(BeNil()) + + catalogID := *catalogResult.ID + + offeringOptions := service.NewImportOfferingOptions(catalogID, expectedOfferingZipURL) + offeringResult, _, err := service.ImportOffering(offeringOptions) + + Expect(err).To(BeNil()) + + offeringID := *offeringResult.ID + versionLocator1 := *offeringResult.Kinds[0].Versions[0].VersionLocator + + importOptions := service.NewImportOfferingVersionOptions(catalogID, offeringID, expectedOfferingZipURLUpdate) + importResult, _, err := service.ImportOfferingVersion(importOptions) + + Expect(err).To(BeNil()) + + versionLocator2 := *importResult.Kinds[0].Versions[1].VersionLocator + + getOptions := service.NewGetVersionUpdatesOptions(versionLocator1) + getResult, getResponse, err := service.GetVersionUpdates(getOptions) + + service.DeleteCatalog(service.NewDeleteCatalogOptions(catalogID)) + + Expect(err).To(BeNil()) + Expect(getResponse.StatusCode).To(Equal(200)) + Expect(len(getResult)).To(Equal(expectedOfferingUpdates)) + Expect(*getResult[0].VersionLocator).To(Equal(versionLocator2)) + Expect(*getResult[0].Version).To(Equal(expectedOfferingVersion2)) + Expect(*getResult[0].PackageVersion).To(Equal(expectedOfferingVersion2)) + Expect(*getResult[0].CanUpdate).To(BeTrue()) + + }) + It("Fail to get version updates for version that does not exist", func() { + shouldSkipTest() + + getOptions := service.NewGetVersionUpdatesOptions(fakeVersionLocator) + _, getResponse, err := service.GetVersionUpdates(getOptions) + + Expect(err).ToNot(BeNil()) + Expect(getResponse.StatusCode).To(Equal(404)) + }) + + It("Get license providers", func() { + const ( + expectedResourceCount = 1 + expectedTotalResults int64 = 1 + expectedTotalPages int64 = 1 + expectedName = "IBM Passport Advantage" + expectedOfferingType = "content" + expectedCreateURL = "https://www.ibm.com/software/passportadvantage/aboutpassport.html" + expectedInfoURL = "https://www.ibm.com/software/passportadvantage/" + expectedURL = "/v1/licensing/license_providers/11cabc37-c4a7-410b-894d-8cb3586423f1" + expectedState = "active" + ) + + shouldSkipTest() + + getOptions := service.NewGetLicenseProvidersOptions() + getResult, getResponse, err := service.GetLicenseProviders(getOptions) + + Expect(err).To(BeNil()) + Expect(getResponse.StatusCode).To(Equal(200)) + Expect(len(getResult.Resources)).To(Equal(expectedResourceCount)) + Expect(*getResult.TotalResults).To(Equal(expectedTotalResults)) + Expect(*getResult.TotalPages).To(Equal(expectedTotalPages)) + Expect(*getResult.Resources[0].Name).To(Equal(expectedName)) + Expect(*getResult.Resources[0].OfferingType).To(Equal(expectedOfferingType)) + Expect(*getResult.Resources[0].CreateURL).To(Equal(expectedCreateURL)) + Expect(*getResult.Resources[0].InfoURL).To(Equal(expectedInfoURL)) + Expect(*getResult.Resources[0].URL).To(Equal(expectedURL)) + Expect(*getResult.Resources[0].State).To(Equal(expectedState)) + }) + + It("Get license entitlements", func() { + const ( + expectedResourceCount = 0 + expectedTotalResults int64 = 0 + expectedTotalPages int64 = 1 + ) + + shouldSkipTest() + + listOptions := service.NewListLicenseEntitlementsOptions() + listResult, listResponse, err := service.ListLicenseEntitlements(listOptions) + + Expect(err).To(BeNil()) + Expect(listResponse.StatusCode).To(Equal(200)) + Expect(len(listResult.Resources)).To(Equal(expectedResourceCount)) + Expect(*listResult.TotalResults).To(Equal(expectedTotalResults)) + Expect(*listResult.TotalPages).To(Equal(expectedTotalPages)) + }) + + It("Fail to search license versions", func() { + shouldSkipTest() + + searchOptions := service.NewSearchLicenseVersionsOptions(fakeName) + searchResponse, err := service.SearchLicenseVersions(searchOptions) + + Expect(err).ToNot(BeNil()) + Expect(searchResponse.StatusCode).To(Equal(403)) + }) + + It("Fail to search license offerings", func() { + shouldSkipTest() + + searchOptions := service.NewSearchLicenseOfferingsOptions(fakeName) + searchResponse, err := service.SearchLicenseOfferings(searchOptions) + + Expect(err).ToNot(BeNil()) + Expect(searchResponse.StatusCode).To(Equal(403)) + }) + }) +}) diff --git a/catalogmanagementv1/catalog_management_v1_suite_test.go b/catalogmanagementv1/catalog_management_v1_suite_test.go new file mode 100644 index 00000000..ac5d348c --- /dev/null +++ b/catalogmanagementv1/catalog_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 catalogmanagementv1_test + +import ( + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + "testing" +) + +func TestCatalogManagementV1(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "CatalogManagementV1 Suite") +} diff --git a/catalogmanagementv1/catalog_management_v1_test.go b/catalogmanagementv1/catalog_management_v1_test.go new file mode 100644 index 00000000..b6ec5ae3 --- /dev/null +++ b/catalogmanagementv1/catalog_management_v1_test.go @@ -0,0 +1,10890 @@ +/** + * (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 catalogmanagementv1_test + +import ( + "bytes" + "fmt" + "github.com/IBM/go-sdk-core/v4/core" + "github.com/IBM/platform-services-go-sdk/catalogmanagementv1" + "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(`CatalogManagementV1`, func() { + var testServer *httptest.Server + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`GetCatalogAccount(getCatalogAccountOptions *GetCatalogAccountOptions) - Operation response error`, func() { + getCatalogAccountPath := "/catalogaccount" + 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(getCatalogAccountPath)) + 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 GetCatalogAccount with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogAccountOptions model + getCatalogAccountOptionsModel := new(catalogmanagementv1.GetCatalogAccountOptions) + getCatalogAccountOptionsModel.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.GetCatalogAccount(getCatalogAccountOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetCatalogAccount(getCatalogAccountOptions *GetCatalogAccountOptions)`, func() { + getCatalogAccountPath := "/catalogaccount" + 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(getCatalogAccountPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "account_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}}`) + })) + }) + It(`Invoke GetCatalogAccount successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetCatalogAccount(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetCatalogAccountOptions model + getCatalogAccountOptionsModel := new(catalogmanagementv1.GetCatalogAccountOptions) + getCatalogAccountOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetCatalogAccount(getCatalogAccountOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetCatalogAccount with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogAccountOptions model + getCatalogAccountOptionsModel := new(catalogmanagementv1.GetCatalogAccountOptions) + getCatalogAccountOptionsModel.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.GetCatalogAccount(getCatalogAccountOptionsModel) + 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(`UpdateCatalogAccount(updateCatalogAccountOptions *UpdateCatalogAccountOptions)`, func() { + updateCatalogAccountPath := "/catalogaccount" + 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(updateCatalogAccountPath)) + Expect(req.Method).To(Equal("PUT")) + res.WriteHeader(200) + })) + }) + It(`Invoke UpdateCatalogAccount successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.UpdateCatalogAccount(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the UpdateCatalogAccountOptions model + updateCatalogAccountOptionsModel := new(catalogmanagementv1.UpdateCatalogAccountOptions) + updateCatalogAccountOptionsModel.ID = core.StringPtr("testString") + updateCatalogAccountOptionsModel.AccountFilters = filtersModel + updateCatalogAccountOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.UpdateCatalogAccount(updateCatalogAccountOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke UpdateCatalogAccount with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the UpdateCatalogAccountOptions model + updateCatalogAccountOptionsModel := new(catalogmanagementv1.UpdateCatalogAccountOptions) + updateCatalogAccountOptionsModel.ID = core.StringPtr("testString") + updateCatalogAccountOptionsModel.AccountFilters = filtersModel + updateCatalogAccountOptionsModel.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.UpdateCatalogAccount(updateCatalogAccountOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetCatalogAccountFilters(getCatalogAccountFiltersOptions *GetCatalogAccountFiltersOptions) - Operation response error`, func() { + getCatalogAccountFiltersPath := "/catalogaccount/filters" + 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(getCatalogAccountFiltersPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["catalog"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetCatalogAccountFilters with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogAccountFiltersOptions model + getCatalogAccountFiltersOptionsModel := new(catalogmanagementv1.GetCatalogAccountFiltersOptions) + getCatalogAccountFiltersOptionsModel.Catalog = core.StringPtr("testString") + getCatalogAccountFiltersOptionsModel.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.GetCatalogAccountFilters(getCatalogAccountFiltersOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetCatalogAccountFilters(getCatalogAccountFiltersOptions *GetCatalogAccountFiltersOptions)`, func() { + getCatalogAccountFiltersPath := "/catalogaccount/filters" + 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(getCatalogAccountFiltersPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["catalog"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"account_filters": [{"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}], "catalog_filters": [{"catalog": {"id": "ID", "name": "Name"}, "filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}}]}`) + })) + }) + It(`Invoke GetCatalogAccountFilters successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetCatalogAccountFilters(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetCatalogAccountFiltersOptions model + getCatalogAccountFiltersOptionsModel := new(catalogmanagementv1.GetCatalogAccountFiltersOptions) + getCatalogAccountFiltersOptionsModel.Catalog = core.StringPtr("testString") + getCatalogAccountFiltersOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetCatalogAccountFilters(getCatalogAccountFiltersOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetCatalogAccountFilters with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogAccountFiltersOptions model + getCatalogAccountFiltersOptionsModel := new(catalogmanagementv1.GetCatalogAccountFiltersOptions) + getCatalogAccountFiltersOptionsModel.Catalog = core.StringPtr("testString") + getCatalogAccountFiltersOptionsModel.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.GetCatalogAccountFilters(getCatalogAccountFiltersOptionsModel) + 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(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`ListCatalogs(listCatalogsOptions *ListCatalogsOptions) - Operation response error`, func() { + listCatalogsPath := "/catalogs" + 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(listCatalogsPath)) + 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 ListCatalogs with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListCatalogsOptions model + listCatalogsOptionsModel := new(catalogmanagementv1.ListCatalogsOptions) + listCatalogsOptionsModel.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.ListCatalogs(listCatalogsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListCatalogs(listCatalogsOptions *ListCatalogsOptions)`, func() { + listCatalogsPath := "/catalogs" + 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(listCatalogsPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"id": "ID", "_rev": "Rev", "label": "Label", "short_description": "ShortDescription", "catalog_icon_url": "CatalogIconURL", "tags": ["Tags"], "url": "URL", "crn": "Crn", "offerings_url": "OfferingsURL", "features": [{"title": "Title", "description": "Description"}], "disabled": true, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "resource_group_id": "ResourceGroupID", "owning_account": "OwningAccount", "catalog_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "syndication_settings": {"remove_related_components": false, "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "history": {"namespaces": ["Namespaces"], "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "last_run": "2019-01-01T12:00:00"}, "authorization": {"token": "Token", "last_run": "2019-01-01T12:00:00"}}}]}`) + })) + }) + It(`Invoke ListCatalogs successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListCatalogs(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ListCatalogsOptions model + listCatalogsOptionsModel := new(catalogmanagementv1.ListCatalogsOptions) + listCatalogsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ListCatalogs(listCatalogsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ListCatalogs with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListCatalogsOptions model + listCatalogsOptionsModel := new(catalogmanagementv1.ListCatalogsOptions) + listCatalogsOptionsModel.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.ListCatalogs(listCatalogsOptionsModel) + 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(`CreateCatalog(createCatalogOptions *CreateCatalogOptions) - Operation response error`, func() { + createCatalogPath := "/catalogs" + 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(createCatalogPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke CreateCatalog with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the CreateCatalogOptions model + createCatalogOptionsModel := new(catalogmanagementv1.CreateCatalogOptions) + createCatalogOptionsModel.ID = core.StringPtr("testString") + createCatalogOptionsModel.Rev = core.StringPtr("testString") + createCatalogOptionsModel.Label = core.StringPtr("testString") + createCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + createCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + createCatalogOptionsModel.Tags = []string{"testString"} + createCatalogOptionsModel.URL = core.StringPtr("testString") + createCatalogOptionsModel.Crn = core.StringPtr("testString") + createCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + createCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createCatalogOptionsModel.Disabled = core.BoolPtr(true) + createCatalogOptionsModel.Created = CreateMockDateTime() + createCatalogOptionsModel.Updated = CreateMockDateTime() + createCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + createCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + createCatalogOptionsModel.CatalogFilters = filtersModel + createCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + createCatalogOptionsModel.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.CreateCatalog(createCatalogOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CreateCatalog(createCatalogOptions *CreateCatalogOptions)`, func() { + createCatalogPath := "/catalogs" + 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(createCatalogPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "label": "Label", "short_description": "ShortDescription", "catalog_icon_url": "CatalogIconURL", "tags": ["Tags"], "url": "URL", "crn": "Crn", "offerings_url": "OfferingsURL", "features": [{"title": "Title", "description": "Description"}], "disabled": true, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "resource_group_id": "ResourceGroupID", "owning_account": "OwningAccount", "catalog_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "syndication_settings": {"remove_related_components": false, "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "history": {"namespaces": ["Namespaces"], "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "last_run": "2019-01-01T12:00:00"}, "authorization": {"token": "Token", "last_run": "2019-01-01T12:00:00"}}}`) + })) + }) + It(`Invoke CreateCatalog successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CreateCatalog(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the CreateCatalogOptions model + createCatalogOptionsModel := new(catalogmanagementv1.CreateCatalogOptions) + createCatalogOptionsModel.ID = core.StringPtr("testString") + createCatalogOptionsModel.Rev = core.StringPtr("testString") + createCatalogOptionsModel.Label = core.StringPtr("testString") + createCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + createCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + createCatalogOptionsModel.Tags = []string{"testString"} + createCatalogOptionsModel.URL = core.StringPtr("testString") + createCatalogOptionsModel.Crn = core.StringPtr("testString") + createCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + createCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createCatalogOptionsModel.Disabled = core.BoolPtr(true) + createCatalogOptionsModel.Created = CreateMockDateTime() + createCatalogOptionsModel.Updated = CreateMockDateTime() + createCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + createCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + createCatalogOptionsModel.CatalogFilters = filtersModel + createCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + createCatalogOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.CreateCatalog(createCatalogOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke CreateCatalog with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the CreateCatalogOptions model + createCatalogOptionsModel := new(catalogmanagementv1.CreateCatalogOptions) + createCatalogOptionsModel.ID = core.StringPtr("testString") + createCatalogOptionsModel.Rev = core.StringPtr("testString") + createCatalogOptionsModel.Label = core.StringPtr("testString") + createCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + createCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + createCatalogOptionsModel.Tags = []string{"testString"} + createCatalogOptionsModel.URL = core.StringPtr("testString") + createCatalogOptionsModel.Crn = core.StringPtr("testString") + createCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + createCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createCatalogOptionsModel.Disabled = core.BoolPtr(true) + createCatalogOptionsModel.Created = CreateMockDateTime() + createCatalogOptionsModel.Updated = CreateMockDateTime() + createCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + createCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + createCatalogOptionsModel.CatalogFilters = filtersModel + createCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + createCatalogOptionsModel.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.CreateCatalog(createCatalogOptionsModel) + 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(`GetCatalog(getCatalogOptions *GetCatalogOptions) - Operation response error`, func() { + getCatalogPath := "/catalogs/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(getCatalogPath)) + 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 GetCatalog with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogOptions model + getCatalogOptionsModel := new(catalogmanagementv1.GetCatalogOptions) + getCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getCatalogOptionsModel.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.GetCatalog(getCatalogOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetCatalog(getCatalogOptions *GetCatalogOptions)`, func() { + getCatalogPath := "/catalogs/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(getCatalogPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "label": "Label", "short_description": "ShortDescription", "catalog_icon_url": "CatalogIconURL", "tags": ["Tags"], "url": "URL", "crn": "Crn", "offerings_url": "OfferingsURL", "features": [{"title": "Title", "description": "Description"}], "disabled": true, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "resource_group_id": "ResourceGroupID", "owning_account": "OwningAccount", "catalog_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "syndication_settings": {"remove_related_components": false, "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "history": {"namespaces": ["Namespaces"], "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "last_run": "2019-01-01T12:00:00"}, "authorization": {"token": "Token", "last_run": "2019-01-01T12:00:00"}}}`) + })) + }) + It(`Invoke GetCatalog successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetCatalog(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetCatalogOptions model + getCatalogOptionsModel := new(catalogmanagementv1.GetCatalogOptions) + getCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getCatalogOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetCatalog(getCatalogOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetCatalog with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetCatalogOptions model + getCatalogOptionsModel := new(catalogmanagementv1.GetCatalogOptions) + getCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getCatalogOptionsModel.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.GetCatalog(getCatalogOptionsModel) + 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 GetCatalogOptions model with no property values + getCatalogOptionsModelNew := new(catalogmanagementv1.GetCatalogOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetCatalog(getCatalogOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ReplaceCatalog(replaceCatalogOptions *ReplaceCatalogOptions) - Operation response error`, func() { + replaceCatalogPath := "/catalogs/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(replaceCatalogPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ReplaceCatalog with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the ReplaceCatalogOptions model + replaceCatalogOptionsModel := new(catalogmanagementv1.ReplaceCatalogOptions) + replaceCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceCatalogOptionsModel.ID = core.StringPtr("testString") + replaceCatalogOptionsModel.Rev = core.StringPtr("testString") + replaceCatalogOptionsModel.Label = core.StringPtr("testString") + replaceCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Tags = []string{"testString"} + replaceCatalogOptionsModel.URL = core.StringPtr("testString") + replaceCatalogOptionsModel.Crn = core.StringPtr("testString") + replaceCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceCatalogOptionsModel.Disabled = core.BoolPtr(true) + replaceCatalogOptionsModel.Created = CreateMockDateTime() + replaceCatalogOptionsModel.Updated = CreateMockDateTime() + replaceCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + replaceCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogFilters = filtersModel + replaceCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + replaceCatalogOptionsModel.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.ReplaceCatalog(replaceCatalogOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReplaceCatalog(replaceCatalogOptions *ReplaceCatalogOptions)`, func() { + replaceCatalogPath := "/catalogs/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(replaceCatalogPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "label": "Label", "short_description": "ShortDescription", "catalog_icon_url": "CatalogIconURL", "tags": ["Tags"], "url": "URL", "crn": "Crn", "offerings_url": "OfferingsURL", "features": [{"title": "Title", "description": "Description"}], "disabled": true, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "resource_group_id": "ResourceGroupID", "owning_account": "OwningAccount", "catalog_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "syndication_settings": {"remove_related_components": false, "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "history": {"namespaces": ["Namespaces"], "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "last_run": "2019-01-01T12:00:00"}, "authorization": {"token": "Token", "last_run": "2019-01-01T12:00:00"}}}`) + })) + }) + It(`Invoke ReplaceCatalog successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReplaceCatalog(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the ReplaceCatalogOptions model + replaceCatalogOptionsModel := new(catalogmanagementv1.ReplaceCatalogOptions) + replaceCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceCatalogOptionsModel.ID = core.StringPtr("testString") + replaceCatalogOptionsModel.Rev = core.StringPtr("testString") + replaceCatalogOptionsModel.Label = core.StringPtr("testString") + replaceCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Tags = []string{"testString"} + replaceCatalogOptionsModel.URL = core.StringPtr("testString") + replaceCatalogOptionsModel.Crn = core.StringPtr("testString") + replaceCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceCatalogOptionsModel.Disabled = core.BoolPtr(true) + replaceCatalogOptionsModel.Created = CreateMockDateTime() + replaceCatalogOptionsModel.Updated = CreateMockDateTime() + replaceCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + replaceCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogFilters = filtersModel + replaceCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + replaceCatalogOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ReplaceCatalog(replaceCatalogOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ReplaceCatalog with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + + // Construct an instance of the ReplaceCatalogOptions model + replaceCatalogOptionsModel := new(catalogmanagementv1.ReplaceCatalogOptions) + replaceCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceCatalogOptionsModel.ID = core.StringPtr("testString") + replaceCatalogOptionsModel.Rev = core.StringPtr("testString") + replaceCatalogOptionsModel.Label = core.StringPtr("testString") + replaceCatalogOptionsModel.ShortDescription = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogIconURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Tags = []string{"testString"} + replaceCatalogOptionsModel.URL = core.StringPtr("testString") + replaceCatalogOptionsModel.Crn = core.StringPtr("testString") + replaceCatalogOptionsModel.OfferingsURL = core.StringPtr("testString") + replaceCatalogOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceCatalogOptionsModel.Disabled = core.BoolPtr(true) + replaceCatalogOptionsModel.Created = CreateMockDateTime() + replaceCatalogOptionsModel.Updated = CreateMockDateTime() + replaceCatalogOptionsModel.ResourceGroupID = core.StringPtr("testString") + replaceCatalogOptionsModel.OwningAccount = core.StringPtr("testString") + replaceCatalogOptionsModel.CatalogFilters = filtersModel + replaceCatalogOptionsModel.SyndicationSettings = syndicationResourceModel + replaceCatalogOptionsModel.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.ReplaceCatalog(replaceCatalogOptionsModel) + 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 ReplaceCatalogOptions model with no property values + replaceCatalogOptionsModelNew := new(catalogmanagementv1.ReplaceCatalogOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ReplaceCatalog(replaceCatalogOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeleteCatalog(deleteCatalogOptions *DeleteCatalogOptions)`, func() { + deleteCatalogPath := "/catalogs/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(deleteCatalogPath)) + Expect(req.Method).To(Equal("DELETE")) + res.WriteHeader(200) + })) + }) + It(`Invoke DeleteCatalog successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeleteCatalog(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeleteCatalogOptions model + deleteCatalogOptionsModel := new(catalogmanagementv1.DeleteCatalogOptions) + deleteCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + deleteCatalogOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeleteCatalog(deleteCatalogOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeleteCatalog with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeleteCatalogOptions model + deleteCatalogOptionsModel := new(catalogmanagementv1.DeleteCatalogOptions) + deleteCatalogOptionsModel.CatalogIdentifier = core.StringPtr("testString") + deleteCatalogOptionsModel.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.DeleteCatalog(deleteCatalogOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeleteCatalogOptions model with no property values + deleteCatalogOptionsModelNew := new(catalogmanagementv1.DeleteCatalogOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeleteCatalog(deleteCatalogOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`GetEnterprise(getEnterpriseOptions *GetEnterpriseOptions) - Operation response error`, func() { + getEnterprisePath := "/enterprises/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(getEnterprisePath)) + 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 GetEnterprise with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetEnterpriseOptions model + getEnterpriseOptionsModel := new(catalogmanagementv1.GetEnterpriseOptions) + getEnterpriseOptionsModel.EnterpriseID = core.StringPtr("testString") + getEnterpriseOptionsModel.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.GetEnterprise(getEnterpriseOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetEnterprise(getEnterpriseOptions *GetEnterpriseOptions)`, func() { + getEnterprisePath := "/enterprises/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(getEnterprisePath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "account_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "account_groups": {"keys": {"id": "ID", "account_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}}}}`) + })) + }) + It(`Invoke GetEnterprise successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetEnterprise(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetEnterpriseOptions model + getEnterpriseOptionsModel := new(catalogmanagementv1.GetEnterpriseOptions) + getEnterpriseOptionsModel.EnterpriseID = core.StringPtr("testString") + getEnterpriseOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetEnterprise(getEnterpriseOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetEnterprise with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetEnterpriseOptions model + getEnterpriseOptionsModel := new(catalogmanagementv1.GetEnterpriseOptions) + getEnterpriseOptionsModel.EnterpriseID = core.StringPtr("testString") + getEnterpriseOptionsModel.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.GetEnterprise(getEnterpriseOptionsModel) + 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 GetEnterpriseOptions model with no property values + getEnterpriseOptionsModelNew := new(catalogmanagementv1.GetEnterpriseOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetEnterprise(getEnterpriseOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReplaceEnterprise(replaceEnterpriseOptions *ReplaceEnterpriseOptions)`, func() { + replaceEnterprisePath := "/enterprises/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(replaceEnterprisePath)) + Expect(req.Method).To(Equal("PUT")) + res.WriteHeader(200) + })) + }) + It(`Invoke ReplaceEnterprise successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReplaceEnterprise(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the AccountGroup model + accountGroupModel := new(catalogmanagementv1.AccountGroup) + accountGroupModel.ID = core.StringPtr("testString") + accountGroupModel.AccountFilters = filtersModel + + // Construct an instance of the EnterpriseAccountGroups model + enterpriseAccountGroupsModel := new(catalogmanagementv1.EnterpriseAccountGroups) + enterpriseAccountGroupsModel.Keys = accountGroupModel + + // Construct an instance of the ReplaceEnterpriseOptions model + replaceEnterpriseOptionsModel := new(catalogmanagementv1.ReplaceEnterpriseOptions) + replaceEnterpriseOptionsModel.EnterpriseID = core.StringPtr("testString") + replaceEnterpriseOptionsModel.ID = core.StringPtr("testString") + replaceEnterpriseOptionsModel.Rev = core.StringPtr("testString") + replaceEnterpriseOptionsModel.AccountFilters = filtersModel + replaceEnterpriseOptionsModel.AccountGroups = enterpriseAccountGroupsModel + replaceEnterpriseOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.ReplaceEnterprise(replaceEnterpriseOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke ReplaceEnterprise with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + filterTermsModel.FilterTerms = []string{"testString"} + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + + // Construct an instance of the AccountGroup model + accountGroupModel := new(catalogmanagementv1.AccountGroup) + accountGroupModel.ID = core.StringPtr("testString") + accountGroupModel.AccountFilters = filtersModel + + // Construct an instance of the EnterpriseAccountGroups model + enterpriseAccountGroupsModel := new(catalogmanagementv1.EnterpriseAccountGroups) + enterpriseAccountGroupsModel.Keys = accountGroupModel + + // Construct an instance of the ReplaceEnterpriseOptions model + replaceEnterpriseOptionsModel := new(catalogmanagementv1.ReplaceEnterpriseOptions) + replaceEnterpriseOptionsModel.EnterpriseID = core.StringPtr("testString") + replaceEnterpriseOptionsModel.ID = core.StringPtr("testString") + replaceEnterpriseOptionsModel.Rev = core.StringPtr("testString") + replaceEnterpriseOptionsModel.AccountFilters = filtersModel + replaceEnterpriseOptionsModel.AccountGroups = enterpriseAccountGroupsModel + replaceEnterpriseOptionsModel.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.ReplaceEnterprise(replaceEnterpriseOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the ReplaceEnterpriseOptions model with no property values + replaceEnterpriseOptionsModelNew := new(catalogmanagementv1.ReplaceEnterpriseOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.ReplaceEnterprise(replaceEnterpriseOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`GetConsumptionOfferings(getConsumptionOfferingsOptions *GetConsumptionOfferingsOptions) - Operation response error`, func() { + getConsumptionOfferingsPath := "/offerings" + 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(getConsumptionOfferingsPath)) + Expect(req.Method).To(Equal("GET")) + + // TODO: Add check for digest query parameter + + Expect(req.URL.Query()["catalog"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["select"]).To(Equal([]string{"all"})) + + + // TODO: Add check for includeHidden query parameter + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetConsumptionOfferings with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetConsumptionOfferingsOptions model + getConsumptionOfferingsOptionsModel := new(catalogmanagementv1.GetConsumptionOfferingsOptions) + getConsumptionOfferingsOptionsModel.Digest = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.Catalog = core.StringPtr("testString") + getConsumptionOfferingsOptionsModel.Select = core.StringPtr("all") + getConsumptionOfferingsOptionsModel.IncludeHidden = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.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.GetConsumptionOfferings(getConsumptionOfferingsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetConsumptionOfferings(getConsumptionOfferingsOptions *GetConsumptionOfferingsOptions)`, func() { + getConsumptionOfferingsPath := "/offerings" + 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(getConsumptionOfferingsPath)) + Expect(req.Method).To(Equal("GET")) + + // TODO: Add check for digest query parameter + + Expect(req.URL.Query()["catalog"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["select"]).To(Equal([]string{"all"})) + + + // TODO: Add check for includeHidden query parameter + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}]}`) + })) + }) + It(`Invoke GetConsumptionOfferings successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetConsumptionOfferings(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetConsumptionOfferingsOptions model + getConsumptionOfferingsOptionsModel := new(catalogmanagementv1.GetConsumptionOfferingsOptions) + getConsumptionOfferingsOptionsModel.Digest = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.Catalog = core.StringPtr("testString") + getConsumptionOfferingsOptionsModel.Select = core.StringPtr("all") + getConsumptionOfferingsOptionsModel.IncludeHidden = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetConsumptionOfferings(getConsumptionOfferingsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetConsumptionOfferings with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetConsumptionOfferingsOptions model + getConsumptionOfferingsOptionsModel := new(catalogmanagementv1.GetConsumptionOfferingsOptions) + getConsumptionOfferingsOptionsModel.Digest = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.Catalog = core.StringPtr("testString") + getConsumptionOfferingsOptionsModel.Select = core.StringPtr("all") + getConsumptionOfferingsOptionsModel.IncludeHidden = core.BoolPtr(true) + getConsumptionOfferingsOptionsModel.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.GetConsumptionOfferings(getConsumptionOfferingsOptionsModel) + 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(`ListOfferings(listOfferingsOptions *ListOfferingsOptions) - Operation response error`, func() { + listOfferingsPath := "/catalogs/testString/offerings" + 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(listOfferingsPath)) + Expect(req.Method).To(Equal("GET")) + + // TODO: Add check for digest query parameter + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ListOfferings with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListOfferingsOptions model + listOfferingsOptionsModel := new(catalogmanagementv1.ListOfferingsOptions) + listOfferingsOptionsModel.CatalogIdentifier = core.StringPtr("testString") + listOfferingsOptionsModel.Digest = core.BoolPtr(true) + listOfferingsOptionsModel.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.ListOfferings(listOfferingsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListOfferings(listOfferingsOptions *ListOfferingsOptions)`, func() { + listOfferingsPath := "/catalogs/testString/offerings" + 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(listOfferingsPath)) + Expect(req.Method).To(Equal("GET")) + + // TODO: Add check for digest query parameter + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}]}`) + })) + }) + It(`Invoke ListOfferings successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListOfferings(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ListOfferingsOptions model + listOfferingsOptionsModel := new(catalogmanagementv1.ListOfferingsOptions) + listOfferingsOptionsModel.CatalogIdentifier = core.StringPtr("testString") + listOfferingsOptionsModel.Digest = core.BoolPtr(true) + listOfferingsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ListOfferings(listOfferingsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ListOfferings with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListOfferingsOptions model + listOfferingsOptionsModel := new(catalogmanagementv1.ListOfferingsOptions) + listOfferingsOptionsModel.CatalogIdentifier = core.StringPtr("testString") + listOfferingsOptionsModel.Digest = core.BoolPtr(true) + listOfferingsOptionsModel.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.ListOfferings(listOfferingsOptionsModel) + 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 ListOfferingsOptions model with no property values + listOfferingsOptionsModelNew := new(catalogmanagementv1.ListOfferingsOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ListOfferings(listOfferingsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`CreateOffering(createOfferingOptions *CreateOfferingOptions) - Operation response error`, func() { + createOfferingPath := "/catalogs/testString/offerings" + 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(createOfferingPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke CreateOffering with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the CreateOfferingOptions model + createOfferingOptionsModel := new(catalogmanagementv1.CreateOfferingOptions) + createOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + createOfferingOptionsModel.ID = core.StringPtr("testString") + createOfferingOptionsModel.Rev = core.StringPtr("testString") + createOfferingOptionsModel.URL = core.StringPtr("testString") + createOfferingOptionsModel.Crn = core.StringPtr("testString") + createOfferingOptionsModel.Label = core.StringPtr("testString") + createOfferingOptionsModel.Name = core.StringPtr("testString") + createOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + createOfferingOptionsModel.Tags = []string{"testString"} + createOfferingOptionsModel.Rating = ratingModel + createOfferingOptionsModel.Created = CreateMockDateTime() + createOfferingOptionsModel.Updated = CreateMockDateTime() + createOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + createOfferingOptionsModel.LongDescription = core.StringPtr("testString") + createOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + createOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + createOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + createOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + createOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + createOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + createOfferingOptionsModel.CatalogID = core.StringPtr("testString") + createOfferingOptionsModel.CatalogName = core.StringPtr("testString") + createOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + createOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + createOfferingOptionsModel.Hidden = core.BoolPtr(true) + createOfferingOptionsModel.Provider = core.StringPtr("testString") + createOfferingOptionsModel.RepoInfo = repoInfoModel + createOfferingOptionsModel.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.CreateOffering(createOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CreateOffering(createOfferingOptions *CreateOfferingOptions)`, func() { + createOfferingPath := "/catalogs/testString/offerings" + 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(createOfferingPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke CreateOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CreateOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the CreateOfferingOptions model + createOfferingOptionsModel := new(catalogmanagementv1.CreateOfferingOptions) + createOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + createOfferingOptionsModel.ID = core.StringPtr("testString") + createOfferingOptionsModel.Rev = core.StringPtr("testString") + createOfferingOptionsModel.URL = core.StringPtr("testString") + createOfferingOptionsModel.Crn = core.StringPtr("testString") + createOfferingOptionsModel.Label = core.StringPtr("testString") + createOfferingOptionsModel.Name = core.StringPtr("testString") + createOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + createOfferingOptionsModel.Tags = []string{"testString"} + createOfferingOptionsModel.Rating = ratingModel + createOfferingOptionsModel.Created = CreateMockDateTime() + createOfferingOptionsModel.Updated = CreateMockDateTime() + createOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + createOfferingOptionsModel.LongDescription = core.StringPtr("testString") + createOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + createOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + createOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + createOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + createOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + createOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + createOfferingOptionsModel.CatalogID = core.StringPtr("testString") + createOfferingOptionsModel.CatalogName = core.StringPtr("testString") + createOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + createOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + createOfferingOptionsModel.Hidden = core.BoolPtr(true) + createOfferingOptionsModel.Provider = core.StringPtr("testString") + createOfferingOptionsModel.RepoInfo = repoInfoModel + createOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.CreateOffering(createOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke CreateOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the CreateOfferingOptions model + createOfferingOptionsModel := new(catalogmanagementv1.CreateOfferingOptions) + createOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + createOfferingOptionsModel.ID = core.StringPtr("testString") + createOfferingOptionsModel.Rev = core.StringPtr("testString") + createOfferingOptionsModel.URL = core.StringPtr("testString") + createOfferingOptionsModel.Crn = core.StringPtr("testString") + createOfferingOptionsModel.Label = core.StringPtr("testString") + createOfferingOptionsModel.Name = core.StringPtr("testString") + createOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + createOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + createOfferingOptionsModel.Tags = []string{"testString"} + createOfferingOptionsModel.Rating = ratingModel + createOfferingOptionsModel.Created = CreateMockDateTime() + createOfferingOptionsModel.Updated = CreateMockDateTime() + createOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + createOfferingOptionsModel.LongDescription = core.StringPtr("testString") + createOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + createOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + createOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + createOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + createOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + createOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + createOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + createOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + createOfferingOptionsModel.CatalogID = core.StringPtr("testString") + createOfferingOptionsModel.CatalogName = core.StringPtr("testString") + createOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + createOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + createOfferingOptionsModel.Hidden = core.BoolPtr(true) + createOfferingOptionsModel.Provider = core.StringPtr("testString") + createOfferingOptionsModel.RepoInfo = repoInfoModel + createOfferingOptionsModel.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.CreateOffering(createOfferingOptionsModel) + 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 CreateOfferingOptions model with no property values + createOfferingOptionsModelNew := new(catalogmanagementv1.CreateOfferingOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.CreateOffering(createOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ImportOfferingVersion(importOfferingVersionOptions *ImportOfferingVersionOptions) - Operation response error`, func() { + importOfferingVersionPath := "/catalogs/testString/offerings/testString/version" + 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(importOfferingVersionPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["targetVersion"]).To(Equal([]string{"testString"})) + + + // TODO: Add check for includeConfig query parameter + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ImportOfferingVersion with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ImportOfferingVersionOptions model + importOfferingVersionOptionsModel := new(catalogmanagementv1.ImportOfferingVersionOptions) + importOfferingVersionOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingVersionOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingVersionOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingVersionOptionsModel.Tags = []string{"testString"} + importOfferingVersionOptionsModel.TargetKinds = []string{"testString"} + importOfferingVersionOptionsModel.TargetVersion = core.StringPtr("testString") + importOfferingVersionOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingVersionOptionsModel.RepoType = core.StringPtr("testString") + importOfferingVersionOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingVersionOptionsModel.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.ImportOfferingVersion(importOfferingVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ImportOfferingVersion(importOfferingVersionOptions *ImportOfferingVersionOptions)`, func() { + importOfferingVersionPath := "/catalogs/testString/offerings/testString/version" + 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(importOfferingVersionPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["targetVersion"]).To(Equal([]string{"testString"})) + + + // TODO: Add check for includeConfig query parameter + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke ImportOfferingVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ImportOfferingVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ImportOfferingVersionOptions model + importOfferingVersionOptionsModel := new(catalogmanagementv1.ImportOfferingVersionOptions) + importOfferingVersionOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingVersionOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingVersionOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingVersionOptionsModel.Tags = []string{"testString"} + importOfferingVersionOptionsModel.TargetKinds = []string{"testString"} + importOfferingVersionOptionsModel.TargetVersion = core.StringPtr("testString") + importOfferingVersionOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingVersionOptionsModel.RepoType = core.StringPtr("testString") + importOfferingVersionOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ImportOfferingVersion(importOfferingVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ImportOfferingVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ImportOfferingVersionOptions model + importOfferingVersionOptionsModel := new(catalogmanagementv1.ImportOfferingVersionOptions) + importOfferingVersionOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingVersionOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingVersionOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingVersionOptionsModel.Tags = []string{"testString"} + importOfferingVersionOptionsModel.TargetKinds = []string{"testString"} + importOfferingVersionOptionsModel.TargetVersion = core.StringPtr("testString") + importOfferingVersionOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingVersionOptionsModel.RepoType = core.StringPtr("testString") + importOfferingVersionOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingVersionOptionsModel.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.ImportOfferingVersion(importOfferingVersionOptionsModel) + 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 ImportOfferingVersionOptions model with no property values + importOfferingVersionOptionsModelNew := new(catalogmanagementv1.ImportOfferingVersionOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ImportOfferingVersion(importOfferingVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ImportOffering(importOfferingOptions *ImportOfferingOptions) - Operation response error`, func() { + importOfferingPath := "/catalogs/testString/import/offerings" + 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(importOfferingPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["offeringID"]).To(Equal([]string{"testString"})) + + + // TODO: Add check for includeConfig query parameter + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ImportOffering with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ImportOfferingOptions model + importOfferingOptionsModel := new(catalogmanagementv1.ImportOfferingOptions) + importOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingOptionsModel.Tags = []string{"testString"} + importOfferingOptionsModel.TargetKinds = []string{"testString"} + importOfferingOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingOptionsModel.RepoType = core.StringPtr("testString") + importOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingOptionsModel.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.ImportOffering(importOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ImportOffering(importOfferingOptions *ImportOfferingOptions)`, func() { + importOfferingPath := "/catalogs/testString/import/offerings" + 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(importOfferingPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["offeringID"]).To(Equal([]string{"testString"})) + + + // TODO: Add check for includeConfig query parameter + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke ImportOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ImportOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ImportOfferingOptions model + importOfferingOptionsModel := new(catalogmanagementv1.ImportOfferingOptions) + importOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingOptionsModel.Tags = []string{"testString"} + importOfferingOptionsModel.TargetKinds = []string{"testString"} + importOfferingOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingOptionsModel.RepoType = core.StringPtr("testString") + importOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ImportOffering(importOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ImportOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ImportOfferingOptions model + importOfferingOptionsModel := new(catalogmanagementv1.ImportOfferingOptions) + importOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + importOfferingOptionsModel.Zipurl = core.StringPtr("testString") + importOfferingOptionsModel.Tags = []string{"testString"} + importOfferingOptionsModel.TargetKinds = []string{"testString"} + importOfferingOptionsModel.OfferingID = core.StringPtr("testString") + importOfferingOptionsModel.IncludeConfig = core.BoolPtr(true) + importOfferingOptionsModel.RepoType = core.StringPtr("testString") + importOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + importOfferingOptionsModel.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.ImportOffering(importOfferingOptionsModel) + 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 ImportOfferingOptions model with no property values + importOfferingOptionsModelNew := new(catalogmanagementv1.ImportOfferingOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ImportOffering(importOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ReloadOffering(reloadOfferingOptions *ReloadOfferingOptions) - Operation response error`, func() { + reloadOfferingPath := "/catalogs/testString/offerings/testString/reload" + 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(reloadOfferingPath)) + Expect(req.Method).To(Equal("PUT")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["targetVersion"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ReloadOffering with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReloadOfferingOptions model + reloadOfferingOptionsModel := new(catalogmanagementv1.ReloadOfferingOptions) + reloadOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + reloadOfferingOptionsModel.OfferingID = core.StringPtr("testString") + reloadOfferingOptionsModel.Zipurl = core.StringPtr("testString") + reloadOfferingOptionsModel.TargetVersion = core.StringPtr("testString") + reloadOfferingOptionsModel.Tags = []string{"testString"} + reloadOfferingOptionsModel.TargetKinds = []string{"testString"} + reloadOfferingOptionsModel.RepoType = core.StringPtr("testString") + reloadOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + reloadOfferingOptionsModel.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.ReloadOffering(reloadOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReloadOffering(reloadOfferingOptions *ReloadOfferingOptions)`, func() { + reloadOfferingPath := "/catalogs/testString/offerings/testString/reload" + 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(reloadOfferingPath)) + Expect(req.Method).To(Equal("PUT")) + Expect(req.Header["X-Auth-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["zipurl"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["targetVersion"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["repoType"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(201) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke ReloadOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReloadOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ReloadOfferingOptions model + reloadOfferingOptionsModel := new(catalogmanagementv1.ReloadOfferingOptions) + reloadOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + reloadOfferingOptionsModel.OfferingID = core.StringPtr("testString") + reloadOfferingOptionsModel.Zipurl = core.StringPtr("testString") + reloadOfferingOptionsModel.TargetVersion = core.StringPtr("testString") + reloadOfferingOptionsModel.Tags = []string{"testString"} + reloadOfferingOptionsModel.TargetKinds = []string{"testString"} + reloadOfferingOptionsModel.RepoType = core.StringPtr("testString") + reloadOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + reloadOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ReloadOffering(reloadOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ReloadOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReloadOfferingOptions model + reloadOfferingOptionsModel := new(catalogmanagementv1.ReloadOfferingOptions) + reloadOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + reloadOfferingOptionsModel.OfferingID = core.StringPtr("testString") + reloadOfferingOptionsModel.Zipurl = core.StringPtr("testString") + reloadOfferingOptionsModel.TargetVersion = core.StringPtr("testString") + reloadOfferingOptionsModel.Tags = []string{"testString"} + reloadOfferingOptionsModel.TargetKinds = []string{"testString"} + reloadOfferingOptionsModel.RepoType = core.StringPtr("testString") + reloadOfferingOptionsModel.XAuthToken = core.StringPtr("testString") + reloadOfferingOptionsModel.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.ReloadOffering(reloadOfferingOptionsModel) + 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 ReloadOfferingOptions model with no property values + reloadOfferingOptionsModelNew := new(catalogmanagementv1.ReloadOfferingOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ReloadOffering(reloadOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetOffering(getOfferingOptions *GetOfferingOptions) - Operation response error`, func() { + getOfferingPath := "/catalogs/testString/offerings/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(getOfferingPath)) + 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 GetOffering with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetOfferingOptions model + getOfferingOptionsModel := new(catalogmanagementv1.GetOfferingOptions) + getOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getOfferingOptionsModel.OfferingID = core.StringPtr("testString") + getOfferingOptionsModel.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.GetOffering(getOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetOffering(getOfferingOptions *GetOfferingOptions)`, func() { + getOfferingPath := "/catalogs/testString/offerings/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(getOfferingPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke GetOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetOfferingOptions model + getOfferingOptionsModel := new(catalogmanagementv1.GetOfferingOptions) + getOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getOfferingOptionsModel.OfferingID = core.StringPtr("testString") + getOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetOffering(getOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetOfferingOptions model + getOfferingOptionsModel := new(catalogmanagementv1.GetOfferingOptions) + getOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + getOfferingOptionsModel.OfferingID = core.StringPtr("testString") + getOfferingOptionsModel.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.GetOffering(getOfferingOptionsModel) + 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 GetOfferingOptions model with no property values + getOfferingOptionsModelNew := new(catalogmanagementv1.GetOfferingOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetOffering(getOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ReplaceOffering(replaceOfferingOptions *ReplaceOfferingOptions) - Operation response error`, func() { + replaceOfferingPath := "/catalogs/testString/offerings/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(replaceOfferingPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ReplaceOffering with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the ReplaceOfferingOptions model + replaceOfferingOptionsModel := new(catalogmanagementv1.ReplaceOfferingOptions) + replaceOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingOptionsModel.ID = core.StringPtr("testString") + replaceOfferingOptionsModel.Rev = core.StringPtr("testString") + replaceOfferingOptionsModel.URL = core.StringPtr("testString") + replaceOfferingOptionsModel.Crn = core.StringPtr("testString") + replaceOfferingOptionsModel.Label = core.StringPtr("testString") + replaceOfferingOptionsModel.Name = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + replaceOfferingOptionsModel.Tags = []string{"testString"} + replaceOfferingOptionsModel.Rating = ratingModel + replaceOfferingOptionsModel.Created = CreateMockDateTime() + replaceOfferingOptionsModel.Updated = CreateMockDateTime() + replaceOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.LongDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + replaceOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + replaceOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogID = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogName = core.StringPtr("testString") + replaceOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + replaceOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + replaceOfferingOptionsModel.Hidden = core.BoolPtr(true) + replaceOfferingOptionsModel.Provider = core.StringPtr("testString") + replaceOfferingOptionsModel.RepoInfo = repoInfoModel + replaceOfferingOptionsModel.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.ReplaceOffering(replaceOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReplaceOffering(replaceOfferingOptions *ReplaceOfferingOptions)`, func() { + replaceOfferingPath := "/catalogs/testString/offerings/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(replaceOfferingPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "label": "Label", "short_description": "ShortDescription", "catalog_icon_url": "CatalogIconURL", "tags": ["Tags"], "url": "URL", "crn": "Crn", "offerings_url": "OfferingsURL", "features": [{"title": "Title", "description": "Description"}], "disabled": true, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "resource_group_id": "ResourceGroupID", "owning_account": "OwningAccount", "catalog_filters": {"include_all": true, "category_filters": {"mapKey": {"include": false, "filter": {"filter_terms": ["FilterTerms"]}}}, "id_filters": {"include": {"filter_terms": ["FilterTerms"]}, "exclude": {"filter_terms": ["FilterTerms"]}}}, "syndication_settings": {"remove_related_components": false, "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "history": {"namespaces": ["Namespaces"], "clusters": [{"region": "Region", "id": "ID", "name": "Name", "resource_group_name": "ResourceGroupName", "type": "Type", "namespaces": ["Namespaces"], "all_namespaces": false}], "last_run": "2019-01-01T12:00:00"}, "authorization": {"token": "Token", "last_run": "2019-01-01T12:00:00"}}}`) + })) + }) + It(`Invoke ReplaceOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReplaceOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the ReplaceOfferingOptions model + replaceOfferingOptionsModel := new(catalogmanagementv1.ReplaceOfferingOptions) + replaceOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingOptionsModel.ID = core.StringPtr("testString") + replaceOfferingOptionsModel.Rev = core.StringPtr("testString") + replaceOfferingOptionsModel.URL = core.StringPtr("testString") + replaceOfferingOptionsModel.Crn = core.StringPtr("testString") + replaceOfferingOptionsModel.Label = core.StringPtr("testString") + replaceOfferingOptionsModel.Name = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + replaceOfferingOptionsModel.Tags = []string{"testString"} + replaceOfferingOptionsModel.Rating = ratingModel + replaceOfferingOptionsModel.Created = CreateMockDateTime() + replaceOfferingOptionsModel.Updated = CreateMockDateTime() + replaceOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.LongDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + replaceOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + replaceOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogID = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogName = core.StringPtr("testString") + replaceOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + replaceOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + replaceOfferingOptionsModel.Hidden = core.BoolPtr(true) + replaceOfferingOptionsModel.Provider = core.StringPtr("testString") + replaceOfferingOptionsModel.RepoInfo = repoInfoModel + replaceOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ReplaceOffering(replaceOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ReplaceOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + + // Construct an instance of the ReplaceOfferingOptions model + replaceOfferingOptionsModel := new(catalogmanagementv1.ReplaceOfferingOptions) + replaceOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingOptionsModel.ID = core.StringPtr("testString") + replaceOfferingOptionsModel.Rev = core.StringPtr("testString") + replaceOfferingOptionsModel.URL = core.StringPtr("testString") + replaceOfferingOptionsModel.Crn = core.StringPtr("testString") + replaceOfferingOptionsModel.Label = core.StringPtr("testString") + replaceOfferingOptionsModel.Name = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingIconURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingDocsURL = core.StringPtr("testString") + replaceOfferingOptionsModel.OfferingSupportURL = core.StringPtr("testString") + replaceOfferingOptionsModel.Tags = []string{"testString"} + replaceOfferingOptionsModel.Rating = ratingModel + replaceOfferingOptionsModel.Created = CreateMockDateTime() + replaceOfferingOptionsModel.Updated = CreateMockDateTime() + replaceOfferingOptionsModel.ShortDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.LongDescription = core.StringPtr("testString") + replaceOfferingOptionsModel.Features = []catalogmanagementv1.Feature{*featureModel} + replaceOfferingOptionsModel.Kinds = []catalogmanagementv1.Kind{*kindModel} + replaceOfferingOptionsModel.PermitRequestIbmPublicPublish = core.BoolPtr(true) + replaceOfferingOptionsModel.IbmPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicPublishApproved = core.BoolPtr(true) + replaceOfferingOptionsModel.PublicOriginalCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PublishPublicCrn = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalApprovalRecord = core.StringPtr("testString") + replaceOfferingOptionsModel.PortalUiURL = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogID = core.StringPtr("testString") + replaceOfferingOptionsModel.CatalogName = core.StringPtr("testString") + replaceOfferingOptionsModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + replaceOfferingOptionsModel.Disclaimer = core.StringPtr("testString") + replaceOfferingOptionsModel.Hidden = core.BoolPtr(true) + replaceOfferingOptionsModel.Provider = core.StringPtr("testString") + replaceOfferingOptionsModel.RepoInfo = repoInfoModel + replaceOfferingOptionsModel.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.ReplaceOffering(replaceOfferingOptionsModel) + 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 ReplaceOfferingOptions model with no property values + replaceOfferingOptionsModelNew := new(catalogmanagementv1.ReplaceOfferingOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ReplaceOffering(replaceOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeleteOffering(deleteOfferingOptions *DeleteOfferingOptions)`, func() { + deleteOfferingPath := "/catalogs/testString/offerings/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(deleteOfferingPath)) + Expect(req.Method).To(Equal("DELETE")) + res.WriteHeader(200) + })) + }) + It(`Invoke DeleteOffering successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeleteOffering(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeleteOfferingOptions model + deleteOfferingOptionsModel := new(catalogmanagementv1.DeleteOfferingOptions) + deleteOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + deleteOfferingOptionsModel.OfferingID = core.StringPtr("testString") + deleteOfferingOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeleteOffering(deleteOfferingOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeleteOffering with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeleteOfferingOptions model + deleteOfferingOptionsModel := new(catalogmanagementv1.DeleteOfferingOptions) + deleteOfferingOptionsModel.CatalogIdentifier = core.StringPtr("testString") + deleteOfferingOptionsModel.OfferingID = core.StringPtr("testString") + deleteOfferingOptionsModel.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.DeleteOffering(deleteOfferingOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeleteOfferingOptions model with no property values + deleteOfferingOptionsModelNew := new(catalogmanagementv1.DeleteOfferingOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeleteOffering(deleteOfferingOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ReplaceOfferingIcon(replaceOfferingIconOptions *ReplaceOfferingIconOptions) - Operation response error`, func() { + replaceOfferingIconPath := "/catalogs/testString/offerings/testString/icon/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(replaceOfferingIconPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ReplaceOfferingIcon with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReplaceOfferingIconOptions model + replaceOfferingIconOptionsModel := new(catalogmanagementv1.ReplaceOfferingIconOptions) + replaceOfferingIconOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingIconOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingIconOptionsModel.FileName = core.StringPtr("testString") + replaceOfferingIconOptionsModel.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.ReplaceOfferingIcon(replaceOfferingIconOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReplaceOfferingIcon(replaceOfferingIconOptions *ReplaceOfferingIconOptions)`, func() { + replaceOfferingIconPath := "/catalogs/testString/offerings/testString/icon/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(replaceOfferingIconPath)) + Expect(req.Method).To(Equal("PUT")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke ReplaceOfferingIcon successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReplaceOfferingIcon(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ReplaceOfferingIconOptions model + replaceOfferingIconOptionsModel := new(catalogmanagementv1.ReplaceOfferingIconOptions) + replaceOfferingIconOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingIconOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingIconOptionsModel.FileName = core.StringPtr("testString") + replaceOfferingIconOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ReplaceOfferingIcon(replaceOfferingIconOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ReplaceOfferingIcon with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReplaceOfferingIconOptions model + replaceOfferingIconOptionsModel := new(catalogmanagementv1.ReplaceOfferingIconOptions) + replaceOfferingIconOptionsModel.CatalogIdentifier = core.StringPtr("testString") + replaceOfferingIconOptionsModel.OfferingID = core.StringPtr("testString") + replaceOfferingIconOptionsModel.FileName = core.StringPtr("testString") + replaceOfferingIconOptionsModel.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.ReplaceOfferingIcon(replaceOfferingIconOptionsModel) + 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 ReplaceOfferingIconOptions model with no property values + replaceOfferingIconOptionsModelNew := new(catalogmanagementv1.ReplaceOfferingIconOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ReplaceOfferingIcon(replaceOfferingIconOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`UpdateOfferingIbm(updateOfferingIbmOptions *UpdateOfferingIbmOptions) - Operation response error`, func() { + updateOfferingIbmPath := "/catalogs/testString/offerings/testString/publish/ibm/true" + 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(updateOfferingIbmPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke UpdateOfferingIbm with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the UpdateOfferingIbmOptions model + updateOfferingIbmOptionsModel := new(catalogmanagementv1.UpdateOfferingIbmOptions) + updateOfferingIbmOptionsModel.CatalogIdentifier = core.StringPtr("testString") + updateOfferingIbmOptionsModel.OfferingID = core.StringPtr("testString") + updateOfferingIbmOptionsModel.ApprovalType = core.StringPtr("ibm") + updateOfferingIbmOptionsModel.Approved = core.StringPtr("true") + updateOfferingIbmOptionsModel.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.UpdateOfferingIbm(updateOfferingIbmOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`UpdateOfferingIbm(updateOfferingIbmOptions *UpdateOfferingIbmOptions)`, func() { + updateOfferingIbmPath := "/catalogs/testString/offerings/testString/publish/ibm/true" + 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(updateOfferingIbmPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"ibm": false, "public": true, "changed": false}`) + })) + }) + It(`Invoke UpdateOfferingIbm successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.UpdateOfferingIbm(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the UpdateOfferingIbmOptions model + updateOfferingIbmOptionsModel := new(catalogmanagementv1.UpdateOfferingIbmOptions) + updateOfferingIbmOptionsModel.CatalogIdentifier = core.StringPtr("testString") + updateOfferingIbmOptionsModel.OfferingID = core.StringPtr("testString") + updateOfferingIbmOptionsModel.ApprovalType = core.StringPtr("ibm") + updateOfferingIbmOptionsModel.Approved = core.StringPtr("true") + updateOfferingIbmOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.UpdateOfferingIbm(updateOfferingIbmOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke UpdateOfferingIbm with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the UpdateOfferingIbmOptions model + updateOfferingIbmOptionsModel := new(catalogmanagementv1.UpdateOfferingIbmOptions) + updateOfferingIbmOptionsModel.CatalogIdentifier = core.StringPtr("testString") + updateOfferingIbmOptionsModel.OfferingID = core.StringPtr("testString") + updateOfferingIbmOptionsModel.ApprovalType = core.StringPtr("ibm") + updateOfferingIbmOptionsModel.Approved = core.StringPtr("true") + updateOfferingIbmOptionsModel.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.UpdateOfferingIbm(updateOfferingIbmOptionsModel) + 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 UpdateOfferingIbmOptions model with no property values + updateOfferingIbmOptionsModelNew := new(catalogmanagementv1.UpdateOfferingIbmOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.UpdateOfferingIbm(updateOfferingIbmOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + + Describe(`GetVersionAbout(getVersionAboutOptions *GetVersionAboutOptions)`, func() { + getVersionAboutPath := "/versions/testString/about" + 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(getVersionAboutPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "text/markdown") + res.WriteHeader(200) + fmt.Fprintf(res, `"OperationResponse"`) + })) + }) + It(`Invoke GetVersionAbout successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersionAbout(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetVersionAboutOptions model + getVersionAboutOptionsModel := new(catalogmanagementv1.GetVersionAboutOptions) + getVersionAboutOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionAboutOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetVersionAbout(getVersionAboutOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetVersionAbout with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionAboutOptions model + getVersionAboutOptionsModel := new(catalogmanagementv1.GetVersionAboutOptions) + getVersionAboutOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionAboutOptionsModel.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.GetVersionAbout(getVersionAboutOptionsModel) + 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 GetVersionAboutOptions model with no property values + getVersionAboutOptionsModelNew := new(catalogmanagementv1.GetVersionAboutOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetVersionAbout(getVersionAboutOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetVersionLicense(getVersionLicenseOptions *GetVersionLicenseOptions)`, func() { + getVersionLicensePath := "/versions/testString/licenses/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(getVersionLicensePath)) + Expect(req.Method).To(Equal("GET")) + res.WriteHeader(200) + })) + }) + It(`Invoke GetVersionLicense successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersionLicense(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the GetVersionLicenseOptions model + getVersionLicenseOptionsModel := new(catalogmanagementv1.GetVersionLicenseOptions) + getVersionLicenseOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionLicenseOptionsModel.LicenseID = core.StringPtr("testString") + getVersionLicenseOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.GetVersionLicense(getVersionLicenseOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke GetVersionLicense with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionLicenseOptions model + getVersionLicenseOptionsModel := new(catalogmanagementv1.GetVersionLicenseOptions) + getVersionLicenseOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionLicenseOptionsModel.LicenseID = core.StringPtr("testString") + getVersionLicenseOptionsModel.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.GetVersionLicense(getVersionLicenseOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the GetVersionLicenseOptions model with no property values + getVersionLicenseOptionsModelNew := new(catalogmanagementv1.GetVersionLicenseOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.GetVersionLicense(getVersionLicenseOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetVersionContainerImages(getVersionContainerImagesOptions *GetVersionContainerImagesOptions) - Operation response error`, func() { + getVersionContainerImagesPath := "/versions/testString/containerImages" + 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(getVersionContainerImagesPath)) + 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 GetVersionContainerImages with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionContainerImagesOptions model + getVersionContainerImagesOptionsModel := new(catalogmanagementv1.GetVersionContainerImagesOptions) + getVersionContainerImagesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionContainerImagesOptionsModel.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.GetVersionContainerImages(getVersionContainerImagesOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetVersionContainerImages(getVersionContainerImagesOptions *GetVersionContainerImagesOptions)`, func() { + getVersionContainerImagesPath := "/versions/testString/containerImages" + 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(getVersionContainerImagesPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"description": "Description", "images": [{"image": "Image"}]}`) + })) + }) + It(`Invoke GetVersionContainerImages successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersionContainerImages(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetVersionContainerImagesOptions model + getVersionContainerImagesOptionsModel := new(catalogmanagementv1.GetVersionContainerImagesOptions) + getVersionContainerImagesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionContainerImagesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetVersionContainerImages(getVersionContainerImagesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetVersionContainerImages with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionContainerImagesOptions model + getVersionContainerImagesOptionsModel := new(catalogmanagementv1.GetVersionContainerImagesOptions) + getVersionContainerImagesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionContainerImagesOptionsModel.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.GetVersionContainerImages(getVersionContainerImagesOptionsModel) + 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 GetVersionContainerImagesOptions model with no property values + getVersionContainerImagesOptionsModelNew := new(catalogmanagementv1.GetVersionContainerImagesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetVersionContainerImages(getVersionContainerImagesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeprecateVersion(deprecateVersionOptions *DeprecateVersionOptions)`, func() { + deprecateVersionPath := "/versions/testString/deprecate" + 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(deprecateVersionPath)) + Expect(req.Method).To(Equal("POST")) + res.WriteHeader(202) + })) + }) + It(`Invoke DeprecateVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeprecateVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeprecateVersionOptions model + deprecateVersionOptionsModel := new(catalogmanagementv1.DeprecateVersionOptions) + deprecateVersionOptionsModel.VersionLocID = core.StringPtr("testString") + deprecateVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeprecateVersion(deprecateVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeprecateVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeprecateVersionOptions model + deprecateVersionOptionsModel := new(catalogmanagementv1.DeprecateVersionOptions) + deprecateVersionOptionsModel.VersionLocID = core.StringPtr("testString") + deprecateVersionOptionsModel.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.DeprecateVersion(deprecateVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeprecateVersionOptions model with no property values + deprecateVersionOptionsModelNew := new(catalogmanagementv1.DeprecateVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeprecateVersion(deprecateVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`AccountPublishVersion(accountPublishVersionOptions *AccountPublishVersionOptions)`, func() { + accountPublishVersionPath := "/versions/testString/account-publish" + 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(accountPublishVersionPath)) + Expect(req.Method).To(Equal("POST")) + res.WriteHeader(202) + })) + }) + It(`Invoke AccountPublishVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.AccountPublishVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the AccountPublishVersionOptions model + accountPublishVersionOptionsModel := new(catalogmanagementv1.AccountPublishVersionOptions) + accountPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + accountPublishVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.AccountPublishVersion(accountPublishVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke AccountPublishVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the AccountPublishVersionOptions model + accountPublishVersionOptionsModel := new(catalogmanagementv1.AccountPublishVersionOptions) + accountPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + accountPublishVersionOptionsModel.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.AccountPublishVersion(accountPublishVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the AccountPublishVersionOptions model with no property values + accountPublishVersionOptionsModelNew := new(catalogmanagementv1.AccountPublishVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.AccountPublishVersion(accountPublishVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`IbmPublishVersion(ibmPublishVersionOptions *IbmPublishVersionOptions)`, func() { + ibmPublishVersionPath := "/versions/testString/ibm-publish" + 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(ibmPublishVersionPath)) + Expect(req.Method).To(Equal("POST")) + res.WriteHeader(202) + })) + }) + It(`Invoke IbmPublishVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.IbmPublishVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the IbmPublishVersionOptions model + ibmPublishVersionOptionsModel := new(catalogmanagementv1.IbmPublishVersionOptions) + ibmPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + ibmPublishVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.IbmPublishVersion(ibmPublishVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke IbmPublishVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the IbmPublishVersionOptions model + ibmPublishVersionOptionsModel := new(catalogmanagementv1.IbmPublishVersionOptions) + ibmPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + ibmPublishVersionOptionsModel.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.IbmPublishVersion(ibmPublishVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the IbmPublishVersionOptions model with no property values + ibmPublishVersionOptionsModelNew := new(catalogmanagementv1.IbmPublishVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.IbmPublishVersion(ibmPublishVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`PublicPublishVersion(publicPublishVersionOptions *PublicPublishVersionOptions)`, func() { + publicPublishVersionPath := "/versions/testString/public-publish" + 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(publicPublishVersionPath)) + Expect(req.Method).To(Equal("POST")) + res.WriteHeader(202) + })) + }) + It(`Invoke PublicPublishVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.PublicPublishVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the PublicPublishVersionOptions model + publicPublishVersionOptionsModel := new(catalogmanagementv1.PublicPublishVersionOptions) + publicPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + publicPublishVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.PublicPublishVersion(publicPublishVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke PublicPublishVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the PublicPublishVersionOptions model + publicPublishVersionOptionsModel := new(catalogmanagementv1.PublicPublishVersionOptions) + publicPublishVersionOptionsModel.VersionLocID = core.StringPtr("testString") + publicPublishVersionOptionsModel.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.PublicPublishVersion(publicPublishVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the PublicPublishVersionOptions model with no property values + publicPublishVersionOptionsModelNew := new(catalogmanagementv1.PublicPublishVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.PublicPublishVersion(publicPublishVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CommitVersion(commitVersionOptions *CommitVersionOptions)`, func() { + commitVersionPath := "/versions/testString/commit" + 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(commitVersionPath)) + Expect(req.Method).To(Equal("POST")) + res.WriteHeader(200) + })) + }) + It(`Invoke CommitVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CommitVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the CommitVersionOptions model + commitVersionOptionsModel := new(catalogmanagementv1.CommitVersionOptions) + commitVersionOptionsModel.VersionLocID = core.StringPtr("testString") + commitVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.CommitVersion(commitVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke CommitVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CommitVersionOptions model + commitVersionOptionsModel := new(catalogmanagementv1.CommitVersionOptions) + commitVersionOptionsModel.VersionLocID = core.StringPtr("testString") + commitVersionOptionsModel.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.CommitVersion(commitVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the CommitVersionOptions model with no property values + commitVersionOptionsModelNew := new(catalogmanagementv1.CommitVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.CommitVersion(commitVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetVersionWorkingCopy(getVersionWorkingCopyOptions *GetVersionWorkingCopyOptions) - Operation response error`, func() { + getVersionWorkingCopyPath := "/versions/testString/workingcopy" + 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(getVersionWorkingCopyPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetVersionWorkingCopy with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionWorkingCopyOptions model + getVersionWorkingCopyOptionsModel := new(catalogmanagementv1.GetVersionWorkingCopyOptions) + getVersionWorkingCopyOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionWorkingCopyOptionsModel.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.GetVersionWorkingCopy(getVersionWorkingCopyOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetVersionWorkingCopy(getVersionWorkingCopyOptions *GetVersionWorkingCopyOptions)`, func() { + getVersionWorkingCopyPath := "/versions/testString/workingcopy" + 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(getVersionWorkingCopyPath)) + Expect(req.Method).To(Equal("POST")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}`) + })) + }) + It(`Invoke GetVersionWorkingCopy successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersionWorkingCopy(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetVersionWorkingCopyOptions model + getVersionWorkingCopyOptionsModel := new(catalogmanagementv1.GetVersionWorkingCopyOptions) + getVersionWorkingCopyOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionWorkingCopyOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetVersionWorkingCopy(getVersionWorkingCopyOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetVersionWorkingCopy with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionWorkingCopyOptions model + getVersionWorkingCopyOptionsModel := new(catalogmanagementv1.GetVersionWorkingCopyOptions) + getVersionWorkingCopyOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionWorkingCopyOptionsModel.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.GetVersionWorkingCopy(getVersionWorkingCopyOptionsModel) + 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 GetVersionWorkingCopyOptions model with no property values + getVersionWorkingCopyOptionsModelNew := new(catalogmanagementv1.GetVersionWorkingCopyOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetVersionWorkingCopy(getVersionWorkingCopyOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetVersionUpdates(getVersionUpdatesOptions *GetVersionUpdatesOptions) - Operation response error`, func() { + getVersionUpdatesPath := "/versions/testString/updates" + 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(getVersionUpdatesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["resource_group_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetVersionUpdates with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionUpdatesOptions model + getVersionUpdatesOptionsModel := new(catalogmanagementv1.GetVersionUpdatesOptions) + getVersionUpdatesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ClusterID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Region = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ResourceGroupID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Namespace = core.StringPtr("testString") + getVersionUpdatesOptionsModel.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.GetVersionUpdates(getVersionUpdatesOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetVersionUpdates(getVersionUpdatesOptions *GetVersionUpdatesOptions)`, func() { + getVersionUpdatesPath := "/versions/testString/updates" + 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(getVersionUpdatesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["resource_group_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `[{"version_locator": "VersionLocator", "version": "Version", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "required_resources": [{"type": "mem", "value": "anyValue"}], "package_version": "PackageVersion", "can_update": false, "messages": {"anyKey": "anyValue"}}]`) + })) + }) + It(`Invoke GetVersionUpdates successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersionUpdates(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetVersionUpdatesOptions model + getVersionUpdatesOptionsModel := new(catalogmanagementv1.GetVersionUpdatesOptions) + getVersionUpdatesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ClusterID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Region = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ResourceGroupID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Namespace = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetVersionUpdates(getVersionUpdatesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetVersionUpdates with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionUpdatesOptions model + getVersionUpdatesOptionsModel := new(catalogmanagementv1.GetVersionUpdatesOptions) + getVersionUpdatesOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ClusterID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Region = core.StringPtr("testString") + getVersionUpdatesOptionsModel.ResourceGroupID = core.StringPtr("testString") + getVersionUpdatesOptionsModel.Namespace = core.StringPtr("testString") + getVersionUpdatesOptionsModel.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.GetVersionUpdates(getVersionUpdatesOptionsModel) + 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 GetVersionUpdatesOptions model with no property values + getVersionUpdatesOptionsModelNew := new(catalogmanagementv1.GetVersionUpdatesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetVersionUpdates(getVersionUpdatesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetVersion(getVersionOptions *GetVersionOptions) - Operation response error`, func() { + getVersionPath := "/versions/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(getVersionPath)) + 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 GetVersion with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionOptions model + getVersionOptionsModel := new(catalogmanagementv1.GetVersionOptions) + getVersionOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionOptionsModel.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.GetVersion(getVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetVersion(getVersionOptions *GetVersionOptions)`, func() { + getVersionPath := "/versions/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(getVersionPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"id": "ID", "_rev": "Rev", "url": "URL", "crn": "Crn", "label": "Label", "name": "Name", "offering_icon_url": "OfferingIconURL", "offering_docs_url": "OfferingDocsURL", "offering_support_url": "OfferingSupportURL", "tags": ["Tags"], "rating": {"one_star_count": 12, "two_star_count": 12, "three_star_count": 14, "four_star_count": 13}, "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "short_description": "ShortDescription", "long_description": "LongDescription", "features": [{"title": "Title", "description": "Description"}], "kinds": [{"id": "ID", "format_kind": "FormatKind", "target_kind": "TargetKind", "metadata": {"anyKey": "anyValue"}, "install_description": "InstallDescription", "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "versions": [{"id": "ID", "_rev": "Rev", "crn": "Crn", "version": "Version", "sha": "Sha", "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "offering_id": "OfferingID", "catalog_id": "CatalogID", "kind_id": "KindID", "tags": ["Tags"], "repo_url": "RepoURL", "source_url": "SourceURL", "tgz_url": "TgzURL", "configuration": [{"key": "Key", "type": "Type", "default_value": "anyValue", "value_constraint": "ValueConstraint", "description": "Description", "required": true, "options": [{"anyKey": "anyValue"}], "hidden": true}], "metadata": {"anyKey": "anyValue"}, "validation": {"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}, "required_resources": [{"type": "mem", "value": "anyValue"}], "single_instance": true, "install": {"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}, "pre_install": [{"instructions": "Instructions", "script": "Script", "script_permission": "ScriptPermission", "delete_script": "DeleteScript", "scope": "Scope"}], "entitlement": {"provider_name": "ProviderName", "provider_id": "ProviderID", "product_id": "ProductID", "part_numbers": ["PartNumbers"], "image_repo_name": "ImageRepoName"}, "licenses": [{"id": "ID", "name": "Name", "type": "Type", "url": "URL", "description": "Description"}], "image_manifest_url": "ImageManifestURL", "deprecated": true, "package_version": "PackageVersion", "state": {"current": "Current", "current_entered": "2019-01-01T12:00:00", "pending": "Pending", "pending_requested": "2019-01-01T12:00:00", "previous": "Previous"}, "version_locator": "VersionLocator", "console_url": "ConsoleURL", "long_description": "LongDescription", "whitelisted_accounts": ["WhitelistedAccounts"]}], "plans": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "additional_features": [{"title": "Title", "description": "Description"}], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00", "deployments": [{"id": "ID", "label": "Label", "name": "Name", "short_description": "ShortDescription", "long_description": "LongDescription", "metadata": {"anyKey": "anyValue"}, "tags": ["Tags"], "created": "2019-01-01T12:00:00", "updated": "2019-01-01T12:00:00"}]}]}], "permit_request_ibm_public_publish": false, "ibm_publish_approved": true, "public_publish_approved": false, "public_original_crn": "PublicOriginalCrn", "publish_public_crn": "PublishPublicCrn", "portal_approval_record": "PortalApprovalRecord", "portal_ui_url": "PortalUiURL", "catalog_id": "CatalogID", "catalog_name": "CatalogName", "metadata": {"anyKey": "anyValue"}, "disclaimer": "Disclaimer", "hidden": true, "provider": "Provider", "repo_info": {"token": "Token", "type": "Type"}}`) + })) + }) + It(`Invoke GetVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetVersionOptions model + getVersionOptionsModel := new(catalogmanagementv1.GetVersionOptions) + getVersionOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetVersion(getVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetVersionOptions model + getVersionOptionsModel := new(catalogmanagementv1.GetVersionOptions) + getVersionOptionsModel.VersionLocID = core.StringPtr("testString") + getVersionOptionsModel.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.GetVersion(getVersionOptionsModel) + 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 GetVersionOptions model with no property values + getVersionOptionsModelNew := new(catalogmanagementv1.GetVersionOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetVersion(getVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeleteVersion(deleteVersionOptions *DeleteVersionOptions)`, func() { + deleteVersionPath := "/versions/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(deleteVersionPath)) + Expect(req.Method).To(Equal("DELETE")) + res.WriteHeader(200) + })) + }) + It(`Invoke DeleteVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeleteVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeleteVersionOptions model + deleteVersionOptionsModel := new(catalogmanagementv1.DeleteVersionOptions) + deleteVersionOptionsModel.VersionLocID = core.StringPtr("testString") + deleteVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeleteVersion(deleteVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeleteVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeleteVersionOptions model + deleteVersionOptionsModel := new(catalogmanagementv1.DeleteVersionOptions) + deleteVersionOptionsModel.VersionLocID = core.StringPtr("testString") + deleteVersionOptionsModel.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.DeleteVersion(deleteVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeleteVersionOptions model with no property values + deleteVersionOptionsModelNew := new(catalogmanagementv1.DeleteVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeleteVersion(deleteVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListVersions(listVersionsOptions *ListVersionsOptions)`, func() { + listVersionsPath := "/versions" + 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(listVersionsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["q"]).To(Equal([]string{"testString"})) + + res.WriteHeader(200) + })) + }) + It(`Invoke ListVersions successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListVersions(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the ListVersionsOptions model + listVersionsOptionsModel := new(catalogmanagementv1.ListVersionsOptions) + listVersionsOptionsModel.Q = core.StringPtr("testString") + listVersionsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.ListVersions(listVersionsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke ListVersions with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListVersionsOptions model + listVersionsOptionsModel := new(catalogmanagementv1.ListVersionsOptions) + listVersionsOptionsModel.Q = core.StringPtr("testString") + listVersionsOptionsModel.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.ListVersions(listVersionsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the ListVersionsOptions model with no property values + listVersionsOptionsModelNew := new(catalogmanagementv1.ListVersionsOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.ListVersions(listVersionsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`GetRepos(getReposOptions *GetReposOptions) - Operation response error`, func() { + getReposPath := "/repo/testString/entries" + 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(getReposPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["repourl"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetRepos with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetReposOptions model + getReposOptionsModel := new(catalogmanagementv1.GetReposOptions) + getReposOptionsModel.Type = core.StringPtr("testString") + getReposOptionsModel.Repourl = core.StringPtr("testString") + getReposOptionsModel.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.GetRepos(getReposOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetRepos(getReposOptions *GetReposOptions)`, func() { + getReposPath := "/repo/testString/entries" + 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(getReposPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["repourl"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"chart": {"api_version": "ApiVersion", "created": "2019-01-01T12:00:00", "description": "Description", "deprecated": true, "digest": "Digest", "home": "Home", "icon": "Icon", "keywords": ["Keywords"], "maintainers": [{"email": "Email", "name": "Name"}], "name": "Name", "tiller_version": "TillerVersion", "urls": ["Urls"], "sources": ["Sources"], "version": "Version", "appVersion": "AppVersion"}}`) + })) + }) + It(`Invoke GetRepos successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetRepos(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetReposOptions model + getReposOptionsModel := new(catalogmanagementv1.GetReposOptions) + getReposOptionsModel.Type = core.StringPtr("testString") + getReposOptionsModel.Repourl = core.StringPtr("testString") + getReposOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetRepos(getReposOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetRepos with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetReposOptions model + getReposOptionsModel := new(catalogmanagementv1.GetReposOptions) + getReposOptionsModel.Type = core.StringPtr("testString") + getReposOptionsModel.Repourl = core.StringPtr("testString") + getReposOptionsModel.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.GetRepos(getReposOptionsModel) + 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 GetReposOptions model with no property values + getReposOptionsModelNew := new(catalogmanagementv1.GetReposOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetRepos(getReposOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetRepo(getRepoOptions *GetRepoOptions) - Operation response error`, func() { + getRepoPath := "/repo/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(getRepoPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["charturl"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetRepo with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetRepoOptions model + getRepoOptionsModel := new(catalogmanagementv1.GetRepoOptions) + getRepoOptionsModel.Type = core.StringPtr("testString") + getRepoOptionsModel.Charturl = core.StringPtr("testString") + getRepoOptionsModel.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.GetRepo(getRepoOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetRepo(getRepoOptions *GetRepoOptions)`, func() { + getRepoPath := "/repo/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(getRepoPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["charturl"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"chart": {"Chart.yaml": {"name": "Name", "description": "Description", "icon": "Icon", "version": "Version", "appVersion": "AppVersion"}, "sha": {"anyKey": "anyValue"}, "README.md": "READMEMd", "values-metadata": {"anyKey": "anyValue"}, "license-metadata": {"anyKey": "anyValue"}}}`) + })) + }) + It(`Invoke GetRepo successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetRepo(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetRepoOptions model + getRepoOptionsModel := new(catalogmanagementv1.GetRepoOptions) + getRepoOptionsModel.Type = core.StringPtr("testString") + getRepoOptionsModel.Charturl = core.StringPtr("testString") + getRepoOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetRepo(getRepoOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetRepo with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetRepoOptions model + getRepoOptionsModel := new(catalogmanagementv1.GetRepoOptions) + getRepoOptionsModel.Type = core.StringPtr("testString") + getRepoOptionsModel.Charturl = core.StringPtr("testString") + getRepoOptionsModel.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.GetRepo(getRepoOptionsModel) + 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 GetRepoOptions model with no property values + getRepoOptionsModelNew := new(catalogmanagementv1.GetRepoOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetRepo(getRepoOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`ListClusters(listClustersOptions *ListClustersOptions) - Operation response error`, func() { + listClustersPath := "/deploy/kubernetes/clusters" + 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(listClustersPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["limit"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["offset"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["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 ListClusters with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListClustersOptions model + listClustersOptionsModel := new(catalogmanagementv1.ListClustersOptions) + listClustersOptionsModel.Limit = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Offset = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Type = core.StringPtr("testString") + listClustersOptionsModel.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.ListClusters(listClustersOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListClusters(listClustersOptions *ListClustersOptions)`, func() { + listClustersPath := "/deploy/kubernetes/clusters" + 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(listClustersPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["limit"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["offset"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["type"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"resource_group_id": "ResourceGroupID", "resource_group_name": "ResourceGroupName", "id": "ID", "name": "Name", "region": "Region"}]}`) + })) + }) + It(`Invoke ListClusters successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListClusters(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ListClustersOptions model + listClustersOptionsModel := new(catalogmanagementv1.ListClustersOptions) + listClustersOptionsModel.Limit = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Offset = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Type = core.StringPtr("testString") + listClustersOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ListClusters(listClustersOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ListClusters with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListClustersOptions model + listClustersOptionsModel := new(catalogmanagementv1.ListClustersOptions) + listClustersOptionsModel.Limit = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Offset = core.Int64Ptr(int64(38)) + listClustersOptionsModel.Type = core.StringPtr("testString") + listClustersOptionsModel.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.ListClusters(listClustersOptionsModel) + 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(`GetCluster(getClusterOptions *GetClusterOptions) - Operation response error`, func() { + getClusterPath := "/deploy/kubernetes/clusters/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(getClusterPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetCluster with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetClusterOptions model + getClusterOptionsModel := new(catalogmanagementv1.GetClusterOptions) + getClusterOptionsModel.ClusterID = core.StringPtr("testString") + getClusterOptionsModel.Region = core.StringPtr("testString") + getClusterOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getClusterOptionsModel.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.GetCluster(getClusterOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetCluster(getClusterOptions *GetClusterOptions)`, func() { + getClusterPath := "/deploy/kubernetes/clusters/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(getClusterPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"resource_group_id": "ResourceGroupID", "resource_group_name": "ResourceGroupName", "id": "ID", "name": "Name", "region": "Region"}`) + })) + }) + It(`Invoke GetCluster successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetCluster(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetClusterOptions model + getClusterOptionsModel := new(catalogmanagementv1.GetClusterOptions) + getClusterOptionsModel.ClusterID = core.StringPtr("testString") + getClusterOptionsModel.Region = core.StringPtr("testString") + getClusterOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getClusterOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetCluster(getClusterOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetCluster with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetClusterOptions model + getClusterOptionsModel := new(catalogmanagementv1.GetClusterOptions) + getClusterOptionsModel.ClusterID = core.StringPtr("testString") + getClusterOptionsModel.Region = core.StringPtr("testString") + getClusterOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getClusterOptionsModel.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.GetCluster(getClusterOptionsModel) + 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 GetClusterOptions model with no property values + getClusterOptionsModelNew := new(catalogmanagementv1.GetClusterOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetCluster(getClusterOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetNamespaces(getNamespacesOptions *GetNamespacesOptions) - Operation response error`, func() { + getNamespacesPath := "/deploy/kubernetes/clusters/testString/namespaces" + 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(getNamespacesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["limit"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["offset"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetNamespaces with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetNamespacesOptions model + getNamespacesOptionsModel := new(catalogmanagementv1.GetNamespacesOptions) + getNamespacesOptionsModel.ClusterID = core.StringPtr("testString") + getNamespacesOptionsModel.Region = core.StringPtr("testString") + getNamespacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getNamespacesOptionsModel.Limit = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.Offset = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.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.GetNamespaces(getNamespacesOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetNamespaces(getNamespacesOptions *GetNamespacesOptions)`, func() { + getNamespacesPath := "/deploy/kubernetes/clusters/testString/namespaces" + 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(getNamespacesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["limit"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + Expect(req.URL.Query()["offset"]).To(Equal([]string{fmt.Sprint(int64(38))})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": ["Resources"]}`) + })) + }) + It(`Invoke GetNamespaces successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetNamespaces(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetNamespacesOptions model + getNamespacesOptionsModel := new(catalogmanagementv1.GetNamespacesOptions) + getNamespacesOptionsModel.ClusterID = core.StringPtr("testString") + getNamespacesOptionsModel.Region = core.StringPtr("testString") + getNamespacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getNamespacesOptionsModel.Limit = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.Offset = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetNamespaces(getNamespacesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetNamespaces with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetNamespacesOptions model + getNamespacesOptionsModel := new(catalogmanagementv1.GetNamespacesOptions) + getNamespacesOptionsModel.ClusterID = core.StringPtr("testString") + getNamespacesOptionsModel.Region = core.StringPtr("testString") + getNamespacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getNamespacesOptionsModel.Limit = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.Offset = core.Int64Ptr(int64(38)) + getNamespacesOptionsModel.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.GetNamespaces(getNamespacesOptionsModel) + 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 GetNamespacesOptions model with no property values + getNamespacesOptionsModelNew := new(catalogmanagementv1.GetNamespacesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetNamespaces(getNamespacesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`CreateOperator(createOperatorOptions *CreateOperatorOptions) - Operation response error`, func() { + createOperatorPath := "/deploy/kubernetes/olm/operator" + 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(createOperatorPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][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 CreateOperator with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CreateOperatorOptions model + createOperatorOptionsModel := new(catalogmanagementv1.CreateOperatorOptions) + createOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + createOperatorOptionsModel.ClusterID = core.StringPtr("testString") + createOperatorOptionsModel.Region = core.StringPtr("testString") + createOperatorOptionsModel.Namespaces = []string{"testString"} + createOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + createOperatorOptionsModel.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.CreateOperator(createOperatorOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CreateOperator(createOperatorOptions *CreateOperatorOptions)`, func() { + createOperatorPath := "/deploy/kubernetes/olm/operator" + 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(createOperatorPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `[{"phase": "Phase", "message": "Message", "link": "Link", "name": "Name", "version": "Version", "namespace": "Namespace", "package_name": "PackageName", "catalog_id": "CatalogID"}]`) + })) + }) + It(`Invoke CreateOperator successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CreateOperator(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the CreateOperatorOptions model + createOperatorOptionsModel := new(catalogmanagementv1.CreateOperatorOptions) + createOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + createOperatorOptionsModel.ClusterID = core.StringPtr("testString") + createOperatorOptionsModel.Region = core.StringPtr("testString") + createOperatorOptionsModel.Namespaces = []string{"testString"} + createOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + createOperatorOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.CreateOperator(createOperatorOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke CreateOperator with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CreateOperatorOptions model + createOperatorOptionsModel := new(catalogmanagementv1.CreateOperatorOptions) + createOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + createOperatorOptionsModel.ClusterID = core.StringPtr("testString") + createOperatorOptionsModel.Region = core.StringPtr("testString") + createOperatorOptionsModel.Namespaces = []string{"testString"} + createOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + createOperatorOptionsModel.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.CreateOperator(createOperatorOptionsModel) + 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 CreateOperatorOptions model with no property values + createOperatorOptionsModelNew := new(catalogmanagementv1.CreateOperatorOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.CreateOperator(createOperatorOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ListOperators(listOperatorsOptions *ListOperatorsOptions) - Operation response error`, func() { + listOperatorsPath := "/deploy/kubernetes/olm/operator" + 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(listOperatorsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_locator_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ListOperators with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListOperatorsOptions model + listOperatorsOptionsModel := new(catalogmanagementv1.ListOperatorsOptions) + listOperatorsOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + listOperatorsOptionsModel.ClusterID = core.StringPtr("testString") + listOperatorsOptionsModel.Region = core.StringPtr("testString") + listOperatorsOptionsModel.VersionLocatorID = core.StringPtr("testString") + listOperatorsOptionsModel.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.ListOperators(listOperatorsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListOperators(listOperatorsOptions *ListOperatorsOptions)`, func() { + listOperatorsPath := "/deploy/kubernetes/olm/operator" + 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(listOperatorsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_locator_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `[{"phase": "Phase", "message": "Message", "link": "Link", "name": "Name", "version": "Version", "namespace": "Namespace", "package_name": "PackageName", "catalog_id": "CatalogID"}]`) + })) + }) + It(`Invoke ListOperators successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListOperators(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ListOperatorsOptions model + listOperatorsOptionsModel := new(catalogmanagementv1.ListOperatorsOptions) + listOperatorsOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + listOperatorsOptionsModel.ClusterID = core.StringPtr("testString") + listOperatorsOptionsModel.Region = core.StringPtr("testString") + listOperatorsOptionsModel.VersionLocatorID = core.StringPtr("testString") + listOperatorsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ListOperators(listOperatorsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ListOperators with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListOperatorsOptions model + listOperatorsOptionsModel := new(catalogmanagementv1.ListOperatorsOptions) + listOperatorsOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + listOperatorsOptionsModel.ClusterID = core.StringPtr("testString") + listOperatorsOptionsModel.Region = core.StringPtr("testString") + listOperatorsOptionsModel.VersionLocatorID = core.StringPtr("testString") + listOperatorsOptionsModel.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.ListOperators(listOperatorsOptionsModel) + 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 ListOperatorsOptions model with no property values + listOperatorsOptionsModelNew := new(catalogmanagementv1.ListOperatorsOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ListOperators(listOperatorsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`ReplaceOperator(replaceOperatorOptions *ReplaceOperatorOptions) - Operation response error`, func() { + replaceOperatorPath := "/deploy/kubernetes/olm/operator" + 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(replaceOperatorPath)) + Expect(req.Method).To(Equal("PUT")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][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 ReplaceOperator with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReplaceOperatorOptions model + replaceOperatorOptionsModel := new(catalogmanagementv1.ReplaceOperatorOptions) + replaceOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + replaceOperatorOptionsModel.ClusterID = core.StringPtr("testString") + replaceOperatorOptionsModel.Region = core.StringPtr("testString") + replaceOperatorOptionsModel.Namespaces = []string{"testString"} + replaceOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + replaceOperatorOptionsModel.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.ReplaceOperator(replaceOperatorOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ReplaceOperator(replaceOperatorOptions *ReplaceOperatorOptions)`, func() { + replaceOperatorPath := "/deploy/kubernetes/olm/operator" + 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(replaceOperatorPath)) + Expect(req.Method).To(Equal("PUT")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `[{"phase": "Phase", "message": "Message", "link": "Link", "name": "Name", "version": "Version", "namespace": "Namespace", "package_name": "PackageName", "catalog_id": "CatalogID"}]`) + })) + }) + It(`Invoke ReplaceOperator successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ReplaceOperator(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ReplaceOperatorOptions model + replaceOperatorOptionsModel := new(catalogmanagementv1.ReplaceOperatorOptions) + replaceOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + replaceOperatorOptionsModel.ClusterID = core.StringPtr("testString") + replaceOperatorOptionsModel.Region = core.StringPtr("testString") + replaceOperatorOptionsModel.Namespaces = []string{"testString"} + replaceOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + replaceOperatorOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ReplaceOperator(replaceOperatorOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ReplaceOperator with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ReplaceOperatorOptions model + replaceOperatorOptionsModel := new(catalogmanagementv1.ReplaceOperatorOptions) + replaceOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + replaceOperatorOptionsModel.ClusterID = core.StringPtr("testString") + replaceOperatorOptionsModel.Region = core.StringPtr("testString") + replaceOperatorOptionsModel.Namespaces = []string{"testString"} + replaceOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + replaceOperatorOptionsModel.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.ReplaceOperator(replaceOperatorOptionsModel) + 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 ReplaceOperatorOptions model with no property values + replaceOperatorOptionsModelNew := new(catalogmanagementv1.ReplaceOperatorOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.ReplaceOperator(replaceOperatorOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeleteOperator(deleteOperatorOptions *DeleteOperatorOptions)`, func() { + deleteOperatorPath := "/deploy/kubernetes/olm/operator" + 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(deleteOperatorPath)) + Expect(req.Method).To(Equal("DELETE")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_locator_id"]).To(Equal([]string{"testString"})) + + res.WriteHeader(200) + })) + }) + It(`Invoke DeleteOperator successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeleteOperator(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeleteOperatorOptions model + deleteOperatorOptionsModel := new(catalogmanagementv1.DeleteOperatorOptions) + deleteOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + deleteOperatorOptionsModel.ClusterID = core.StringPtr("testString") + deleteOperatorOptionsModel.Region = core.StringPtr("testString") + deleteOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + deleteOperatorOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeleteOperator(deleteOperatorOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeleteOperator with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeleteOperatorOptions model + deleteOperatorOptionsModel := new(catalogmanagementv1.DeleteOperatorOptions) + deleteOperatorOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + deleteOperatorOptionsModel.ClusterID = core.StringPtr("testString") + deleteOperatorOptionsModel.Region = core.StringPtr("testString") + deleteOperatorOptionsModel.VersionLocatorID = core.StringPtr("testString") + deleteOperatorOptionsModel.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.DeleteOperator(deleteOperatorOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeleteOperatorOptions model with no property values + deleteOperatorOptionsModelNew := new(catalogmanagementv1.DeleteOperatorOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeleteOperator(deleteOperatorOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`InstallVersion(installVersionOptions *InstallVersionOptions)`, func() { + installVersionPath := "/versions/testString/install" + 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(installVersionPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.WriteHeader(202) + })) + }) + It(`Invoke InstallVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.InstallVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the InstallVersionOptions model + installVersionOptionsModel := new(catalogmanagementv1.InstallVersionOptions) + installVersionOptionsModel.VersionLocID = core.StringPtr("testString") + installVersionOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + installVersionOptionsModel.ClusterID = core.StringPtr("testString") + installVersionOptionsModel.Region = core.StringPtr("testString") + installVersionOptionsModel.Namespace = core.StringPtr("testString") + installVersionOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + installVersionOptionsModel.EntitlementApikey = core.StringPtr("testString") + installVersionOptionsModel.Schematics = deployRequestBodySchematicsModel + installVersionOptionsModel.Script = core.StringPtr("testString") + installVersionOptionsModel.ScriptID = core.StringPtr("testString") + installVersionOptionsModel.VersionLocatorID = core.StringPtr("testString") + installVersionOptionsModel.VcenterID = core.StringPtr("testString") + installVersionOptionsModel.VcenterPassword = core.StringPtr("testString") + installVersionOptionsModel.VcenterLocation = core.StringPtr("testString") + installVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.InstallVersion(installVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke InstallVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the InstallVersionOptions model + installVersionOptionsModel := new(catalogmanagementv1.InstallVersionOptions) + installVersionOptionsModel.VersionLocID = core.StringPtr("testString") + installVersionOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + installVersionOptionsModel.ClusterID = core.StringPtr("testString") + installVersionOptionsModel.Region = core.StringPtr("testString") + installVersionOptionsModel.Namespace = core.StringPtr("testString") + installVersionOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + installVersionOptionsModel.EntitlementApikey = core.StringPtr("testString") + installVersionOptionsModel.Schematics = deployRequestBodySchematicsModel + installVersionOptionsModel.Script = core.StringPtr("testString") + installVersionOptionsModel.ScriptID = core.StringPtr("testString") + installVersionOptionsModel.VersionLocatorID = core.StringPtr("testString") + installVersionOptionsModel.VcenterID = core.StringPtr("testString") + installVersionOptionsModel.VcenterPassword = core.StringPtr("testString") + installVersionOptionsModel.VcenterLocation = core.StringPtr("testString") + installVersionOptionsModel.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.InstallVersion(installVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the InstallVersionOptions model with no property values + installVersionOptionsModelNew := new(catalogmanagementv1.InstallVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.InstallVersion(installVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`PreinstallVersion(preinstallVersionOptions *PreinstallVersionOptions)`, func() { + preinstallVersionPath := "/versions/testString/preinstall" + 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(preinstallVersionPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.WriteHeader(202) + })) + }) + It(`Invoke PreinstallVersion successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.PreinstallVersion(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the PreinstallVersionOptions model + preinstallVersionOptionsModel := new(catalogmanagementv1.PreinstallVersionOptions) + preinstallVersionOptionsModel.VersionLocID = core.StringPtr("testString") + preinstallVersionOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + preinstallVersionOptionsModel.ClusterID = core.StringPtr("testString") + preinstallVersionOptionsModel.Region = core.StringPtr("testString") + preinstallVersionOptionsModel.Namespace = core.StringPtr("testString") + preinstallVersionOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + preinstallVersionOptionsModel.EntitlementApikey = core.StringPtr("testString") + preinstallVersionOptionsModel.Schematics = deployRequestBodySchematicsModel + preinstallVersionOptionsModel.Script = core.StringPtr("testString") + preinstallVersionOptionsModel.ScriptID = core.StringPtr("testString") + preinstallVersionOptionsModel.VersionLocatorID = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterID = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterPassword = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterLocation = core.StringPtr("testString") + preinstallVersionOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.PreinstallVersion(preinstallVersionOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke PreinstallVersion with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the PreinstallVersionOptions model + preinstallVersionOptionsModel := new(catalogmanagementv1.PreinstallVersionOptions) + preinstallVersionOptionsModel.VersionLocID = core.StringPtr("testString") + preinstallVersionOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + preinstallVersionOptionsModel.ClusterID = core.StringPtr("testString") + preinstallVersionOptionsModel.Region = core.StringPtr("testString") + preinstallVersionOptionsModel.Namespace = core.StringPtr("testString") + preinstallVersionOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + preinstallVersionOptionsModel.EntitlementApikey = core.StringPtr("testString") + preinstallVersionOptionsModel.Schematics = deployRequestBodySchematicsModel + preinstallVersionOptionsModel.Script = core.StringPtr("testString") + preinstallVersionOptionsModel.ScriptID = core.StringPtr("testString") + preinstallVersionOptionsModel.VersionLocatorID = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterID = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterPassword = core.StringPtr("testString") + preinstallVersionOptionsModel.VcenterLocation = core.StringPtr("testString") + preinstallVersionOptionsModel.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.PreinstallVersion(preinstallVersionOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the PreinstallVersionOptions model with no property values + preinstallVersionOptionsModelNew := new(catalogmanagementv1.PreinstallVersionOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.PreinstallVersion(preinstallVersionOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetPreinstall(getPreinstallOptions *GetPreinstallOptions) - Operation response error`, func() { + getPreinstallPath := "/versions/testString/preinstall" + 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(getPreinstallPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetPreinstall with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetPreinstallOptions model + getPreinstallOptionsModel := new(catalogmanagementv1.GetPreinstallOptions) + getPreinstallOptionsModel.VersionLocID = core.StringPtr("testString") + getPreinstallOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getPreinstallOptionsModel.ClusterID = core.StringPtr("testString") + getPreinstallOptionsModel.Region = core.StringPtr("testString") + getPreinstallOptionsModel.Namespace = core.StringPtr("testString") + getPreinstallOptionsModel.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.GetPreinstall(getPreinstallOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetPreinstall(getPreinstallOptions *GetPreinstallOptions)`, func() { + getPreinstallPath := "/versions/testString/preinstall" + 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(getPreinstallPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"metadata": {"cluster_id": "ClusterID", "region": "Region", "namespace": "Namespace", "workspace_id": "WorkspaceID", "workspace_name": "WorkspaceName"}, "release": {"deployments": [{"anyKey": "anyValue"}], "replicasets": [{"anyKey": "anyValue"}], "statefulsets": [{"anyKey": "anyValue"}], "pods": [{"anyKey": "anyValue"}], "errors": [{"anyKey": "anyValue"}]}, "content_mgmt": {"pods": [{"anyKey": "anyValue"}], "errors": [{"anyKey": "anyValue"}]}}`) + })) + }) + It(`Invoke GetPreinstall successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetPreinstall(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetPreinstallOptions model + getPreinstallOptionsModel := new(catalogmanagementv1.GetPreinstallOptions) + getPreinstallOptionsModel.VersionLocID = core.StringPtr("testString") + getPreinstallOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getPreinstallOptionsModel.ClusterID = core.StringPtr("testString") + getPreinstallOptionsModel.Region = core.StringPtr("testString") + getPreinstallOptionsModel.Namespace = core.StringPtr("testString") + getPreinstallOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetPreinstall(getPreinstallOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetPreinstall with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetPreinstallOptions model + getPreinstallOptionsModel := new(catalogmanagementv1.GetPreinstallOptions) + getPreinstallOptionsModel.VersionLocID = core.StringPtr("testString") + getPreinstallOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getPreinstallOptionsModel.ClusterID = core.StringPtr("testString") + getPreinstallOptionsModel.Region = core.StringPtr("testString") + getPreinstallOptionsModel.Namespace = core.StringPtr("testString") + getPreinstallOptionsModel.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.GetPreinstall(getPreinstallOptionsModel) + 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 GetPreinstallOptions model with no property values + getPreinstallOptionsModelNew := new(catalogmanagementv1.GetPreinstallOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetPreinstall(getPreinstallOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ValidationInstall(validationInstallOptions *ValidationInstallOptions)`, func() { + validationInstallPath := "/versions/testString/validation/install" + 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(validationInstallPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.WriteHeader(202) + })) + }) + It(`Invoke ValidationInstall successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ValidationInstall(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the ValidationInstallOptions model + validationInstallOptionsModel := new(catalogmanagementv1.ValidationInstallOptions) + validationInstallOptionsModel.VersionLocID = core.StringPtr("testString") + validationInstallOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + validationInstallOptionsModel.ClusterID = core.StringPtr("testString") + validationInstallOptionsModel.Region = core.StringPtr("testString") + validationInstallOptionsModel.Namespace = core.StringPtr("testString") + validationInstallOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + validationInstallOptionsModel.EntitlementApikey = core.StringPtr("testString") + validationInstallOptionsModel.Schematics = deployRequestBodySchematicsModel + validationInstallOptionsModel.Script = core.StringPtr("testString") + validationInstallOptionsModel.ScriptID = core.StringPtr("testString") + validationInstallOptionsModel.VersionLocatorID = core.StringPtr("testString") + validationInstallOptionsModel.VcenterID = core.StringPtr("testString") + validationInstallOptionsModel.VcenterPassword = core.StringPtr("testString") + validationInstallOptionsModel.VcenterLocation = core.StringPtr("testString") + validationInstallOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.ValidationInstall(validationInstallOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke ValidationInstall with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + + // Construct an instance of the ValidationInstallOptions model + validationInstallOptionsModel := new(catalogmanagementv1.ValidationInstallOptions) + validationInstallOptionsModel.VersionLocID = core.StringPtr("testString") + validationInstallOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + validationInstallOptionsModel.ClusterID = core.StringPtr("testString") + validationInstallOptionsModel.Region = core.StringPtr("testString") + validationInstallOptionsModel.Namespace = core.StringPtr("testString") + validationInstallOptionsModel.OverrideValues = map[string]interface{}{"anyKey": "anyValue"} + validationInstallOptionsModel.EntitlementApikey = core.StringPtr("testString") + validationInstallOptionsModel.Schematics = deployRequestBodySchematicsModel + validationInstallOptionsModel.Script = core.StringPtr("testString") + validationInstallOptionsModel.ScriptID = core.StringPtr("testString") + validationInstallOptionsModel.VersionLocatorID = core.StringPtr("testString") + validationInstallOptionsModel.VcenterID = core.StringPtr("testString") + validationInstallOptionsModel.VcenterPassword = core.StringPtr("testString") + validationInstallOptionsModel.VcenterLocation = core.StringPtr("testString") + validationInstallOptionsModel.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.ValidationInstall(validationInstallOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the ValidationInstallOptions model with no property values + validationInstallOptionsModelNew := new(catalogmanagementv1.ValidationInstallOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.ValidationInstall(validationInstallOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetValidationStatus(getValidationStatusOptions *GetValidationStatusOptions) - Operation response error`, func() { + getValidationStatusPath := "/versions/testString/validation/install" + 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(getValidationStatusPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][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 GetValidationStatus with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetValidationStatusOptions model + getValidationStatusOptionsModel := new(catalogmanagementv1.GetValidationStatusOptions) + getValidationStatusOptionsModel.VersionLocID = core.StringPtr("testString") + getValidationStatusOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getValidationStatusOptionsModel.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.GetValidationStatus(getValidationStatusOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetValidationStatus(getValidationStatusOptions *GetValidationStatusOptions)`, func() { + getValidationStatusPath := "/versions/testString/validation/install" + 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(getValidationStatusPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"validated": "2019-01-01T12:00:00", "requested": "2019-01-01T12:00:00", "state": "State", "last_operation": "LastOperation", "target": {"anyKey": "anyValue"}}`) + })) + }) + It(`Invoke GetValidationStatus successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetValidationStatus(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetValidationStatusOptions model + getValidationStatusOptionsModel := new(catalogmanagementv1.GetValidationStatusOptions) + getValidationStatusOptionsModel.VersionLocID = core.StringPtr("testString") + getValidationStatusOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getValidationStatusOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetValidationStatus(getValidationStatusOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetValidationStatus with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetValidationStatusOptions model + getValidationStatusOptionsModel := new(catalogmanagementv1.GetValidationStatusOptions) + getValidationStatusOptionsModel.VersionLocID = core.StringPtr("testString") + getValidationStatusOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getValidationStatusOptionsModel.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.GetValidationStatus(getValidationStatusOptionsModel) + 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 GetValidationStatusOptions model with no property values + getValidationStatusOptionsModelNew := new(catalogmanagementv1.GetValidationStatusOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetValidationStatus(getValidationStatusOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetOverrideValues(getOverrideValuesOptions *GetOverrideValuesOptions)`, func() { + getOverrideValuesPath := "/versions/testString/validation/overridevalues" + 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(getOverrideValuesPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"mapKey": "anyValue"}`) + })) + }) + It(`Invoke GetOverrideValues successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetOverrideValues(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetOverrideValuesOptions model + getOverrideValuesOptionsModel := new(catalogmanagementv1.GetOverrideValuesOptions) + getOverrideValuesOptionsModel.VersionLocID = core.StringPtr("testString") + getOverrideValuesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetOverrideValues(getOverrideValuesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetOverrideValues with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetOverrideValuesOptions model + getOverrideValuesOptionsModel := new(catalogmanagementv1.GetOverrideValuesOptions) + getOverrideValuesOptionsModel.VersionLocID = core.StringPtr("testString") + getOverrideValuesOptionsModel.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.GetOverrideValues(getOverrideValuesOptionsModel) + 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 GetOverrideValuesOptions model with no property values + getOverrideValuesOptionsModelNew := new(catalogmanagementv1.GetOverrideValuesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetOverrideValues(getOverrideValuesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetSchematicsWorkspaces(getSchematicsWorkspacesOptions *GetSchematicsWorkspacesOptions) - Operation response error`, func() { + getSchematicsWorkspacesPath := "/versions/testString/workspaces" + 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(getSchematicsWorkspacesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][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 GetSchematicsWorkspaces with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetSchematicsWorkspacesOptions model + getSchematicsWorkspacesOptionsModel := new(catalogmanagementv1.GetSchematicsWorkspacesOptions) + getSchematicsWorkspacesOptionsModel.VersionLocID = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.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.GetSchematicsWorkspaces(getSchematicsWorkspacesOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetSchematicsWorkspaces(getSchematicsWorkspacesOptions *GetSchematicsWorkspacesOptions)`, func() { + getSchematicsWorkspacesPath := "/versions/testString/workspaces" + 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(getSchematicsWorkspacesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.Header["X-Auth-Refresh-Token"]).ToNot(BeNil()) + Expect(req.Header["X-Auth-Refresh-Token"][0]).To(Equal(fmt.Sprintf("%v", "testString"))) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"id": "ID", "name": "Name", "type": ["Type"], "description": "Description", "tags": ["Tags"], "created_at": "2019-01-01T12:00:00", "created_by": "CreatedBy", "status": "Status", "workspace_status": {"frozen": true, "locked": true}, "template_ref": "TemplateRef", "template_repo": {"repo_url": "RepoURL", "chart_name": "ChartName", "script_name": "ScriptName", "uninstall_script_name": "UninstallScriptName", "folder_name": "FolderName", "repo_sha_value": "RepoShaValue"}, "template_data": [{"anyKey": "anyValue"}], "runtime_data": {"id": "ID", "engine_name": "EngineName", "engine_version": "EngineVersion", "state_store_url": "StateStoreURL", "log_store_url": "LogStoreURL"}, "shared_data": {"anyKey": "anyValue"}, "catalog_ref": {"item_id": "ItemID", "item_name": "ItemName", "item_url": "ItemURL"}}]}`) + })) + }) + It(`Invoke GetSchematicsWorkspaces successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetSchematicsWorkspaces(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetSchematicsWorkspacesOptions model + getSchematicsWorkspacesOptionsModel := new(catalogmanagementv1.GetSchematicsWorkspacesOptions) + getSchematicsWorkspacesOptionsModel.VersionLocID = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetSchematicsWorkspaces(getSchematicsWorkspacesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetSchematicsWorkspaces with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetSchematicsWorkspacesOptions model + getSchematicsWorkspacesOptionsModel := new(catalogmanagementv1.GetSchematicsWorkspacesOptions) + getSchematicsWorkspacesOptionsModel.VersionLocID = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.XAuthRefreshToken = core.StringPtr("testString") + getSchematicsWorkspacesOptionsModel.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.GetSchematicsWorkspaces(getSchematicsWorkspacesOptionsModel) + 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 GetSchematicsWorkspacesOptions model with no property values + getSchematicsWorkspacesOptionsModelNew := new(catalogmanagementv1.GetSchematicsWorkspacesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetSchematicsWorkspaces(getSchematicsWorkspacesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`CanDeploySchematics(canDeploySchematicsOptions *CanDeploySchematicsOptions) - Operation response error`, func() { + canDeploySchematicsPath := "/versions/testString/candeploy" + 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(canDeploySchematicsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["resource_group_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke CanDeploySchematics with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CanDeploySchematicsOptions model + canDeploySchematicsOptionsModel := new(catalogmanagementv1.CanDeploySchematicsOptions) + canDeploySchematicsOptionsModel.VersionLocID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ClusterID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Region = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Namespace = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ResourceGroupID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.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.CanDeploySchematics(canDeploySchematicsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CanDeploySchematics(canDeploySchematicsOptions *CanDeploySchematicsOptions)`, func() { + canDeploySchematicsPath := "/versions/testString/candeploy" + 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(canDeploySchematicsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["cluster_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["region"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["namespace"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["resource_group_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"pre_install": {"anyKey": "anyValue"}, "install": {"anyKey": "anyValue"}}`) + })) + }) + It(`Invoke CanDeploySchematics successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CanDeploySchematics(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the CanDeploySchematicsOptions model + canDeploySchematicsOptionsModel := new(catalogmanagementv1.CanDeploySchematicsOptions) + canDeploySchematicsOptionsModel.VersionLocID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ClusterID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Region = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Namespace = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ResourceGroupID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.CanDeploySchematics(canDeploySchematicsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke CanDeploySchematics with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CanDeploySchematicsOptions model + canDeploySchematicsOptionsModel := new(catalogmanagementv1.CanDeploySchematicsOptions) + canDeploySchematicsOptionsModel.VersionLocID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ClusterID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Region = core.StringPtr("testString") + canDeploySchematicsOptionsModel.Namespace = core.StringPtr("testString") + canDeploySchematicsOptionsModel.ResourceGroupID = core.StringPtr("testString") + canDeploySchematicsOptionsModel.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.CanDeploySchematics(canDeploySchematicsOptionsModel) + 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 CanDeploySchematicsOptions model with no property values + canDeploySchematicsOptionsModelNew := new(catalogmanagementv1.CanDeploySchematicsOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.CanDeploySchematics(canDeploySchematicsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetResourceGroups(getResourceGroupsOptions *GetResourceGroupsOptions) - Operation response error`, func() { + getResourceGroupsPath := "/deploy/schematics/resourcegroups" + 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(getResourceGroupsPath)) + 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 GetResourceGroups with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetResourceGroupsOptions model + getResourceGroupsOptionsModel := new(catalogmanagementv1.GetResourceGroupsOptions) + getResourceGroupsOptionsModel.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.GetResourceGroups(getResourceGroupsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetResourceGroups(getResourceGroupsOptions *GetResourceGroupsOptions)`, func() { + getResourceGroupsPath := "/deploy/schematics/resourcegroups" + 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(getResourceGroupsPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"offset": 6, "limit": 5, "total_count": 10, "resource_count": 13, "first": "First", "last": "Last", "prev": "Prev", "next": "Next", "resources": [{"id": "ID", "name": "Name", "crn": "Crn", "account_id": "AccountID", "state": "State", "default": false}]}`) + })) + }) + It(`Invoke GetResourceGroups successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetResourceGroups(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetResourceGroupsOptions model + getResourceGroupsOptionsModel := new(catalogmanagementv1.GetResourceGroupsOptions) + getResourceGroupsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetResourceGroups(getResourceGroupsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetResourceGroups with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetResourceGroupsOptions model + getResourceGroupsOptionsModel := new(catalogmanagementv1.GetResourceGroupsOptions) + getResourceGroupsOptionsModel.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.GetResourceGroups(getResourceGroupsOptionsModel) + 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(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + Describe(`GetLicenseProviders(getLicenseProvidersOptions *GetLicenseProvidersOptions) - Operation response error`, func() { + getLicenseProvidersPath := "/license/license_providers" + 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(getLicenseProvidersPath)) + 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 GetLicenseProviders with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicenseProvidersOptions model + getLicenseProvidersOptionsModel := new(catalogmanagementv1.GetLicenseProvidersOptions) + getLicenseProvidersOptionsModel.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.GetLicenseProviders(getLicenseProvidersOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetLicenseProviders(getLicenseProvidersOptions *GetLicenseProvidersOptions)`, func() { + getLicenseProvidersPath := "/license/license_providers" + 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(getLicenseProvidersPath)) + Expect(req.Method).To(Equal("GET")) + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"total_results": 12, "total_pages": 10, "prev_url": "PrevURL", "next_url": "NextURL", "resources": [{"name": "Name", "short_description": "ShortDescription", "id": "ID", "licence_type": "LicenceType", "offering_type": "OfferingType", "create_url": "CreateURL", "info_url": "InfoURL", "url": "URL", "crn": "Crn", "state": "State"}]}`) + })) + }) + It(`Invoke GetLicenseProviders successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetLicenseProviders(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetLicenseProvidersOptions model + getLicenseProvidersOptionsModel := new(catalogmanagementv1.GetLicenseProvidersOptions) + getLicenseProvidersOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetLicenseProviders(getLicenseProvidersOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetLicenseProviders with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicenseProvidersOptions model + getLicenseProvidersOptionsModel := new(catalogmanagementv1.GetLicenseProvidersOptions) + getLicenseProvidersOptionsModel.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.GetLicenseProviders(getLicenseProvidersOptionsModel) + 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(`ListLicenseEntitlements(listLicenseEntitlementsOptions *ListLicenseEntitlementsOptions) - Operation response error`, func() { + listLicenseEntitlementsPath := "/license/entitlements" + 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(listLicenseEntitlementsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_product_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["state"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke ListLicenseEntitlements with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListLicenseEntitlementsOptions model + listLicenseEntitlementsOptionsModel := new(catalogmanagementv1.ListLicenseEntitlementsOptions) + listLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.State = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.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.ListLicenseEntitlements(listLicenseEntitlementsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`ListLicenseEntitlements(listLicenseEntitlementsOptions *ListLicenseEntitlementsOptions)`, func() { + listLicenseEntitlementsPath := "/license/entitlements" + 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(listLicenseEntitlementsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_product_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["state"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"total_results": 12, "total_pages": 10, "prev_url": "PrevURL", "next_url": "NextURL", "resources": [{"name": "Name", "id": "ID", "crn": "Crn", "url": "URL", "offering_type": "OfferingType", "state": "State", "effective_from": "EffectiveFrom", "effective_until": "EffectiveUntil", "account_id": "AccountID", "owner_id": "OwnerID", "version_id": "VersionID", "license_offering_id": "LicenseOfferingID", "license_id": "LicenseID", "license_owner_id": "LicenseOwnerID", "license_type": "LicenseType", "license_provider_id": "LicenseProviderID", "license_provider_url": "LicenseProviderURL", "license_product_id": "LicenseProductID", "namespace_repository": "NamespaceRepository", "apikey": "Apikey", "create_by": "CreateBy", "update_by": "UpdateBy", "create_at": "CreateAt", "updated_at": "UpdatedAt", "history": [{"action": "Action", "user": "User", "date": "Date"}], "offering_list": [{"id": "ID", "name": "Name", "label": "Label", "offering_icon_url": "OfferingIconURL", "account_id": "AccountID", "catalog_id": "CatalogID"}]}]}`) + })) + }) + It(`Invoke ListLicenseEntitlements successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.ListLicenseEntitlements(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the ListLicenseEntitlementsOptions model + listLicenseEntitlementsOptionsModel := new(catalogmanagementv1.ListLicenseEntitlementsOptions) + listLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.State = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.ListLicenseEntitlements(listLicenseEntitlementsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke ListLicenseEntitlements with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the ListLicenseEntitlementsOptions model + listLicenseEntitlementsOptionsModel := new(catalogmanagementv1.ListLicenseEntitlementsOptions) + listLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.State = core.StringPtr("testString") + listLicenseEntitlementsOptionsModel.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.ListLicenseEntitlements(listLicenseEntitlementsOptionsModel) + 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(`CreateLicenseEntitlement(createLicenseEntitlementOptions *CreateLicenseEntitlementOptions) - Operation response error`, func() { + createLicenseEntitlementPath := "/license/entitlements" + 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(createLicenseEntitlementPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke CreateLicenseEntitlement with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CreateLicenseEntitlementOptions model + createLicenseEntitlementOptionsModel := new(catalogmanagementv1.CreateLicenseEntitlementOptions) + createLicenseEntitlementOptionsModel.Name = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveFrom = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveUntil = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.VersionID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseOwnerID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProviderID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProductID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.AccountID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.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.CreateLicenseEntitlement(createLicenseEntitlementOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`CreateLicenseEntitlement(createLicenseEntitlementOptions *CreateLicenseEntitlementOptions)`, func() { + createLicenseEntitlementPath := "/license/entitlements" + 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(createLicenseEntitlementPath)) + Expect(req.Method).To(Equal("POST")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"name": "Name", "id": "ID", "crn": "Crn", "url": "URL", "offering_type": "OfferingType", "state": "State", "effective_from": "EffectiveFrom", "effective_until": "EffectiveUntil", "account_id": "AccountID", "owner_id": "OwnerID", "version_id": "VersionID", "license_offering_id": "LicenseOfferingID", "license_id": "LicenseID", "license_owner_id": "LicenseOwnerID", "license_type": "LicenseType", "license_provider_id": "LicenseProviderID", "license_provider_url": "LicenseProviderURL", "license_product_id": "LicenseProductID", "namespace_repository": "NamespaceRepository", "apikey": "Apikey", "create_by": "CreateBy", "update_by": "UpdateBy", "create_at": "CreateAt", "updated_at": "UpdatedAt", "history": [{"action": "Action", "user": "User", "date": "Date"}], "offering_list": [{"id": "ID", "name": "Name", "label": "Label", "offering_icon_url": "OfferingIconURL", "account_id": "AccountID", "catalog_id": "CatalogID"}]}`) + })) + }) + It(`Invoke CreateLicenseEntitlement successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.CreateLicenseEntitlement(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the CreateLicenseEntitlementOptions model + createLicenseEntitlementOptionsModel := new(catalogmanagementv1.CreateLicenseEntitlementOptions) + createLicenseEntitlementOptionsModel.Name = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveFrom = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveUntil = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.VersionID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseOwnerID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProviderID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProductID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.AccountID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.CreateLicenseEntitlement(createLicenseEntitlementOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke CreateLicenseEntitlement with error: Operation request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the CreateLicenseEntitlementOptions model + createLicenseEntitlementOptionsModel := new(catalogmanagementv1.CreateLicenseEntitlementOptions) + createLicenseEntitlementOptionsModel.Name = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveFrom = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.EffectiveUntil = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.VersionID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseOwnerID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProviderID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.LicenseProductID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.AccountID = core.StringPtr("testString") + createLicenseEntitlementOptionsModel.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.CreateLicenseEntitlement(createLicenseEntitlementOptionsModel) + 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(`GetLicenseEntitlements(getLicenseEntitlementsOptions *GetLicenseEntitlementsOptions) - Operation response error`, func() { + getLicenseEntitlementsPath := "/license/entitlements/productID/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(getLicenseEntitlementsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetLicenseEntitlements with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicenseEntitlementsOptions model + getLicenseEntitlementsOptionsModel := new(catalogmanagementv1.GetLicenseEntitlementsOptions) + getLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.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.GetLicenseEntitlements(getLicenseEntitlementsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetLicenseEntitlements(getLicenseEntitlementsOptions *GetLicenseEntitlementsOptions)`, func() { + getLicenseEntitlementsPath := "/license/entitlements/productID/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(getLicenseEntitlementsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["version_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"total_results": 12, "total_pages": 10, "prev_url": "PrevURL", "next_url": "NextURL", "resources": [{"name": "Name", "id": "ID", "crn": "Crn", "url": "URL", "offering_type": "OfferingType", "state": "State", "effective_from": "EffectiveFrom", "effective_until": "EffectiveUntil", "account_id": "AccountID", "owner_id": "OwnerID", "version_id": "VersionID", "license_offering_id": "LicenseOfferingID", "license_id": "LicenseID", "license_owner_id": "LicenseOwnerID", "license_type": "LicenseType", "license_provider_id": "LicenseProviderID", "license_provider_url": "LicenseProviderURL", "license_product_id": "LicenseProductID", "namespace_repository": "NamespaceRepository", "apikey": "Apikey", "create_by": "CreateBy", "update_by": "UpdateBy", "create_at": "CreateAt", "updated_at": "UpdatedAt", "history": [{"action": "Action", "user": "User", "date": "Date"}], "offering_list": [{"id": "ID", "name": "Name", "label": "Label", "offering_icon_url": "OfferingIconURL", "account_id": "AccountID", "catalog_id": "CatalogID"}]}]}`) + })) + }) + It(`Invoke GetLicenseEntitlements successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetLicenseEntitlements(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetLicenseEntitlementsOptions model + getLicenseEntitlementsOptionsModel := new(catalogmanagementv1.GetLicenseEntitlementsOptions) + getLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetLicenseEntitlements(getLicenseEntitlementsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetLicenseEntitlements with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicenseEntitlementsOptions model + getLicenseEntitlementsOptionsModel := new(catalogmanagementv1.GetLicenseEntitlementsOptions) + getLicenseEntitlementsOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.AccountID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.VersionID = core.StringPtr("testString") + getLicenseEntitlementsOptionsModel.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.GetLicenseEntitlements(getLicenseEntitlementsOptionsModel) + 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 GetLicenseEntitlementsOptions model with no property values + getLicenseEntitlementsOptionsModelNew := new(catalogmanagementv1.GetLicenseEntitlementsOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetLicenseEntitlements(getLicenseEntitlementsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`DeleteLicenseEntitlement(deleteLicenseEntitlementOptions *DeleteLicenseEntitlementOptions)`, func() { + deleteLicenseEntitlementPath := "/license/entitlements/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(deleteLicenseEntitlementPath)) + Expect(req.Method).To(Equal("DELETE")) + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + res.WriteHeader(200) + })) + }) + It(`Invoke DeleteLicenseEntitlement successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.DeleteLicenseEntitlement(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the DeleteLicenseEntitlementOptions model + deleteLicenseEntitlementOptionsModel := new(catalogmanagementv1.DeleteLicenseEntitlementOptions) + deleteLicenseEntitlementOptionsModel.EntitlementID = core.StringPtr("testString") + deleteLicenseEntitlementOptionsModel.AccountID = core.StringPtr("testString") + deleteLicenseEntitlementOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.DeleteLicenseEntitlement(deleteLicenseEntitlementOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke DeleteLicenseEntitlement with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the DeleteLicenseEntitlementOptions model + deleteLicenseEntitlementOptionsModel := new(catalogmanagementv1.DeleteLicenseEntitlementOptions) + deleteLicenseEntitlementOptionsModel.EntitlementID = core.StringPtr("testString") + deleteLicenseEntitlementOptionsModel.AccountID = core.StringPtr("testString") + deleteLicenseEntitlementOptionsModel.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.DeleteLicenseEntitlement(deleteLicenseEntitlementOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the DeleteLicenseEntitlementOptions model with no property values + deleteLicenseEntitlementOptionsModelNew := new(catalogmanagementv1.DeleteLicenseEntitlementOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.DeleteLicenseEntitlement(deleteLicenseEntitlementOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`GetLicenses(getLicensesOptions *GetLicensesOptions) - Operation response error`, func() { + getLicensesPath := "/license/licenses" + 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(getLicensesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["license_provider_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["name"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_type"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_product_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `} this is not valid json {`) + })) + }) + It(`Invoke GetLicenses with error: Operation response processing error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicensesOptions model + getLicensesOptionsModel := new(catalogmanagementv1.GetLicensesOptions) + getLicensesOptionsModel.LicenseProviderID = core.StringPtr("testString") + getLicensesOptionsModel.AccountID = core.StringPtr("testString") + getLicensesOptionsModel.Name = core.StringPtr("testString") + getLicensesOptionsModel.LicenseType = core.StringPtr("testString") + getLicensesOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicensesOptionsModel.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.GetLicenses(getLicensesOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`GetLicenses(getLicensesOptions *GetLicensesOptions)`, func() { + getLicensesPath := "/license/licenses" + 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(getLicensesPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["license_provider_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["account_id"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["name"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_type"]).To(Equal([]string{"testString"})) + + Expect(req.URL.Query()["license_product_id"]).To(Equal([]string{"testString"})) + + res.Header().Set("Content-type", "application/json") + res.WriteHeader(200) + fmt.Fprintf(res, `{"total_results": 12, "total_pages": 10, "prev_url": "PrevURL", "next_url": "NextURL", "resources": [{"name": "Name", "offering_type": "OfferingType", "seats_allowed": "SeatsAllowed", "seats_used": "SeatsUsed", "owner_id": "OwnerID", "license_offering_id": "LicenseOfferingID", "license_id": "LicenseID", "license_owner_id": "LicenseOwnerID", "license_type": "LicenseType", "license_provider_id": "LicenseProviderID", "license_product_id": "LicenseProductID", "license_provider_url": "LicenseProviderURL", "effective_from": "EffectiveFrom", "effective_until": "EffectiveUntil", "internal": true, "offering_list": [{"id": "ID", "name": "Name", "label": "Label", "offering_icon_url": "OfferingIconURL", "account_id": "AccountID", "catalog_id": "CatalogID"}]}]}`) + })) + }) + It(`Invoke GetLicenses successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.GetLicenses(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + + // Construct an instance of the GetLicensesOptions model + getLicensesOptionsModel := new(catalogmanagementv1.GetLicensesOptions) + getLicensesOptionsModel.LicenseProviderID = core.StringPtr("testString") + getLicensesOptionsModel.AccountID = core.StringPtr("testString") + getLicensesOptionsModel.Name = core.StringPtr("testString") + getLicensesOptionsModel.LicenseType = core.StringPtr("testString") + getLicensesOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicensesOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + result, response, operationErr = testService.GetLicenses(getLicensesOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + Expect(result).ToNot(BeNil()) + }) + It(`Invoke GetLicenses with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the GetLicensesOptions model + getLicensesOptionsModel := new(catalogmanagementv1.GetLicensesOptions) + getLicensesOptionsModel.LicenseProviderID = core.StringPtr("testString") + getLicensesOptionsModel.AccountID = core.StringPtr("testString") + getLicensesOptionsModel.Name = core.StringPtr("testString") + getLicensesOptionsModel.LicenseType = core.StringPtr("testString") + getLicensesOptionsModel.LicenseProductID = core.StringPtr("testString") + getLicensesOptionsModel.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.GetLicenses(getLicensesOptionsModel) + 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 GetLicensesOptions model with no property values + getLicensesOptionsModelNew := new(catalogmanagementv1.GetLicensesOptions) + // Invoke operation with invalid model (negative test) + result, response, operationErr = testService.GetLicenses(getLicensesOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + Expect(result).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + Describe(`Service constructor tests`, func() { + It(`Instantiate service client`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testService).ToNot(BeNil()) + Expect(testServiceErr).To(BeNil()) + }) + It(`Instantiate service client with error: Invalid URL`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + }) + It(`Instantiate service client with error: Invalid Auth`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "https://catalogmanagementv1/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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "noauth", + } + + It(`Create service client using external config successfully`, func() { + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + 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 := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + 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{ + "CATALOG_MANAGEMENT_URL": "https://catalogmanagementv1/api", + "CATALOG_MANAGEMENT_AUTH_TYPE": "someOtherAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + }) + + 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{ + "CATALOG_MANAGEMENT_AUTH_TYPE": "NOAuth", + } + + SetTestEnvironment(testEnvironment) + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1UsingExternalConfig(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "{BAD_URL_STRING", + }) + + It(`Instantiate service client with error`, func() { + Expect(testService).To(BeNil()) + Expect(testServiceErr).ToNot(BeNil()) + ClearTestEnvironment(testEnvironment) + }) + }) + }) + + Describe(`SearchLicenseVersions(searchLicenseVersionsOptions *SearchLicenseVersionsOptions)`, func() { + searchLicenseVersionsPath := "/search/license/versions" + 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(searchLicenseVersionsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["q"]).To(Equal([]string{"testString"})) + + res.WriteHeader(200) + })) + }) + It(`Invoke SearchLicenseVersions successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.SearchLicenseVersions(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the SearchLicenseVersionsOptions model + searchLicenseVersionsOptionsModel := new(catalogmanagementv1.SearchLicenseVersionsOptions) + searchLicenseVersionsOptionsModel.Q = core.StringPtr("testString") + searchLicenseVersionsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.SearchLicenseVersions(searchLicenseVersionsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke SearchLicenseVersions with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the SearchLicenseVersionsOptions model + searchLicenseVersionsOptionsModel := new(catalogmanagementv1.SearchLicenseVersionsOptions) + searchLicenseVersionsOptionsModel.Q = core.StringPtr("testString") + searchLicenseVersionsOptionsModel.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.SearchLicenseVersions(searchLicenseVersionsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the SearchLicenseVersionsOptions model with no property values + searchLicenseVersionsOptionsModelNew := new(catalogmanagementv1.SearchLicenseVersionsOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.SearchLicenseVersions(searchLicenseVersionsOptionsModelNew) + Expect(operationErr).ToNot(BeNil()) + Expect(response).To(BeNil()) + }) + AfterEach(func() { + testServer.Close() + }) + }) + }) + + Describe(`SearchLicenseOfferings(searchLicenseOfferingsOptions *SearchLicenseOfferingsOptions)`, func() { + searchLicenseOfferingsPath := "/search/license/offerings" + 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(searchLicenseOfferingsPath)) + Expect(req.Method).To(Equal("GET")) + Expect(req.URL.Query()["q"]).To(Equal([]string{"testString"})) + + res.WriteHeader(200) + })) + }) + It(`Invoke SearchLicenseOfferings successfully`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + 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.SearchLicenseOfferings(nil) + Expect(operationErr).NotTo(BeNil()) + Expect(response).To(BeNil()) + + // Construct an instance of the SearchLicenseOfferingsOptions model + searchLicenseOfferingsOptionsModel := new(catalogmanagementv1.SearchLicenseOfferingsOptions) + searchLicenseOfferingsOptionsModel.Q = core.StringPtr("testString") + searchLicenseOfferingsOptionsModel.Headers = map[string]string{"x-custom-header": "x-custom-value"} + + // Invoke operation with valid options model (positive test) + response, operationErr = testService.SearchLicenseOfferings(searchLicenseOfferingsOptionsModel) + Expect(operationErr).To(BeNil()) + Expect(response).ToNot(BeNil()) + }) + It(`Invoke SearchLicenseOfferings with error: Operation validation and request error`, func() { + testService, testServiceErr := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: testServer.URL, + Authenticator: &core.NoAuthAuthenticator{}, + }) + Expect(testServiceErr).To(BeNil()) + Expect(testService).ToNot(BeNil()) + + // Construct an instance of the SearchLicenseOfferingsOptions model + searchLicenseOfferingsOptionsModel := new(catalogmanagementv1.SearchLicenseOfferingsOptions) + searchLicenseOfferingsOptionsModel.Q = core.StringPtr("testString") + searchLicenseOfferingsOptionsModel.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.SearchLicenseOfferings(searchLicenseOfferingsOptionsModel) + Expect(operationErr).ToNot(BeNil()) + Expect(operationErr.Error()).To(ContainSubstring(core.ERRORMSG_SERVICE_URL_MISSING)) + Expect(response).To(BeNil()) + // Construct a second instance of the SearchLicenseOfferingsOptions model with no property values + searchLicenseOfferingsOptionsModelNew := new(catalogmanagementv1.SearchLicenseOfferingsOptions) + // Invoke operation with invalid model (negative test) + response, operationErr = testService.SearchLicenseOfferings(searchLicenseOfferingsOptionsModelNew) + 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, _ := catalogmanagementv1.NewCatalogManagementV1(&catalogmanagementv1.CatalogManagementV1Options{ + URL: "http://catalogmanagementv1modelgenerator.com", + Authenticator: &core.NoAuthAuthenticator{}, + }) + It(`Invoke NewAccountPublishVersionOptions successfully`, func() { + // Construct an instance of the AccountPublishVersionOptions model + versionLocID := "testString" + accountPublishVersionOptionsModel := testService.NewAccountPublishVersionOptions(versionLocID) + accountPublishVersionOptionsModel.SetVersionLocID("testString") + accountPublishVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(accountPublishVersionOptionsModel).ToNot(BeNil()) + Expect(accountPublishVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(accountPublishVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCanDeploySchematicsOptions successfully`, func() { + // Construct an instance of the CanDeploySchematicsOptions model + versionLocID := "testString" + clusterID := "testString" + region := "testString" + canDeploySchematicsOptionsModel := testService.NewCanDeploySchematicsOptions(versionLocID, clusterID, region) + canDeploySchematicsOptionsModel.SetVersionLocID("testString") + canDeploySchematicsOptionsModel.SetClusterID("testString") + canDeploySchematicsOptionsModel.SetRegion("testString") + canDeploySchematicsOptionsModel.SetNamespace("testString") + canDeploySchematicsOptionsModel.SetResourceGroupID("testString") + canDeploySchematicsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(canDeploySchematicsOptionsModel).ToNot(BeNil()) + Expect(canDeploySchematicsOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(canDeploySchematicsOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(canDeploySchematicsOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(canDeploySchematicsOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(canDeploySchematicsOptionsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + Expect(canDeploySchematicsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCommitVersionOptions successfully`, func() { + // Construct an instance of the CommitVersionOptions model + versionLocID := "testString" + commitVersionOptionsModel := testService.NewCommitVersionOptions(versionLocID) + commitVersionOptionsModel.SetVersionLocID("testString") + commitVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(commitVersionOptionsModel).ToNot(BeNil()) + Expect(commitVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(commitVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCreateCatalogOptions successfully`, func() { + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + Expect(filterTermsModel).ToNot(BeNil()) + filterTermsModel.FilterTerms = []string{"testString"} + Expect(filterTermsModel.FilterTerms).To(Equal([]string{"testString"})) + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + Expect(syndicationClusterModel).ToNot(BeNil()) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + Expect(syndicationClusterModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.ResourceGroupName).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Namespaces).To(Equal([]string{"testString"})) + Expect(syndicationClusterModel.AllNamespaces).To(Equal(core.BoolPtr(true))) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + Expect(categoryFilterModel).ToNot(BeNil()) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + Expect(categoryFilterModel.Include).To(Equal(core.BoolPtr(true))) + Expect(categoryFilterModel.Filter).To(Equal(filterTermsModel)) + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + Expect(idFilterModel).ToNot(BeNil()) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + Expect(idFilterModel.Include).To(Equal(filterTermsModel)) + Expect(idFilterModel.Exclude).To(Equal(filterTermsModel)) + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + Expect(syndicationAuthorizationModel).ToNot(BeNil()) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + Expect(syndicationAuthorizationModel.Token).To(Equal(core.StringPtr("testString"))) + Expect(syndicationAuthorizationModel.LastRun).To(Equal(CreateMockDateTime())) + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + Expect(syndicationHistoryModel).ToNot(BeNil()) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + Expect(syndicationHistoryModel.Namespaces).To(Equal([]string{"testString"})) + Expect(syndicationHistoryModel.Clusters).To(Equal([]catalogmanagementv1.SyndicationCluster{*syndicationClusterModel})) + Expect(syndicationHistoryModel.LastRun).To(Equal(CreateMockDateTime())) + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + Expect(featureModel).ToNot(BeNil()) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + Expect(featureModel.Title).To(Equal(core.StringPtr("testString"))) + Expect(featureModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + Expect(filtersModel).ToNot(BeNil()) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + Expect(filtersModel.IncludeAll).To(Equal(core.BoolPtr(true))) + Expect(filtersModel.CategoryFilters).To(Equal(make(map[string]catalogmanagementv1.CategoryFilter))) + Expect(filtersModel.IdFilters).To(Equal(idFilterModel)) + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + Expect(syndicationResourceModel).ToNot(BeNil()) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + Expect(syndicationResourceModel.RemoveRelatedComponents).To(Equal(core.BoolPtr(true))) + Expect(syndicationResourceModel.Clusters).To(Equal([]catalogmanagementv1.SyndicationCluster{*syndicationClusterModel})) + Expect(syndicationResourceModel.History).To(Equal(syndicationHistoryModel)) + Expect(syndicationResourceModel.Authorization).To(Equal(syndicationAuthorizationModel)) + + // Construct an instance of the CreateCatalogOptions model + createCatalogOptionsModel := testService.NewCreateCatalogOptions() + createCatalogOptionsModel.SetID("testString") + createCatalogOptionsModel.SetRev("testString") + createCatalogOptionsModel.SetLabel("testString") + createCatalogOptionsModel.SetShortDescription("testString") + createCatalogOptionsModel.SetCatalogIconURL("testString") + createCatalogOptionsModel.SetTags([]string{"testString"}) + createCatalogOptionsModel.SetURL("testString") + createCatalogOptionsModel.SetCrn("testString") + createCatalogOptionsModel.SetOfferingsURL("testString") + createCatalogOptionsModel.SetFeatures([]catalogmanagementv1.Feature{*featureModel}) + createCatalogOptionsModel.SetDisabled(true) + createCatalogOptionsModel.SetCreated(CreateMockDateTime()) + createCatalogOptionsModel.SetUpdated(CreateMockDateTime()) + createCatalogOptionsModel.SetResourceGroupID("testString") + createCatalogOptionsModel.SetOwningAccount("testString") + createCatalogOptionsModel.SetCatalogFilters(filtersModel) + createCatalogOptionsModel.SetSyndicationSettings(syndicationResourceModel) + createCatalogOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(createCatalogOptionsModel).ToNot(BeNil()) + Expect(createCatalogOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.CatalogIconURL).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(createCatalogOptionsModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.OfferingsURL).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.Features).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(createCatalogOptionsModel.Disabled).To(Equal(core.BoolPtr(true))) + Expect(createCatalogOptionsModel.Created).To(Equal(CreateMockDateTime())) + Expect(createCatalogOptionsModel.Updated).To(Equal(CreateMockDateTime())) + Expect(createCatalogOptionsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.OwningAccount).To(Equal(core.StringPtr("testString"))) + Expect(createCatalogOptionsModel.CatalogFilters).To(Equal(filtersModel)) + Expect(createCatalogOptionsModel.SyndicationSettings).To(Equal(syndicationResourceModel)) + Expect(createCatalogOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCreateLicenseEntitlementOptions successfully`, func() { + // Construct an instance of the CreateLicenseEntitlementOptions model + createLicenseEntitlementOptionsModel := testService.NewCreateLicenseEntitlementOptions() + createLicenseEntitlementOptionsModel.SetName("testString") + createLicenseEntitlementOptionsModel.SetEffectiveFrom("testString") + createLicenseEntitlementOptionsModel.SetEffectiveUntil("testString") + createLicenseEntitlementOptionsModel.SetVersionID("testString") + createLicenseEntitlementOptionsModel.SetLicenseID("testString") + createLicenseEntitlementOptionsModel.SetLicenseOwnerID("testString") + createLicenseEntitlementOptionsModel.SetLicenseProviderID("testString") + createLicenseEntitlementOptionsModel.SetLicenseProductID("testString") + createLicenseEntitlementOptionsModel.SetAccountID("testString") + createLicenseEntitlementOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(createLicenseEntitlementOptionsModel).ToNot(BeNil()) + Expect(createLicenseEntitlementOptionsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.EffectiveFrom).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.EffectiveUntil).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.VersionID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.LicenseID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.LicenseOwnerID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.LicenseProviderID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.LicenseProductID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.AccountID).To(Equal(core.StringPtr("testString"))) + Expect(createLicenseEntitlementOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCreateOfferingOptions successfully`, func() { + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + Expect(configurationModel).ToNot(BeNil()) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + Expect(configurationModel.Key).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.DefaultValue).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.ValueConstraint).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Description).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Required).To(Equal(core.BoolPtr(true))) + Expect(configurationModel.Options).To(Equal([]interface{}{map[string]interface{}{"anyKey": "anyValue"}})) + Expect(configurationModel.Hidden).To(Equal(core.BoolPtr(true))) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + Expect(deploymentModel).ToNot(BeNil()) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + Expect(deploymentModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(deploymentModel.Tags).To(Equal([]string{"testString"})) + Expect(deploymentModel.Created).To(Equal(CreateMockDateTime())) + Expect(deploymentModel.Updated).To(Equal(CreateMockDateTime())) + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + Expect(featureModel).ToNot(BeNil()) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + Expect(featureModel.Title).To(Equal(core.StringPtr("testString"))) + Expect(featureModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + Expect(licenseModel).ToNot(BeNil()) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + Expect(licenseModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + Expect(resourceModel).ToNot(BeNil()) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + Expect(resourceModel.Type).To(Equal(core.StringPtr("mem"))) + Expect(resourceModel.Value).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + Expect(scriptModel).ToNot(BeNil()) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + Expect(scriptModel.Instructions).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.Script).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.ScriptPermission).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.DeleteScript).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.Scope).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + Expect(stateModel).ToNot(BeNil()) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + Expect(stateModel.Current).To(Equal(core.StringPtr("testString"))) + Expect(stateModel.CurrentEntered).To(Equal(CreateMockDateTime())) + Expect(stateModel.Pending).To(Equal(core.StringPtr("testString"))) + Expect(stateModel.PendingRequested).To(Equal(CreateMockDateTime())) + Expect(stateModel.Previous).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + Expect(validationModel).ToNot(BeNil()) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + Expect(validationModel.Validated).To(Equal(CreateMockDateTime())) + Expect(validationModel.Requested).To(Equal(CreateMockDateTime())) + Expect(validationModel.State).To(Equal(core.StringPtr("testString"))) + Expect(validationModel.LastOperation).To(Equal(core.StringPtr("testString"))) + Expect(validationModel.Target).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + Expect(versionEntitlementModel).ToNot(BeNil()) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + Expect(versionEntitlementModel.ProviderName).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.ProviderID).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.ProductID).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.PartNumbers).To(Equal([]string{"testString"})) + Expect(versionEntitlementModel.ImageRepoName).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + Expect(planModel).ToNot(BeNil()) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + Expect(planModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(planModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(planModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(planModel.Tags).To(Equal([]string{"testString"})) + Expect(planModel.AdditionalFeatures).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(planModel.Created).To(Equal(CreateMockDateTime())) + Expect(planModel.Updated).To(Equal(CreateMockDateTime())) + Expect(planModel.Deployments).To(Equal([]catalogmanagementv1.Deployment{*deploymentModel})) + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + Expect(versionModel).ToNot(BeNil()) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + Expect(versionModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Version).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Sha).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Created).To(Equal(CreateMockDateTime())) + Expect(versionModel.Updated).To(Equal(CreateMockDateTime())) + Expect(versionModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.CatalogID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.KindID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Tags).To(Equal([]string{"testString"})) + Expect(versionModel.RepoURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.SourceURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.TgzURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Configuration).To(Equal([]catalogmanagementv1.Configuration{*configurationModel})) + Expect(versionModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(versionModel.Validation).To(Equal(validationModel)) + Expect(versionModel.RequiredResources).To(Equal([]catalogmanagementv1.Resource{*resourceModel})) + Expect(versionModel.SingleInstance).To(Equal(core.BoolPtr(true))) + Expect(versionModel.Install).To(Equal(scriptModel)) + Expect(versionModel.PreInstall).To(Equal([]catalogmanagementv1.Script{*scriptModel})) + Expect(versionModel.Entitlement).To(Equal(versionEntitlementModel)) + Expect(versionModel.Licenses).To(Equal([]catalogmanagementv1.License{*licenseModel})) + Expect(versionModel.ImageManifestURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Deprecated).To(Equal(core.BoolPtr(true))) + Expect(versionModel.PackageVersion).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.State).To(Equal(stateModel)) + Expect(versionModel.VersionLocator).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.ConsoleURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.WhitelistedAccounts).To(Equal([]string{"testString"})) + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + Expect(kindModel).ToNot(BeNil()) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + Expect(kindModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.FormatKind).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.TargetKind).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(kindModel.InstallDescription).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.Tags).To(Equal([]string{"testString"})) + Expect(kindModel.AdditionalFeatures).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(kindModel.Created).To(Equal(CreateMockDateTime())) + Expect(kindModel.Updated).To(Equal(CreateMockDateTime())) + Expect(kindModel.Versions).To(Equal([]catalogmanagementv1.Version{*versionModel})) + Expect(kindModel.Plans).To(Equal([]catalogmanagementv1.Plan{*planModel})) + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + Expect(ratingModel).ToNot(BeNil()) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + Expect(ratingModel.OneStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.TwoStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.ThreeStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.FourStarCount).To(Equal(core.Int64Ptr(int64(38)))) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + Expect(repoInfoModel).ToNot(BeNil()) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + Expect(repoInfoModel.Token).To(Equal(core.StringPtr("testString"))) + Expect(repoInfoModel.Type).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the CreateOfferingOptions model + catalogIdentifier := "testString" + createOfferingOptionsModel := testService.NewCreateOfferingOptions(catalogIdentifier) + createOfferingOptionsModel.SetCatalogIdentifier("testString") + createOfferingOptionsModel.SetID("testString") + createOfferingOptionsModel.SetRev("testString") + createOfferingOptionsModel.SetURL("testString") + createOfferingOptionsModel.SetCrn("testString") + createOfferingOptionsModel.SetLabel("testString") + createOfferingOptionsModel.SetName("testString") + createOfferingOptionsModel.SetOfferingIconURL("testString") + createOfferingOptionsModel.SetOfferingDocsURL("testString") + createOfferingOptionsModel.SetOfferingSupportURL("testString") + createOfferingOptionsModel.SetTags([]string{"testString"}) + createOfferingOptionsModel.SetRating(ratingModel) + createOfferingOptionsModel.SetCreated(CreateMockDateTime()) + createOfferingOptionsModel.SetUpdated(CreateMockDateTime()) + createOfferingOptionsModel.SetShortDescription("testString") + createOfferingOptionsModel.SetLongDescription("testString") + createOfferingOptionsModel.SetFeatures([]catalogmanagementv1.Feature{*featureModel}) + createOfferingOptionsModel.SetKinds([]catalogmanagementv1.Kind{*kindModel}) + createOfferingOptionsModel.SetPermitRequestIbmPublicPublish(true) + createOfferingOptionsModel.SetIbmPublishApproved(true) + createOfferingOptionsModel.SetPublicPublishApproved(true) + createOfferingOptionsModel.SetPublicOriginalCrn("testString") + createOfferingOptionsModel.SetPublishPublicCrn("testString") + createOfferingOptionsModel.SetPortalApprovalRecord("testString") + createOfferingOptionsModel.SetPortalUiURL("testString") + createOfferingOptionsModel.SetCatalogID("testString") + createOfferingOptionsModel.SetCatalogName("testString") + createOfferingOptionsModel.SetMetadata(map[string]interface{}{"anyKey": "anyValue"}) + createOfferingOptionsModel.SetDisclaimer("testString") + createOfferingOptionsModel.SetHidden(true) + createOfferingOptionsModel.SetProvider("testString") + createOfferingOptionsModel.SetRepoInfo(repoInfoModel) + createOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(createOfferingOptionsModel).ToNot(BeNil()) + Expect(createOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.OfferingIconURL).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.OfferingDocsURL).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.OfferingSupportURL).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(createOfferingOptionsModel.Rating).To(Equal(ratingModel)) + Expect(createOfferingOptionsModel.Created).To(Equal(CreateMockDateTime())) + Expect(createOfferingOptionsModel.Updated).To(Equal(CreateMockDateTime())) + Expect(createOfferingOptionsModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Features).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(createOfferingOptionsModel.Kinds).To(Equal([]catalogmanagementv1.Kind{*kindModel})) + Expect(createOfferingOptionsModel.PermitRequestIbmPublicPublish).To(Equal(core.BoolPtr(true))) + Expect(createOfferingOptionsModel.IbmPublishApproved).To(Equal(core.BoolPtr(true))) + Expect(createOfferingOptionsModel.PublicPublishApproved).To(Equal(core.BoolPtr(true))) + Expect(createOfferingOptionsModel.PublicOriginalCrn).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.PublishPublicCrn).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.PortalApprovalRecord).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.PortalUiURL).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.CatalogID).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.CatalogName).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(createOfferingOptionsModel.Disclaimer).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.Hidden).To(Equal(core.BoolPtr(true))) + Expect(createOfferingOptionsModel.Provider).To(Equal(core.StringPtr("testString"))) + Expect(createOfferingOptionsModel.RepoInfo).To(Equal(repoInfoModel)) + Expect(createOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewCreateOperatorOptions successfully`, func() { + // Construct an instance of the CreateOperatorOptions model + xAuthRefreshToken := "testString" + createOperatorOptionsModel := testService.NewCreateOperatorOptions(xAuthRefreshToken) + createOperatorOptionsModel.SetXAuthRefreshToken("testString") + createOperatorOptionsModel.SetClusterID("testString") + createOperatorOptionsModel.SetRegion("testString") + createOperatorOptionsModel.SetNamespaces([]string{"testString"}) + createOperatorOptionsModel.SetVersionLocatorID("testString") + createOperatorOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(createOperatorOptionsModel).ToNot(BeNil()) + Expect(createOperatorOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(createOperatorOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(createOperatorOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(createOperatorOptionsModel.Namespaces).To(Equal([]string{"testString"})) + Expect(createOperatorOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(createOperatorOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeleteCatalogOptions successfully`, func() { + // Construct an instance of the DeleteCatalogOptions model + catalogIdentifier := "testString" + deleteCatalogOptionsModel := testService.NewDeleteCatalogOptions(catalogIdentifier) + deleteCatalogOptionsModel.SetCatalogIdentifier("testString") + deleteCatalogOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deleteCatalogOptionsModel).ToNot(BeNil()) + Expect(deleteCatalogOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(deleteCatalogOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeleteLicenseEntitlementOptions successfully`, func() { + // Construct an instance of the DeleteLicenseEntitlementOptions model + entitlementID := "testString" + deleteLicenseEntitlementOptionsModel := testService.NewDeleteLicenseEntitlementOptions(entitlementID) + deleteLicenseEntitlementOptionsModel.SetEntitlementID("testString") + deleteLicenseEntitlementOptionsModel.SetAccountID("testString") + deleteLicenseEntitlementOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deleteLicenseEntitlementOptionsModel).ToNot(BeNil()) + Expect(deleteLicenseEntitlementOptionsModel.EntitlementID).To(Equal(core.StringPtr("testString"))) + Expect(deleteLicenseEntitlementOptionsModel.AccountID).To(Equal(core.StringPtr("testString"))) + Expect(deleteLicenseEntitlementOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeleteOfferingOptions successfully`, func() { + // Construct an instance of the DeleteOfferingOptions model + catalogIdentifier := "testString" + offeringID := "testString" + deleteOfferingOptionsModel := testService.NewDeleteOfferingOptions(catalogIdentifier, offeringID) + deleteOfferingOptionsModel.SetCatalogIdentifier("testString") + deleteOfferingOptionsModel.SetOfferingID("testString") + deleteOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deleteOfferingOptionsModel).ToNot(BeNil()) + Expect(deleteOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(deleteOfferingOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(deleteOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeleteOperatorOptions successfully`, func() { + // Construct an instance of the DeleteOperatorOptions model + xAuthRefreshToken := "testString" + clusterID := "testString" + region := "testString" + versionLocatorID := "testString" + deleteOperatorOptionsModel := testService.NewDeleteOperatorOptions(xAuthRefreshToken, clusterID, region, versionLocatorID) + deleteOperatorOptionsModel.SetXAuthRefreshToken("testString") + deleteOperatorOptionsModel.SetClusterID("testString") + deleteOperatorOptionsModel.SetRegion("testString") + deleteOperatorOptionsModel.SetVersionLocatorID("testString") + deleteOperatorOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deleteOperatorOptionsModel).ToNot(BeNil()) + Expect(deleteOperatorOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(deleteOperatorOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(deleteOperatorOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(deleteOperatorOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(deleteOperatorOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeleteVersionOptions successfully`, func() { + // Construct an instance of the DeleteVersionOptions model + versionLocID := "testString" + deleteVersionOptionsModel := testService.NewDeleteVersionOptions(versionLocID) + deleteVersionOptionsModel.SetVersionLocID("testString") + deleteVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deleteVersionOptionsModel).ToNot(BeNil()) + Expect(deleteVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(deleteVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewDeprecateVersionOptions successfully`, func() { + // Construct an instance of the DeprecateVersionOptions model + versionLocID := "testString" + deprecateVersionOptionsModel := testService.NewDeprecateVersionOptions(versionLocID) + deprecateVersionOptionsModel.SetVersionLocID("testString") + deprecateVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(deprecateVersionOptionsModel).ToNot(BeNil()) + Expect(deprecateVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(deprecateVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetCatalogAccountFiltersOptions successfully`, func() { + // Construct an instance of the GetCatalogAccountFiltersOptions model + getCatalogAccountFiltersOptionsModel := testService.NewGetCatalogAccountFiltersOptions() + getCatalogAccountFiltersOptionsModel.SetCatalog("testString") + getCatalogAccountFiltersOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getCatalogAccountFiltersOptionsModel).ToNot(BeNil()) + Expect(getCatalogAccountFiltersOptionsModel.Catalog).To(Equal(core.StringPtr("testString"))) + Expect(getCatalogAccountFiltersOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetCatalogAccountOptions successfully`, func() { + // Construct an instance of the GetCatalogAccountOptions model + getCatalogAccountOptionsModel := testService.NewGetCatalogAccountOptions() + getCatalogAccountOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getCatalogAccountOptionsModel).ToNot(BeNil()) + Expect(getCatalogAccountOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetCatalogOptions successfully`, func() { + // Construct an instance of the GetCatalogOptions model + catalogIdentifier := "testString" + getCatalogOptionsModel := testService.NewGetCatalogOptions(catalogIdentifier) + getCatalogOptionsModel.SetCatalogIdentifier("testString") + getCatalogOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getCatalogOptionsModel).ToNot(BeNil()) + Expect(getCatalogOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(getCatalogOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetClusterOptions successfully`, func() { + // Construct an instance of the GetClusterOptions model + clusterID := "testString" + region := "testString" + xAuthRefreshToken := "testString" + getClusterOptionsModel := testService.NewGetClusterOptions(clusterID, region, xAuthRefreshToken) + getClusterOptionsModel.SetClusterID("testString") + getClusterOptionsModel.SetRegion("testString") + getClusterOptionsModel.SetXAuthRefreshToken("testString") + getClusterOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getClusterOptionsModel).ToNot(BeNil()) + Expect(getClusterOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(getClusterOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(getClusterOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(getClusterOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetConsumptionOfferingsOptions successfully`, func() { + // Construct an instance of the GetConsumptionOfferingsOptions model + getConsumptionOfferingsOptionsModel := testService.NewGetConsumptionOfferingsOptions() + getConsumptionOfferingsOptionsModel.SetDigest(true) + getConsumptionOfferingsOptionsModel.SetCatalog("testString") + getConsumptionOfferingsOptionsModel.SetSelect("all") + getConsumptionOfferingsOptionsModel.SetIncludeHidden(true) + getConsumptionOfferingsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getConsumptionOfferingsOptionsModel).ToNot(BeNil()) + Expect(getConsumptionOfferingsOptionsModel.Digest).To(Equal(core.BoolPtr(true))) + Expect(getConsumptionOfferingsOptionsModel.Catalog).To(Equal(core.StringPtr("testString"))) + Expect(getConsumptionOfferingsOptionsModel.Select).To(Equal(core.StringPtr("all"))) + Expect(getConsumptionOfferingsOptionsModel.IncludeHidden).To(Equal(core.BoolPtr(true))) + Expect(getConsumptionOfferingsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetEnterpriseOptions successfully`, func() { + // Construct an instance of the GetEnterpriseOptions model + enterpriseID := "testString" + getEnterpriseOptionsModel := testService.NewGetEnterpriseOptions(enterpriseID) + getEnterpriseOptionsModel.SetEnterpriseID("testString") + getEnterpriseOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getEnterpriseOptionsModel).ToNot(BeNil()) + Expect(getEnterpriseOptionsModel.EnterpriseID).To(Equal(core.StringPtr("testString"))) + Expect(getEnterpriseOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetLicenseEntitlementsOptions successfully`, func() { + // Construct an instance of the GetLicenseEntitlementsOptions model + licenseProductID := "testString" + getLicenseEntitlementsOptionsModel := testService.NewGetLicenseEntitlementsOptions(licenseProductID) + getLicenseEntitlementsOptionsModel.SetLicenseProductID("testString") + getLicenseEntitlementsOptionsModel.SetAccountID("testString") + getLicenseEntitlementsOptionsModel.SetVersionID("testString") + getLicenseEntitlementsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getLicenseEntitlementsOptionsModel).ToNot(BeNil()) + Expect(getLicenseEntitlementsOptionsModel.LicenseProductID).To(Equal(core.StringPtr("testString"))) + Expect(getLicenseEntitlementsOptionsModel.AccountID).To(Equal(core.StringPtr("testString"))) + Expect(getLicenseEntitlementsOptionsModel.VersionID).To(Equal(core.StringPtr("testString"))) + Expect(getLicenseEntitlementsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetLicenseProvidersOptions successfully`, func() { + // Construct an instance of the GetLicenseProvidersOptions model + getLicenseProvidersOptionsModel := testService.NewGetLicenseProvidersOptions() + getLicenseProvidersOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getLicenseProvidersOptionsModel).ToNot(BeNil()) + Expect(getLicenseProvidersOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetLicensesOptions successfully`, func() { + // Construct an instance of the GetLicensesOptions model + licenseProviderID := "testString" + getLicensesOptionsModel := testService.NewGetLicensesOptions(licenseProviderID) + getLicensesOptionsModel.SetLicenseProviderID("testString") + getLicensesOptionsModel.SetAccountID("testString") + getLicensesOptionsModel.SetName("testString") + getLicensesOptionsModel.SetLicenseType("testString") + getLicensesOptionsModel.SetLicenseProductID("testString") + getLicensesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getLicensesOptionsModel).ToNot(BeNil()) + Expect(getLicensesOptionsModel.LicenseProviderID).To(Equal(core.StringPtr("testString"))) + Expect(getLicensesOptionsModel.AccountID).To(Equal(core.StringPtr("testString"))) + Expect(getLicensesOptionsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(getLicensesOptionsModel.LicenseType).To(Equal(core.StringPtr("testString"))) + Expect(getLicensesOptionsModel.LicenseProductID).To(Equal(core.StringPtr("testString"))) + Expect(getLicensesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetNamespacesOptions successfully`, func() { + // Construct an instance of the GetNamespacesOptions model + clusterID := "testString" + region := "testString" + xAuthRefreshToken := "testString" + getNamespacesOptionsModel := testService.NewGetNamespacesOptions(clusterID, region, xAuthRefreshToken) + getNamespacesOptionsModel.SetClusterID("testString") + getNamespacesOptionsModel.SetRegion("testString") + getNamespacesOptionsModel.SetXAuthRefreshToken("testString") + getNamespacesOptionsModel.SetLimit(int64(38)) + getNamespacesOptionsModel.SetOffset(int64(38)) + getNamespacesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getNamespacesOptionsModel).ToNot(BeNil()) + Expect(getNamespacesOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(getNamespacesOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(getNamespacesOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(getNamespacesOptionsModel.Limit).To(Equal(core.Int64Ptr(int64(38)))) + Expect(getNamespacesOptionsModel.Offset).To(Equal(core.Int64Ptr(int64(38)))) + Expect(getNamespacesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetOfferingOptions successfully`, func() { + // Construct an instance of the GetOfferingOptions model + catalogIdentifier := "testString" + offeringID := "testString" + getOfferingOptionsModel := testService.NewGetOfferingOptions(catalogIdentifier, offeringID) + getOfferingOptionsModel.SetCatalogIdentifier("testString") + getOfferingOptionsModel.SetOfferingID("testString") + getOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getOfferingOptionsModel).ToNot(BeNil()) + Expect(getOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(getOfferingOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(getOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetOverrideValuesOptions successfully`, func() { + // Construct an instance of the GetOverrideValuesOptions model + versionLocID := "testString" + getOverrideValuesOptionsModel := testService.NewGetOverrideValuesOptions(versionLocID) + getOverrideValuesOptionsModel.SetVersionLocID("testString") + getOverrideValuesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getOverrideValuesOptionsModel).ToNot(BeNil()) + Expect(getOverrideValuesOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getOverrideValuesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetPreinstallOptions successfully`, func() { + // Construct an instance of the GetPreinstallOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + getPreinstallOptionsModel := testService.NewGetPreinstallOptions(versionLocID, xAuthRefreshToken) + getPreinstallOptionsModel.SetVersionLocID("testString") + getPreinstallOptionsModel.SetXAuthRefreshToken("testString") + getPreinstallOptionsModel.SetClusterID("testString") + getPreinstallOptionsModel.SetRegion("testString") + getPreinstallOptionsModel.SetNamespace("testString") + getPreinstallOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getPreinstallOptionsModel).ToNot(BeNil()) + Expect(getPreinstallOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getPreinstallOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(getPreinstallOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(getPreinstallOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(getPreinstallOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(getPreinstallOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetRepoOptions successfully`, func() { + // Construct an instance of the GetRepoOptions model + typeVar := "testString" + charturl := "testString" + getRepoOptionsModel := testService.NewGetRepoOptions(typeVar, charturl) + getRepoOptionsModel.SetType("testString") + getRepoOptionsModel.SetCharturl("testString") + getRepoOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getRepoOptionsModel).ToNot(BeNil()) + Expect(getRepoOptionsModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(getRepoOptionsModel.Charturl).To(Equal(core.StringPtr("testString"))) + Expect(getRepoOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetReposOptions successfully`, func() { + // Construct an instance of the GetReposOptions model + typeVar := "testString" + repourl := "testString" + getReposOptionsModel := testService.NewGetReposOptions(typeVar, repourl) + getReposOptionsModel.SetType("testString") + getReposOptionsModel.SetRepourl("testString") + getReposOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getReposOptionsModel).ToNot(BeNil()) + Expect(getReposOptionsModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(getReposOptionsModel.Repourl).To(Equal(core.StringPtr("testString"))) + Expect(getReposOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetResourceGroupsOptions successfully`, func() { + // Construct an instance of the GetResourceGroupsOptions model + getResourceGroupsOptionsModel := testService.NewGetResourceGroupsOptions() + getResourceGroupsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getResourceGroupsOptionsModel).ToNot(BeNil()) + Expect(getResourceGroupsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetSchematicsWorkspacesOptions successfully`, func() { + // Construct an instance of the GetSchematicsWorkspacesOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + getSchematicsWorkspacesOptionsModel := testService.NewGetSchematicsWorkspacesOptions(versionLocID, xAuthRefreshToken) + getSchematicsWorkspacesOptionsModel.SetVersionLocID("testString") + getSchematicsWorkspacesOptionsModel.SetXAuthRefreshToken("testString") + getSchematicsWorkspacesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getSchematicsWorkspacesOptionsModel).ToNot(BeNil()) + Expect(getSchematicsWorkspacesOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getSchematicsWorkspacesOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(getSchematicsWorkspacesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetValidationStatusOptions successfully`, func() { + // Construct an instance of the GetValidationStatusOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + getValidationStatusOptionsModel := testService.NewGetValidationStatusOptions(versionLocID, xAuthRefreshToken) + getValidationStatusOptionsModel.SetVersionLocID("testString") + getValidationStatusOptionsModel.SetXAuthRefreshToken("testString") + getValidationStatusOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getValidationStatusOptionsModel).ToNot(BeNil()) + Expect(getValidationStatusOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getValidationStatusOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(getValidationStatusOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionAboutOptions successfully`, func() { + // Construct an instance of the GetVersionAboutOptions model + versionLocID := "testString" + getVersionAboutOptionsModel := testService.NewGetVersionAboutOptions(versionLocID) + getVersionAboutOptionsModel.SetVersionLocID("testString") + getVersionAboutOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionAboutOptionsModel).ToNot(BeNil()) + Expect(getVersionAboutOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionAboutOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionContainerImagesOptions successfully`, func() { + // Construct an instance of the GetVersionContainerImagesOptions model + versionLocID := "testString" + getVersionContainerImagesOptionsModel := testService.NewGetVersionContainerImagesOptions(versionLocID) + getVersionContainerImagesOptionsModel.SetVersionLocID("testString") + getVersionContainerImagesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionContainerImagesOptionsModel).ToNot(BeNil()) + Expect(getVersionContainerImagesOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionContainerImagesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionLicenseOptions successfully`, func() { + // Construct an instance of the GetVersionLicenseOptions model + versionLocID := "testString" + licenseID := "testString" + getVersionLicenseOptionsModel := testService.NewGetVersionLicenseOptions(versionLocID, licenseID) + getVersionLicenseOptionsModel.SetVersionLocID("testString") + getVersionLicenseOptionsModel.SetLicenseID("testString") + getVersionLicenseOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionLicenseOptionsModel).ToNot(BeNil()) + Expect(getVersionLicenseOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionLicenseOptionsModel.LicenseID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionLicenseOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionOptions successfully`, func() { + // Construct an instance of the GetVersionOptions model + versionLocID := "testString" + getVersionOptionsModel := testService.NewGetVersionOptions(versionLocID) + getVersionOptionsModel.SetVersionLocID("testString") + getVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionOptionsModel).ToNot(BeNil()) + Expect(getVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionUpdatesOptions successfully`, func() { + // Construct an instance of the GetVersionUpdatesOptions model + versionLocID := "testString" + getVersionUpdatesOptionsModel := testService.NewGetVersionUpdatesOptions(versionLocID) + getVersionUpdatesOptionsModel.SetVersionLocID("testString") + getVersionUpdatesOptionsModel.SetClusterID("testString") + getVersionUpdatesOptionsModel.SetRegion("testString") + getVersionUpdatesOptionsModel.SetResourceGroupID("testString") + getVersionUpdatesOptionsModel.SetNamespace("testString") + getVersionUpdatesOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionUpdatesOptionsModel).ToNot(BeNil()) + Expect(getVersionUpdatesOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionUpdatesOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionUpdatesOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(getVersionUpdatesOptionsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionUpdatesOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(getVersionUpdatesOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewGetVersionWorkingCopyOptions successfully`, func() { + // Construct an instance of the GetVersionWorkingCopyOptions model + versionLocID := "testString" + getVersionWorkingCopyOptionsModel := testService.NewGetVersionWorkingCopyOptions(versionLocID) + getVersionWorkingCopyOptionsModel.SetVersionLocID("testString") + getVersionWorkingCopyOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(getVersionWorkingCopyOptionsModel).ToNot(BeNil()) + Expect(getVersionWorkingCopyOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(getVersionWorkingCopyOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewIbmPublishVersionOptions successfully`, func() { + // Construct an instance of the IbmPublishVersionOptions model + versionLocID := "testString" + ibmPublishVersionOptionsModel := testService.NewIbmPublishVersionOptions(versionLocID) + ibmPublishVersionOptionsModel.SetVersionLocID("testString") + ibmPublishVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(ibmPublishVersionOptionsModel).ToNot(BeNil()) + Expect(ibmPublishVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(ibmPublishVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewImportOfferingOptions successfully`, func() { + // Construct an instance of the ImportOfferingOptions model + catalogIdentifier := "testString" + zipurl := "testString" + importOfferingOptionsModel := testService.NewImportOfferingOptions(catalogIdentifier, zipurl) + importOfferingOptionsModel.SetCatalogIdentifier("testString") + importOfferingOptionsModel.SetZipurl("testString") + importOfferingOptionsModel.SetTags([]string{"testString"}) + importOfferingOptionsModel.SetTargetKinds([]string{"testString"}) + importOfferingOptionsModel.SetOfferingID("testString") + importOfferingOptionsModel.SetIncludeConfig(true) + importOfferingOptionsModel.SetRepoType("testString") + importOfferingOptionsModel.SetXAuthToken("testString") + importOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(importOfferingOptionsModel).ToNot(BeNil()) + Expect(importOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingOptionsModel.Zipurl).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(importOfferingOptionsModel.TargetKinds).To(Equal([]string{"testString"})) + Expect(importOfferingOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingOptionsModel.IncludeConfig).To(Equal(core.BoolPtr(true))) + Expect(importOfferingOptionsModel.RepoType).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingOptionsModel.XAuthToken).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewImportOfferingVersionOptions successfully`, func() { + // Construct an instance of the ImportOfferingVersionOptions model + catalogIdentifier := "testString" + offeringID := "testString" + zipurl := "testString" + importOfferingVersionOptionsModel := testService.NewImportOfferingVersionOptions(catalogIdentifier, offeringID, zipurl) + importOfferingVersionOptionsModel.SetCatalogIdentifier("testString") + importOfferingVersionOptionsModel.SetOfferingID("testString") + importOfferingVersionOptionsModel.SetZipurl("testString") + importOfferingVersionOptionsModel.SetTags([]string{"testString"}) + importOfferingVersionOptionsModel.SetTargetKinds([]string{"testString"}) + importOfferingVersionOptionsModel.SetTargetVersion("testString") + importOfferingVersionOptionsModel.SetIncludeConfig(true) + importOfferingVersionOptionsModel.SetRepoType("testString") + importOfferingVersionOptionsModel.SetXAuthToken("testString") + importOfferingVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(importOfferingVersionOptionsModel).ToNot(BeNil()) + Expect(importOfferingVersionOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.Zipurl).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(importOfferingVersionOptionsModel.TargetKinds).To(Equal([]string{"testString"})) + Expect(importOfferingVersionOptionsModel.TargetVersion).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.IncludeConfig).To(Equal(core.BoolPtr(true))) + Expect(importOfferingVersionOptionsModel.RepoType).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.XAuthToken).To(Equal(core.StringPtr("testString"))) + Expect(importOfferingVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewInstallVersionOptions successfully`, func() { + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + Expect(deployRequestBodySchematicsModel).ToNot(BeNil()) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + Expect(deployRequestBodySchematicsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Description).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Tags).To(Equal([]string{"testString"})) + Expect(deployRequestBodySchematicsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the InstallVersionOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + installVersionOptionsModel := testService.NewInstallVersionOptions(versionLocID, xAuthRefreshToken) + installVersionOptionsModel.SetVersionLocID("testString") + installVersionOptionsModel.SetXAuthRefreshToken("testString") + installVersionOptionsModel.SetClusterID("testString") + installVersionOptionsModel.SetRegion("testString") + installVersionOptionsModel.SetNamespace("testString") + installVersionOptionsModel.SetOverrideValues(map[string]interface{}{"anyKey": "anyValue"}) + installVersionOptionsModel.SetEntitlementApikey("testString") + installVersionOptionsModel.SetSchematics(deployRequestBodySchematicsModel) + installVersionOptionsModel.SetScript("testString") + installVersionOptionsModel.SetScriptID("testString") + installVersionOptionsModel.SetVersionLocatorID("testString") + installVersionOptionsModel.SetVcenterID("testString") + installVersionOptionsModel.SetVcenterPassword("testString") + installVersionOptionsModel.SetVcenterLocation("testString") + installVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(installVersionOptionsModel).ToNot(BeNil()) + Expect(installVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.OverrideValues).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(installVersionOptionsModel.EntitlementApikey).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.Schematics).To(Equal(deployRequestBodySchematicsModel)) + Expect(installVersionOptionsModel.Script).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.ScriptID).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.VcenterID).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.VcenterPassword).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.VcenterLocation).To(Equal(core.StringPtr("testString"))) + Expect(installVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListCatalogsOptions successfully`, func() { + // Construct an instance of the ListCatalogsOptions model + listCatalogsOptionsModel := testService.NewListCatalogsOptions() + listCatalogsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listCatalogsOptionsModel).ToNot(BeNil()) + Expect(listCatalogsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListClustersOptions successfully`, func() { + // Construct an instance of the ListClustersOptions model + listClustersOptionsModel := testService.NewListClustersOptions() + listClustersOptionsModel.SetLimit(int64(38)) + listClustersOptionsModel.SetOffset(int64(38)) + listClustersOptionsModel.SetType("testString") + listClustersOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listClustersOptionsModel).ToNot(BeNil()) + Expect(listClustersOptionsModel.Limit).To(Equal(core.Int64Ptr(int64(38)))) + Expect(listClustersOptionsModel.Offset).To(Equal(core.Int64Ptr(int64(38)))) + Expect(listClustersOptionsModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(listClustersOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListLicenseEntitlementsOptions successfully`, func() { + // Construct an instance of the ListLicenseEntitlementsOptions model + listLicenseEntitlementsOptionsModel := testService.NewListLicenseEntitlementsOptions() + listLicenseEntitlementsOptionsModel.SetAccountID("testString") + listLicenseEntitlementsOptionsModel.SetLicenseProductID("testString") + listLicenseEntitlementsOptionsModel.SetVersionID("testString") + listLicenseEntitlementsOptionsModel.SetState("testString") + listLicenseEntitlementsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listLicenseEntitlementsOptionsModel).ToNot(BeNil()) + Expect(listLicenseEntitlementsOptionsModel.AccountID).To(Equal(core.StringPtr("testString"))) + Expect(listLicenseEntitlementsOptionsModel.LicenseProductID).To(Equal(core.StringPtr("testString"))) + Expect(listLicenseEntitlementsOptionsModel.VersionID).To(Equal(core.StringPtr("testString"))) + Expect(listLicenseEntitlementsOptionsModel.State).To(Equal(core.StringPtr("testString"))) + Expect(listLicenseEntitlementsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListOfferingsOptions successfully`, func() { + // Construct an instance of the ListOfferingsOptions model + catalogIdentifier := "testString" + listOfferingsOptionsModel := testService.NewListOfferingsOptions(catalogIdentifier) + listOfferingsOptionsModel.SetCatalogIdentifier("testString") + listOfferingsOptionsModel.SetDigest(true) + listOfferingsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listOfferingsOptionsModel).ToNot(BeNil()) + Expect(listOfferingsOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(listOfferingsOptionsModel.Digest).To(Equal(core.BoolPtr(true))) + Expect(listOfferingsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListOperatorsOptions successfully`, func() { + // Construct an instance of the ListOperatorsOptions model + xAuthRefreshToken := "testString" + clusterID := "testString" + region := "testString" + versionLocatorID := "testString" + listOperatorsOptionsModel := testService.NewListOperatorsOptions(xAuthRefreshToken, clusterID, region, versionLocatorID) + listOperatorsOptionsModel.SetXAuthRefreshToken("testString") + listOperatorsOptionsModel.SetClusterID("testString") + listOperatorsOptionsModel.SetRegion("testString") + listOperatorsOptionsModel.SetVersionLocatorID("testString") + listOperatorsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listOperatorsOptionsModel).ToNot(BeNil()) + Expect(listOperatorsOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(listOperatorsOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(listOperatorsOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(listOperatorsOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(listOperatorsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewListVersionsOptions successfully`, func() { + // Construct an instance of the ListVersionsOptions model + q := "testString" + listVersionsOptionsModel := testService.NewListVersionsOptions(q) + listVersionsOptionsModel.SetQ("testString") + listVersionsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(listVersionsOptionsModel).ToNot(BeNil()) + Expect(listVersionsOptionsModel.Q).To(Equal(core.StringPtr("testString"))) + Expect(listVersionsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewPreinstallVersionOptions successfully`, func() { + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + Expect(deployRequestBodySchematicsModel).ToNot(BeNil()) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + Expect(deployRequestBodySchematicsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Description).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Tags).To(Equal([]string{"testString"})) + Expect(deployRequestBodySchematicsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the PreinstallVersionOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + preinstallVersionOptionsModel := testService.NewPreinstallVersionOptions(versionLocID, xAuthRefreshToken) + preinstallVersionOptionsModel.SetVersionLocID("testString") + preinstallVersionOptionsModel.SetXAuthRefreshToken("testString") + preinstallVersionOptionsModel.SetClusterID("testString") + preinstallVersionOptionsModel.SetRegion("testString") + preinstallVersionOptionsModel.SetNamespace("testString") + preinstallVersionOptionsModel.SetOverrideValues(map[string]interface{}{"anyKey": "anyValue"}) + preinstallVersionOptionsModel.SetEntitlementApikey("testString") + preinstallVersionOptionsModel.SetSchematics(deployRequestBodySchematicsModel) + preinstallVersionOptionsModel.SetScript("testString") + preinstallVersionOptionsModel.SetScriptID("testString") + preinstallVersionOptionsModel.SetVersionLocatorID("testString") + preinstallVersionOptionsModel.SetVcenterID("testString") + preinstallVersionOptionsModel.SetVcenterPassword("testString") + preinstallVersionOptionsModel.SetVcenterLocation("testString") + preinstallVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(preinstallVersionOptionsModel).ToNot(BeNil()) + Expect(preinstallVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.OverrideValues).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(preinstallVersionOptionsModel.EntitlementApikey).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.Schematics).To(Equal(deployRequestBodySchematicsModel)) + Expect(preinstallVersionOptionsModel.Script).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.ScriptID).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.VcenterID).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.VcenterPassword).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.VcenterLocation).To(Equal(core.StringPtr("testString"))) + Expect(preinstallVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewPublicPublishVersionOptions successfully`, func() { + // Construct an instance of the PublicPublishVersionOptions model + versionLocID := "testString" + publicPublishVersionOptionsModel := testService.NewPublicPublishVersionOptions(versionLocID) + publicPublishVersionOptionsModel.SetVersionLocID("testString") + publicPublishVersionOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(publicPublishVersionOptionsModel).ToNot(BeNil()) + Expect(publicPublishVersionOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(publicPublishVersionOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReloadOfferingOptions successfully`, func() { + // Construct an instance of the ReloadOfferingOptions model + catalogIdentifier := "testString" + offeringID := "testString" + zipurl := "testString" + targetVersion := "testString" + reloadOfferingOptionsModel := testService.NewReloadOfferingOptions(catalogIdentifier, offeringID, zipurl, targetVersion) + reloadOfferingOptionsModel.SetCatalogIdentifier("testString") + reloadOfferingOptionsModel.SetOfferingID("testString") + reloadOfferingOptionsModel.SetZipurl("testString") + reloadOfferingOptionsModel.SetTargetVersion("testString") + reloadOfferingOptionsModel.SetTags([]string{"testString"}) + reloadOfferingOptionsModel.SetTargetKinds([]string{"testString"}) + reloadOfferingOptionsModel.SetRepoType("testString") + reloadOfferingOptionsModel.SetXAuthToken("testString") + reloadOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(reloadOfferingOptionsModel).ToNot(BeNil()) + Expect(reloadOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.Zipurl).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.TargetVersion).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(reloadOfferingOptionsModel.TargetKinds).To(Equal([]string{"testString"})) + Expect(reloadOfferingOptionsModel.RepoType).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.XAuthToken).To(Equal(core.StringPtr("testString"))) + Expect(reloadOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReplaceCatalogOptions successfully`, func() { + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + Expect(filterTermsModel).ToNot(BeNil()) + filterTermsModel.FilterTerms = []string{"testString"} + Expect(filterTermsModel.FilterTerms).To(Equal([]string{"testString"})) + + // Construct an instance of the SyndicationCluster model + syndicationClusterModel := new(catalogmanagementv1.SyndicationCluster) + Expect(syndicationClusterModel).ToNot(BeNil()) + syndicationClusterModel.Region = core.StringPtr("testString") + syndicationClusterModel.ID = core.StringPtr("testString") + syndicationClusterModel.Name = core.StringPtr("testString") + syndicationClusterModel.ResourceGroupName = core.StringPtr("testString") + syndicationClusterModel.Type = core.StringPtr("testString") + syndicationClusterModel.Namespaces = []string{"testString"} + syndicationClusterModel.AllNamespaces = core.BoolPtr(true) + Expect(syndicationClusterModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.ResourceGroupName).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(syndicationClusterModel.Namespaces).To(Equal([]string{"testString"})) + Expect(syndicationClusterModel.AllNamespaces).To(Equal(core.BoolPtr(true))) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + Expect(categoryFilterModel).ToNot(BeNil()) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + Expect(categoryFilterModel.Include).To(Equal(core.BoolPtr(true))) + Expect(categoryFilterModel.Filter).To(Equal(filterTermsModel)) + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + Expect(idFilterModel).ToNot(BeNil()) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + Expect(idFilterModel.Include).To(Equal(filterTermsModel)) + Expect(idFilterModel.Exclude).To(Equal(filterTermsModel)) + + // Construct an instance of the SyndicationAuthorization model + syndicationAuthorizationModel := new(catalogmanagementv1.SyndicationAuthorization) + Expect(syndicationAuthorizationModel).ToNot(BeNil()) + syndicationAuthorizationModel.Token = core.StringPtr("testString") + syndicationAuthorizationModel.LastRun = CreateMockDateTime() + Expect(syndicationAuthorizationModel.Token).To(Equal(core.StringPtr("testString"))) + Expect(syndicationAuthorizationModel.LastRun).To(Equal(CreateMockDateTime())) + + // Construct an instance of the SyndicationHistory model + syndicationHistoryModel := new(catalogmanagementv1.SyndicationHistory) + Expect(syndicationHistoryModel).ToNot(BeNil()) + syndicationHistoryModel.Namespaces = []string{"testString"} + syndicationHistoryModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationHistoryModel.LastRun = CreateMockDateTime() + Expect(syndicationHistoryModel.Namespaces).To(Equal([]string{"testString"})) + Expect(syndicationHistoryModel.Clusters).To(Equal([]catalogmanagementv1.SyndicationCluster{*syndicationClusterModel})) + Expect(syndicationHistoryModel.LastRun).To(Equal(CreateMockDateTime())) + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + Expect(featureModel).ToNot(BeNil()) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + Expect(featureModel.Title).To(Equal(core.StringPtr("testString"))) + Expect(featureModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + Expect(filtersModel).ToNot(BeNil()) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + Expect(filtersModel.IncludeAll).To(Equal(core.BoolPtr(true))) + Expect(filtersModel.CategoryFilters).To(Equal(make(map[string]catalogmanagementv1.CategoryFilter))) + Expect(filtersModel.IdFilters).To(Equal(idFilterModel)) + + // Construct an instance of the SyndicationResource model + syndicationResourceModel := new(catalogmanagementv1.SyndicationResource) + Expect(syndicationResourceModel).ToNot(BeNil()) + syndicationResourceModel.RemoveRelatedComponents = core.BoolPtr(true) + syndicationResourceModel.Clusters = []catalogmanagementv1.SyndicationCluster{*syndicationClusterModel} + syndicationResourceModel.History = syndicationHistoryModel + syndicationResourceModel.Authorization = syndicationAuthorizationModel + Expect(syndicationResourceModel.RemoveRelatedComponents).To(Equal(core.BoolPtr(true))) + Expect(syndicationResourceModel.Clusters).To(Equal([]catalogmanagementv1.SyndicationCluster{*syndicationClusterModel})) + Expect(syndicationResourceModel.History).To(Equal(syndicationHistoryModel)) + Expect(syndicationResourceModel.Authorization).To(Equal(syndicationAuthorizationModel)) + + // Construct an instance of the ReplaceCatalogOptions model + catalogIdentifier := "testString" + replaceCatalogOptionsModel := testService.NewReplaceCatalogOptions(catalogIdentifier) + replaceCatalogOptionsModel.SetCatalogIdentifier("testString") + replaceCatalogOptionsModel.SetID("testString") + replaceCatalogOptionsModel.SetRev("testString") + replaceCatalogOptionsModel.SetLabel("testString") + replaceCatalogOptionsModel.SetShortDescription("testString") + replaceCatalogOptionsModel.SetCatalogIconURL("testString") + replaceCatalogOptionsModel.SetTags([]string{"testString"}) + replaceCatalogOptionsModel.SetURL("testString") + replaceCatalogOptionsModel.SetCrn("testString") + replaceCatalogOptionsModel.SetOfferingsURL("testString") + replaceCatalogOptionsModel.SetFeatures([]catalogmanagementv1.Feature{*featureModel}) + replaceCatalogOptionsModel.SetDisabled(true) + replaceCatalogOptionsModel.SetCreated(CreateMockDateTime()) + replaceCatalogOptionsModel.SetUpdated(CreateMockDateTime()) + replaceCatalogOptionsModel.SetResourceGroupID("testString") + replaceCatalogOptionsModel.SetOwningAccount("testString") + replaceCatalogOptionsModel.SetCatalogFilters(filtersModel) + replaceCatalogOptionsModel.SetSyndicationSettings(syndicationResourceModel) + replaceCatalogOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(replaceCatalogOptionsModel).ToNot(BeNil()) + Expect(replaceCatalogOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.CatalogIconURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(replaceCatalogOptionsModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.OfferingsURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.Features).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(replaceCatalogOptionsModel.Disabled).To(Equal(core.BoolPtr(true))) + Expect(replaceCatalogOptionsModel.Created).To(Equal(CreateMockDateTime())) + Expect(replaceCatalogOptionsModel.Updated).To(Equal(CreateMockDateTime())) + Expect(replaceCatalogOptionsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.OwningAccount).To(Equal(core.StringPtr("testString"))) + Expect(replaceCatalogOptionsModel.CatalogFilters).To(Equal(filtersModel)) + Expect(replaceCatalogOptionsModel.SyndicationSettings).To(Equal(syndicationResourceModel)) + Expect(replaceCatalogOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReplaceEnterpriseOptions successfully`, func() { + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + Expect(filterTermsModel).ToNot(BeNil()) + filterTermsModel.FilterTerms = []string{"testString"} + Expect(filterTermsModel.FilterTerms).To(Equal([]string{"testString"})) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + Expect(categoryFilterModel).ToNot(BeNil()) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + Expect(categoryFilterModel.Include).To(Equal(core.BoolPtr(true))) + Expect(categoryFilterModel.Filter).To(Equal(filterTermsModel)) + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + Expect(idFilterModel).ToNot(BeNil()) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + Expect(idFilterModel.Include).To(Equal(filterTermsModel)) + Expect(idFilterModel.Exclude).To(Equal(filterTermsModel)) + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + Expect(filtersModel).ToNot(BeNil()) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + Expect(filtersModel.IncludeAll).To(Equal(core.BoolPtr(true))) + Expect(filtersModel.CategoryFilters).To(Equal(make(map[string]catalogmanagementv1.CategoryFilter))) + Expect(filtersModel.IdFilters).To(Equal(idFilterModel)) + + // Construct an instance of the AccountGroup model + accountGroupModel := new(catalogmanagementv1.AccountGroup) + Expect(accountGroupModel).ToNot(BeNil()) + accountGroupModel.ID = core.StringPtr("testString") + accountGroupModel.AccountFilters = filtersModel + Expect(accountGroupModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(accountGroupModel.AccountFilters).To(Equal(filtersModel)) + + // Construct an instance of the EnterpriseAccountGroups model + enterpriseAccountGroupsModel := new(catalogmanagementv1.EnterpriseAccountGroups) + Expect(enterpriseAccountGroupsModel).ToNot(BeNil()) + enterpriseAccountGroupsModel.Keys = accountGroupModel + Expect(enterpriseAccountGroupsModel.Keys).To(Equal(accountGroupModel)) + + // Construct an instance of the ReplaceEnterpriseOptions model + enterpriseID := "testString" + replaceEnterpriseOptionsModel := testService.NewReplaceEnterpriseOptions(enterpriseID) + replaceEnterpriseOptionsModel.SetEnterpriseID("testString") + replaceEnterpriseOptionsModel.SetID("testString") + replaceEnterpriseOptionsModel.SetRev("testString") + replaceEnterpriseOptionsModel.SetAccountFilters(filtersModel) + replaceEnterpriseOptionsModel.SetAccountGroups(enterpriseAccountGroupsModel) + replaceEnterpriseOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(replaceEnterpriseOptionsModel).ToNot(BeNil()) + Expect(replaceEnterpriseOptionsModel.EnterpriseID).To(Equal(core.StringPtr("testString"))) + Expect(replaceEnterpriseOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(replaceEnterpriseOptionsModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(replaceEnterpriseOptionsModel.AccountFilters).To(Equal(filtersModel)) + Expect(replaceEnterpriseOptionsModel.AccountGroups).To(Equal(enterpriseAccountGroupsModel)) + Expect(replaceEnterpriseOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReplaceOfferingIconOptions successfully`, func() { + // Construct an instance of the ReplaceOfferingIconOptions model + catalogIdentifier := "testString" + offeringID := "testString" + fileName := "testString" + replaceOfferingIconOptionsModel := testService.NewReplaceOfferingIconOptions(catalogIdentifier, offeringID, fileName) + replaceOfferingIconOptionsModel.SetCatalogIdentifier("testString") + replaceOfferingIconOptionsModel.SetOfferingID("testString") + replaceOfferingIconOptionsModel.SetFileName("testString") + replaceOfferingIconOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(replaceOfferingIconOptionsModel).ToNot(BeNil()) + Expect(replaceOfferingIconOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingIconOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingIconOptionsModel.FileName).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingIconOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReplaceOfferingOptions successfully`, func() { + // Construct an instance of the Configuration model + configurationModel := new(catalogmanagementv1.Configuration) + Expect(configurationModel).ToNot(BeNil()) + configurationModel.Key = core.StringPtr("testString") + configurationModel.Type = core.StringPtr("testString") + configurationModel.DefaultValue = core.StringPtr("testString") + configurationModel.ValueConstraint = core.StringPtr("testString") + configurationModel.Description = core.StringPtr("testString") + configurationModel.Required = core.BoolPtr(true) + configurationModel.Options = []interface{}{map[string]interface{}{"anyKey": "anyValue"}} + configurationModel.Hidden = core.BoolPtr(true) + Expect(configurationModel.Key).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.DefaultValue).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.ValueConstraint).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Description).To(Equal(core.StringPtr("testString"))) + Expect(configurationModel.Required).To(Equal(core.BoolPtr(true))) + Expect(configurationModel.Options).To(Equal([]interface{}{map[string]interface{}{"anyKey": "anyValue"}})) + Expect(configurationModel.Hidden).To(Equal(core.BoolPtr(true))) + + // Construct an instance of the Deployment model + deploymentModel := new(catalogmanagementv1.Deployment) + Expect(deploymentModel).ToNot(BeNil()) + deploymentModel.ID = core.StringPtr("testString") + deploymentModel.Label = core.StringPtr("testString") + deploymentModel.Name = core.StringPtr("testString") + deploymentModel.ShortDescription = core.StringPtr("testString") + deploymentModel.LongDescription = core.StringPtr("testString") + deploymentModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + deploymentModel.Tags = []string{"testString"} + deploymentModel.Created = CreateMockDateTime() + deploymentModel.Updated = CreateMockDateTime() + Expect(deploymentModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(deploymentModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(deploymentModel.Tags).To(Equal([]string{"testString"})) + Expect(deploymentModel.Created).To(Equal(CreateMockDateTime())) + Expect(deploymentModel.Updated).To(Equal(CreateMockDateTime())) + + // Construct an instance of the Feature model + featureModel := new(catalogmanagementv1.Feature) + Expect(featureModel).ToNot(BeNil()) + featureModel.Title = core.StringPtr("testString") + featureModel.Description = core.StringPtr("testString") + Expect(featureModel.Title).To(Equal(core.StringPtr("testString"))) + Expect(featureModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the License model + licenseModel := new(catalogmanagementv1.License) + Expect(licenseModel).ToNot(BeNil()) + licenseModel.ID = core.StringPtr("testString") + licenseModel.Name = core.StringPtr("testString") + licenseModel.Type = core.StringPtr("testString") + licenseModel.URL = core.StringPtr("testString") + licenseModel.Description = core.StringPtr("testString") + Expect(licenseModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Type).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(licenseModel.Description).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Resource model + resourceModel := new(catalogmanagementv1.Resource) + Expect(resourceModel).ToNot(BeNil()) + resourceModel.Type = core.StringPtr("mem") + resourceModel.Value = core.StringPtr("testString") + Expect(resourceModel.Type).To(Equal(core.StringPtr("mem"))) + Expect(resourceModel.Value).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Script model + scriptModel := new(catalogmanagementv1.Script) + Expect(scriptModel).ToNot(BeNil()) + scriptModel.Instructions = core.StringPtr("testString") + scriptModel.Script = core.StringPtr("testString") + scriptModel.ScriptPermission = core.StringPtr("testString") + scriptModel.DeleteScript = core.StringPtr("testString") + scriptModel.Scope = core.StringPtr("testString") + Expect(scriptModel.Instructions).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.Script).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.ScriptPermission).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.DeleteScript).To(Equal(core.StringPtr("testString"))) + Expect(scriptModel.Scope).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the State model + stateModel := new(catalogmanagementv1.State) + Expect(stateModel).ToNot(BeNil()) + stateModel.Current = core.StringPtr("testString") + stateModel.CurrentEntered = CreateMockDateTime() + stateModel.Pending = core.StringPtr("testString") + stateModel.PendingRequested = CreateMockDateTime() + stateModel.Previous = core.StringPtr("testString") + Expect(stateModel.Current).To(Equal(core.StringPtr("testString"))) + Expect(stateModel.CurrentEntered).To(Equal(CreateMockDateTime())) + Expect(stateModel.Pending).To(Equal(core.StringPtr("testString"))) + Expect(stateModel.PendingRequested).To(Equal(CreateMockDateTime())) + Expect(stateModel.Previous).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Validation model + validationModel := new(catalogmanagementv1.Validation) + Expect(validationModel).ToNot(BeNil()) + validationModel.Validated = CreateMockDateTime() + validationModel.Requested = CreateMockDateTime() + validationModel.State = core.StringPtr("testString") + validationModel.LastOperation = core.StringPtr("testString") + validationModel.Target = map[string]interface{}{"anyKey": "anyValue"} + Expect(validationModel.Validated).To(Equal(CreateMockDateTime())) + Expect(validationModel.Requested).To(Equal(CreateMockDateTime())) + Expect(validationModel.State).To(Equal(core.StringPtr("testString"))) + Expect(validationModel.LastOperation).To(Equal(core.StringPtr("testString"))) + Expect(validationModel.Target).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + + // Construct an instance of the VersionEntitlement model + versionEntitlementModel := new(catalogmanagementv1.VersionEntitlement) + Expect(versionEntitlementModel).ToNot(BeNil()) + versionEntitlementModel.ProviderName = core.StringPtr("testString") + versionEntitlementModel.ProviderID = core.StringPtr("testString") + versionEntitlementModel.ProductID = core.StringPtr("testString") + versionEntitlementModel.PartNumbers = []string{"testString"} + versionEntitlementModel.ImageRepoName = core.StringPtr("testString") + Expect(versionEntitlementModel.ProviderName).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.ProviderID).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.ProductID).To(Equal(core.StringPtr("testString"))) + Expect(versionEntitlementModel.PartNumbers).To(Equal([]string{"testString"})) + Expect(versionEntitlementModel.ImageRepoName).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the Plan model + planModel := new(catalogmanagementv1.Plan) + Expect(planModel).ToNot(BeNil()) + planModel.ID = core.StringPtr("testString") + planModel.Label = core.StringPtr("testString") + planModel.Name = core.StringPtr("testString") + planModel.ShortDescription = core.StringPtr("testString") + planModel.LongDescription = core.StringPtr("testString") + planModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + planModel.Tags = []string{"testString"} + planModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + planModel.Created = CreateMockDateTime() + planModel.Updated = CreateMockDateTime() + planModel.Deployments = []catalogmanagementv1.Deployment{*deploymentModel} + Expect(planModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(planModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(planModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(planModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(planModel.Tags).To(Equal([]string{"testString"})) + Expect(planModel.AdditionalFeatures).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(planModel.Created).To(Equal(CreateMockDateTime())) + Expect(planModel.Updated).To(Equal(CreateMockDateTime())) + Expect(planModel.Deployments).To(Equal([]catalogmanagementv1.Deployment{*deploymentModel})) + + // Construct an instance of the Version model + versionModel := new(catalogmanagementv1.Version) + Expect(versionModel).ToNot(BeNil()) + versionModel.ID = core.StringPtr("testString") + versionModel.Rev = core.StringPtr("testString") + versionModel.Crn = core.StringPtr("testString") + versionModel.Version = core.StringPtr("testString") + versionModel.Sha = core.StringPtr("testString") + versionModel.Created = CreateMockDateTime() + versionModel.Updated = CreateMockDateTime() + versionModel.OfferingID = core.StringPtr("testString") + versionModel.CatalogID = core.StringPtr("testString") + versionModel.KindID = core.StringPtr("testString") + versionModel.Tags = []string{"testString"} + versionModel.RepoURL = core.StringPtr("testString") + versionModel.SourceURL = core.StringPtr("testString") + versionModel.TgzURL = core.StringPtr("testString") + versionModel.Configuration = []catalogmanagementv1.Configuration{*configurationModel} + versionModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + versionModel.Validation = validationModel + versionModel.RequiredResources = []catalogmanagementv1.Resource{*resourceModel} + versionModel.SingleInstance = core.BoolPtr(true) + versionModel.Install = scriptModel + versionModel.PreInstall = []catalogmanagementv1.Script{*scriptModel} + versionModel.Entitlement = versionEntitlementModel + versionModel.Licenses = []catalogmanagementv1.License{*licenseModel} + versionModel.ImageManifestURL = core.StringPtr("testString") + versionModel.Deprecated = core.BoolPtr(true) + versionModel.PackageVersion = core.StringPtr("testString") + versionModel.State = stateModel + versionModel.VersionLocator = core.StringPtr("testString") + versionModel.ConsoleURL = core.StringPtr("testString") + versionModel.LongDescription = core.StringPtr("testString") + versionModel.WhitelistedAccounts = []string{"testString"} + Expect(versionModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Version).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Sha).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Created).To(Equal(CreateMockDateTime())) + Expect(versionModel.Updated).To(Equal(CreateMockDateTime())) + Expect(versionModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.CatalogID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.KindID).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Tags).To(Equal([]string{"testString"})) + Expect(versionModel.RepoURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.SourceURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.TgzURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Configuration).To(Equal([]catalogmanagementv1.Configuration{*configurationModel})) + Expect(versionModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(versionModel.Validation).To(Equal(validationModel)) + Expect(versionModel.RequiredResources).To(Equal([]catalogmanagementv1.Resource{*resourceModel})) + Expect(versionModel.SingleInstance).To(Equal(core.BoolPtr(true))) + Expect(versionModel.Install).To(Equal(scriptModel)) + Expect(versionModel.PreInstall).To(Equal([]catalogmanagementv1.Script{*scriptModel})) + Expect(versionModel.Entitlement).To(Equal(versionEntitlementModel)) + Expect(versionModel.Licenses).To(Equal([]catalogmanagementv1.License{*licenseModel})) + Expect(versionModel.ImageManifestURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.Deprecated).To(Equal(core.BoolPtr(true))) + Expect(versionModel.PackageVersion).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.State).To(Equal(stateModel)) + Expect(versionModel.VersionLocator).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.ConsoleURL).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(versionModel.WhitelistedAccounts).To(Equal([]string{"testString"})) + + // Construct an instance of the Kind model + kindModel := new(catalogmanagementv1.Kind) + Expect(kindModel).ToNot(BeNil()) + kindModel.ID = core.StringPtr("testString") + kindModel.FormatKind = core.StringPtr("testString") + kindModel.TargetKind = core.StringPtr("testString") + kindModel.Metadata = map[string]interface{}{"anyKey": "anyValue"} + kindModel.InstallDescription = core.StringPtr("testString") + kindModel.Tags = []string{"testString"} + kindModel.AdditionalFeatures = []catalogmanagementv1.Feature{*featureModel} + kindModel.Created = CreateMockDateTime() + kindModel.Updated = CreateMockDateTime() + kindModel.Versions = []catalogmanagementv1.Version{*versionModel} + kindModel.Plans = []catalogmanagementv1.Plan{*planModel} + Expect(kindModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.FormatKind).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.TargetKind).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(kindModel.InstallDescription).To(Equal(core.StringPtr("testString"))) + Expect(kindModel.Tags).To(Equal([]string{"testString"})) + Expect(kindModel.AdditionalFeatures).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(kindModel.Created).To(Equal(CreateMockDateTime())) + Expect(kindModel.Updated).To(Equal(CreateMockDateTime())) + Expect(kindModel.Versions).To(Equal([]catalogmanagementv1.Version{*versionModel})) + Expect(kindModel.Plans).To(Equal([]catalogmanagementv1.Plan{*planModel})) + + // Construct an instance of the Rating model + ratingModel := new(catalogmanagementv1.Rating) + Expect(ratingModel).ToNot(BeNil()) + ratingModel.OneStarCount = core.Int64Ptr(int64(38)) + ratingModel.TwoStarCount = core.Int64Ptr(int64(38)) + ratingModel.ThreeStarCount = core.Int64Ptr(int64(38)) + ratingModel.FourStarCount = core.Int64Ptr(int64(38)) + Expect(ratingModel.OneStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.TwoStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.ThreeStarCount).To(Equal(core.Int64Ptr(int64(38)))) + Expect(ratingModel.FourStarCount).To(Equal(core.Int64Ptr(int64(38)))) + + // Construct an instance of the RepoInfo model + repoInfoModel := new(catalogmanagementv1.RepoInfo) + Expect(repoInfoModel).ToNot(BeNil()) + repoInfoModel.Token = core.StringPtr("testString") + repoInfoModel.Type = core.StringPtr("testString") + Expect(repoInfoModel.Token).To(Equal(core.StringPtr("testString"))) + Expect(repoInfoModel.Type).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the ReplaceOfferingOptions model + catalogIdentifier := "testString" + offeringID := "testString" + replaceOfferingOptionsModel := testService.NewReplaceOfferingOptions(catalogIdentifier, offeringID) + replaceOfferingOptionsModel.SetCatalogIdentifier("testString") + replaceOfferingOptionsModel.SetOfferingID("testString") + replaceOfferingOptionsModel.SetID("testString") + replaceOfferingOptionsModel.SetRev("testString") + replaceOfferingOptionsModel.SetURL("testString") + replaceOfferingOptionsModel.SetCrn("testString") + replaceOfferingOptionsModel.SetLabel("testString") + replaceOfferingOptionsModel.SetName("testString") + replaceOfferingOptionsModel.SetOfferingIconURL("testString") + replaceOfferingOptionsModel.SetOfferingDocsURL("testString") + replaceOfferingOptionsModel.SetOfferingSupportURL("testString") + replaceOfferingOptionsModel.SetTags([]string{"testString"}) + replaceOfferingOptionsModel.SetRating(ratingModel) + replaceOfferingOptionsModel.SetCreated(CreateMockDateTime()) + replaceOfferingOptionsModel.SetUpdated(CreateMockDateTime()) + replaceOfferingOptionsModel.SetShortDescription("testString") + replaceOfferingOptionsModel.SetLongDescription("testString") + replaceOfferingOptionsModel.SetFeatures([]catalogmanagementv1.Feature{*featureModel}) + replaceOfferingOptionsModel.SetKinds([]catalogmanagementv1.Kind{*kindModel}) + replaceOfferingOptionsModel.SetPermitRequestIbmPublicPublish(true) + replaceOfferingOptionsModel.SetIbmPublishApproved(true) + replaceOfferingOptionsModel.SetPublicPublishApproved(true) + replaceOfferingOptionsModel.SetPublicOriginalCrn("testString") + replaceOfferingOptionsModel.SetPublishPublicCrn("testString") + replaceOfferingOptionsModel.SetPortalApprovalRecord("testString") + replaceOfferingOptionsModel.SetPortalUiURL("testString") + replaceOfferingOptionsModel.SetCatalogID("testString") + replaceOfferingOptionsModel.SetCatalogName("testString") + replaceOfferingOptionsModel.SetMetadata(map[string]interface{}{"anyKey": "anyValue"}) + replaceOfferingOptionsModel.SetDisclaimer("testString") + replaceOfferingOptionsModel.SetHidden(true) + replaceOfferingOptionsModel.SetProvider("testString") + replaceOfferingOptionsModel.SetRepoInfo(repoInfoModel) + replaceOfferingOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(replaceOfferingOptionsModel).ToNot(BeNil()) + Expect(replaceOfferingOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Rev).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.URL).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Crn).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Label).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.OfferingIconURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.OfferingDocsURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.OfferingSupportURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Tags).To(Equal([]string{"testString"})) + Expect(replaceOfferingOptionsModel.Rating).To(Equal(ratingModel)) + Expect(replaceOfferingOptionsModel.Created).To(Equal(CreateMockDateTime())) + Expect(replaceOfferingOptionsModel.Updated).To(Equal(CreateMockDateTime())) + Expect(replaceOfferingOptionsModel.ShortDescription).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.LongDescription).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Features).To(Equal([]catalogmanagementv1.Feature{*featureModel})) + Expect(replaceOfferingOptionsModel.Kinds).To(Equal([]catalogmanagementv1.Kind{*kindModel})) + Expect(replaceOfferingOptionsModel.PermitRequestIbmPublicPublish).To(Equal(core.BoolPtr(true))) + Expect(replaceOfferingOptionsModel.IbmPublishApproved).To(Equal(core.BoolPtr(true))) + Expect(replaceOfferingOptionsModel.PublicPublishApproved).To(Equal(core.BoolPtr(true))) + Expect(replaceOfferingOptionsModel.PublicOriginalCrn).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.PublishPublicCrn).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.PortalApprovalRecord).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.PortalUiURL).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.CatalogID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.CatalogName).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Metadata).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(replaceOfferingOptionsModel.Disclaimer).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.Hidden).To(Equal(core.BoolPtr(true))) + Expect(replaceOfferingOptionsModel.Provider).To(Equal(core.StringPtr("testString"))) + Expect(replaceOfferingOptionsModel.RepoInfo).To(Equal(repoInfoModel)) + Expect(replaceOfferingOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewReplaceOperatorOptions successfully`, func() { + // Construct an instance of the ReplaceOperatorOptions model + xAuthRefreshToken := "testString" + replaceOperatorOptionsModel := testService.NewReplaceOperatorOptions(xAuthRefreshToken) + replaceOperatorOptionsModel.SetXAuthRefreshToken("testString") + replaceOperatorOptionsModel.SetClusterID("testString") + replaceOperatorOptionsModel.SetRegion("testString") + replaceOperatorOptionsModel.SetNamespaces([]string{"testString"}) + replaceOperatorOptionsModel.SetVersionLocatorID("testString") + replaceOperatorOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(replaceOperatorOptionsModel).ToNot(BeNil()) + Expect(replaceOperatorOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(replaceOperatorOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOperatorOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(replaceOperatorOptionsModel.Namespaces).To(Equal([]string{"testString"})) + Expect(replaceOperatorOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(replaceOperatorOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewSearchLicenseOfferingsOptions successfully`, func() { + // Construct an instance of the SearchLicenseOfferingsOptions model + q := "testString" + searchLicenseOfferingsOptionsModel := testService.NewSearchLicenseOfferingsOptions(q) + searchLicenseOfferingsOptionsModel.SetQ("testString") + searchLicenseOfferingsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(searchLicenseOfferingsOptionsModel).ToNot(BeNil()) + Expect(searchLicenseOfferingsOptionsModel.Q).To(Equal(core.StringPtr("testString"))) + Expect(searchLicenseOfferingsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewSearchLicenseVersionsOptions successfully`, func() { + // Construct an instance of the SearchLicenseVersionsOptions model + q := "testString" + searchLicenseVersionsOptionsModel := testService.NewSearchLicenseVersionsOptions(q) + searchLicenseVersionsOptionsModel.SetQ("testString") + searchLicenseVersionsOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(searchLicenseVersionsOptionsModel).ToNot(BeNil()) + Expect(searchLicenseVersionsOptionsModel.Q).To(Equal(core.StringPtr("testString"))) + Expect(searchLicenseVersionsOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewUpdateCatalogAccountOptions successfully`, func() { + // Construct an instance of the FilterTerms model + filterTermsModel := new(catalogmanagementv1.FilterTerms) + Expect(filterTermsModel).ToNot(BeNil()) + filterTermsModel.FilterTerms = []string{"testString"} + Expect(filterTermsModel.FilterTerms).To(Equal([]string{"testString"})) + + // Construct an instance of the CategoryFilter model + categoryFilterModel := new(catalogmanagementv1.CategoryFilter) + Expect(categoryFilterModel).ToNot(BeNil()) + categoryFilterModel.Include = core.BoolPtr(true) + categoryFilterModel.Filter = filterTermsModel + Expect(categoryFilterModel.Include).To(Equal(core.BoolPtr(true))) + Expect(categoryFilterModel.Filter).To(Equal(filterTermsModel)) + + // Construct an instance of the IDFilter model + idFilterModel := new(catalogmanagementv1.IDFilter) + Expect(idFilterModel).ToNot(BeNil()) + idFilterModel.Include = filterTermsModel + idFilterModel.Exclude = filterTermsModel + Expect(idFilterModel.Include).To(Equal(filterTermsModel)) + Expect(idFilterModel.Exclude).To(Equal(filterTermsModel)) + + // Construct an instance of the Filters model + filtersModel := new(catalogmanagementv1.Filters) + Expect(filtersModel).ToNot(BeNil()) + filtersModel.IncludeAll = core.BoolPtr(true) + filtersModel.CategoryFilters = make(map[string]catalogmanagementv1.CategoryFilter) + filtersModel.IdFilters = idFilterModel + Expect(filtersModel.IncludeAll).To(Equal(core.BoolPtr(true))) + Expect(filtersModel.CategoryFilters).To(Equal(make(map[string]catalogmanagementv1.CategoryFilter))) + Expect(filtersModel.IdFilters).To(Equal(idFilterModel)) + + // Construct an instance of the UpdateCatalogAccountOptions model + updateCatalogAccountOptionsModel := testService.NewUpdateCatalogAccountOptions() + updateCatalogAccountOptionsModel.SetID("testString") + updateCatalogAccountOptionsModel.SetAccountFilters(filtersModel) + updateCatalogAccountOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(updateCatalogAccountOptionsModel).ToNot(BeNil()) + Expect(updateCatalogAccountOptionsModel.ID).To(Equal(core.StringPtr("testString"))) + Expect(updateCatalogAccountOptionsModel.AccountFilters).To(Equal(filtersModel)) + Expect(updateCatalogAccountOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewUpdateOfferingIbmOptions successfully`, func() { + // Construct an instance of the UpdateOfferingIbmOptions model + catalogIdentifier := "testString" + offeringID := "testString" + approvalType := "ibm" + approved := "true" + updateOfferingIbmOptionsModel := testService.NewUpdateOfferingIbmOptions(catalogIdentifier, offeringID, approvalType, approved) + updateOfferingIbmOptionsModel.SetCatalogIdentifier("testString") + updateOfferingIbmOptionsModel.SetOfferingID("testString") + updateOfferingIbmOptionsModel.SetApprovalType("ibm") + updateOfferingIbmOptionsModel.SetApproved("true") + updateOfferingIbmOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(updateOfferingIbmOptionsModel).ToNot(BeNil()) + Expect(updateOfferingIbmOptionsModel.CatalogIdentifier).To(Equal(core.StringPtr("testString"))) + Expect(updateOfferingIbmOptionsModel.OfferingID).To(Equal(core.StringPtr("testString"))) + Expect(updateOfferingIbmOptionsModel.ApprovalType).To(Equal(core.StringPtr("ibm"))) + Expect(updateOfferingIbmOptionsModel.Approved).To(Equal(core.StringPtr("true"))) + Expect(updateOfferingIbmOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + It(`Invoke NewValidationInstallOptions successfully`, func() { + // Construct an instance of the DeployRequestBodySchematics model + deployRequestBodySchematicsModel := new(catalogmanagementv1.DeployRequestBodySchematics) + Expect(deployRequestBodySchematicsModel).ToNot(BeNil()) + deployRequestBodySchematicsModel.Name = core.StringPtr("testString") + deployRequestBodySchematicsModel.Description = core.StringPtr("testString") + deployRequestBodySchematicsModel.Tags = []string{"testString"} + deployRequestBodySchematicsModel.ResourceGroupID = core.StringPtr("testString") + Expect(deployRequestBodySchematicsModel.Name).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Description).To(Equal(core.StringPtr("testString"))) + Expect(deployRequestBodySchematicsModel.Tags).To(Equal([]string{"testString"})) + Expect(deployRequestBodySchematicsModel.ResourceGroupID).To(Equal(core.StringPtr("testString"))) + + // Construct an instance of the ValidationInstallOptions model + versionLocID := "testString" + xAuthRefreshToken := "testString" + validationInstallOptionsModel := testService.NewValidationInstallOptions(versionLocID, xAuthRefreshToken) + validationInstallOptionsModel.SetVersionLocID("testString") + validationInstallOptionsModel.SetXAuthRefreshToken("testString") + validationInstallOptionsModel.SetClusterID("testString") + validationInstallOptionsModel.SetRegion("testString") + validationInstallOptionsModel.SetNamespace("testString") + validationInstallOptionsModel.SetOverrideValues(map[string]interface{}{"anyKey": "anyValue"}) + validationInstallOptionsModel.SetEntitlementApikey("testString") + validationInstallOptionsModel.SetSchematics(deployRequestBodySchematicsModel) + validationInstallOptionsModel.SetScript("testString") + validationInstallOptionsModel.SetScriptID("testString") + validationInstallOptionsModel.SetVersionLocatorID("testString") + validationInstallOptionsModel.SetVcenterID("testString") + validationInstallOptionsModel.SetVcenterPassword("testString") + validationInstallOptionsModel.SetVcenterLocation("testString") + validationInstallOptionsModel.SetHeaders(map[string]string{"foo": "bar"}) + Expect(validationInstallOptionsModel).ToNot(BeNil()) + Expect(validationInstallOptionsModel.VersionLocID).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.XAuthRefreshToken).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.ClusterID).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.Region).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.Namespace).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.OverrideValues).To(Equal(map[string]interface{}{"anyKey": "anyValue"})) + Expect(validationInstallOptionsModel.EntitlementApikey).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.Schematics).To(Equal(deployRequestBodySchematicsModel)) + Expect(validationInstallOptionsModel.Script).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.ScriptID).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.VersionLocatorID).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.VcenterID).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.VcenterPassword).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.VcenterLocation).To(Equal(core.StringPtr("testString"))) + Expect(validationInstallOptionsModel.Headers).To(Equal(map[string]string{"foo": "bar"})) + }) + }) + }) + 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) + } +}